GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-08-13 20:26:03 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add support for NVCC5: most of the Core and part of LU are callable from CUDA code.

Browse Source 
Still a lot to do.
This commit is contained in:
Gael Guennebaud 2013-02-07 19:06:14 +01:00
parent e4ec63aee7
commit 5adcc6c7b4
36 changed files with 550 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Eigen/Core
View File

@ -49,6 +49,16 @@
#endif #endif
#endif #endif
// Handle NVCC/CUDA
#ifdef __CUDACC__
// Do not try to vectorize on CUDA!
#define EIGEN_DONT_VECTORIZE
// Do not try asserts on CUDA!
#define EIGEN_NO_DEBUG
// All functions callable from CUDA code must be qualified with __device__
#define EIGEN_DEVICE_FUNC __host__ __device__
#endif
#ifndef EIGEN_DONT_VECTORIZE #ifndef EIGEN_DONT_VECTORIZE
#if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER) #if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)

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

@ -69,6 +69,7 @@ class Array
* the usage of 'using'. This should be done only for operator=. * the usage of 'using'. This should be done only for operator=.
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived> &other) EIGEN_STRONG_INLINE Array& operator=(const EigenBase<OtherDerived> &other)
{ {
return Base::operator=(other); return Base::operator=(other);
@ -84,6 +85,7 @@ class Array
* remain row-vectors and vectors remain vectors. * remain row-vectors and vectors remain vectors.
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array& operator=(const ArrayBase<OtherDerived>& other) EIGEN_STRONG_INLINE Array& operator=(const ArrayBase<OtherDerived>& other)
{ {
return Base::_set(other); return Base::_set(other);
@ -92,6 +94,7 @@ class Array
/** 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_DEVICE_FUNC
EIGEN_STRONG_INLINE Array& operator=(const Array& other) EIGEN_STRONG_INLINE Array& operator=(const Array& other)
{ {
return Base::_set(other); return Base::_set(other);
@ -107,6 +110,7 @@ class Array
* *
* \sa resize(Index,Index) * \sa resize(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE explicit Array() : Base() EIGEN_STRONG_INLINE explicit Array() : Base()
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -116,6 +120,7 @@ class Array
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
// FIXME is it still needed ?? // FIXME is it still needed ??
/** \internal */ /** \internal */
EIGEN_DEVICE_FUNC
Array(internal::constructor_without_unaligned_array_assert) Array(internal::constructor_without_unaligned_array_assert)
: Base(internal::constructor_without_unaligned_array_assert()) : Base(internal::constructor_without_unaligned_array_assert())
{ {
@ -130,6 +135,7 @@ class Array
* it is redundant to pass the dimension here, so it makes more sense to use the default * it is redundant to pass the dimension here, so it makes more sense to use the default
* constructor Matrix() instead. * constructor Matrix() instead.
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE explicit Array(Index dim) EIGEN_STRONG_INLINE explicit Array(Index dim)
: Base(dim, RowsAtCompileTime == 1 ? 1 : dim, ColsAtCompileTime == 1 ? 1 : dim) : Base(dim, RowsAtCompileTime == 1 ? 1 : dim, ColsAtCompileTime == 1 ? 1 : dim)
{ {
@ -142,6 +148,7 @@ class Array
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename T0, typename T1> template<typename T0, typename T1>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1) EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -159,6 +166,7 @@ class Array
#endif #endif
/** constructs an initialized 3D vector with given coefficients */ /** constructs an initialized 3D vector with given coefficients */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2) EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -168,6 +176,7 @@ class Array
m_storage.data()[2] = val2; m_storage.data()[2] = val2;
} }
/** constructs an initialized 4D vector with given coefficients */ /** constructs an initialized 4D vector with given coefficients */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2, const Scalar& val3) EIGEN_STRONG_INLINE Array(const Scalar& val0, const Scalar& val1, const Scalar& val2, const Scalar& val3)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -178,10 +187,11 @@ class Array
m_storage.data()[3] = val3; m_storage.data()[3] = val3;
} }
explicit Array(const Scalar *data); EIGEN_DEVICE_FUNC explicit Array(const Scalar *data);
/** Constructor copying the value of the expression \a other */ /** Constructor copying the value of the expression \a other */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const ArrayBase<OtherDerived>& other) EIGEN_STRONG_INLINE Array(const ArrayBase<OtherDerived>& other)
: Base(other.rows() * other.cols(), other.rows(), other.cols()) : Base(other.rows() * other.cols(), other.rows(), other.cols())
{ {
@ -189,6 +199,7 @@ class Array
Base::_set_noalias(other); Base::_set_noalias(other);
} }
/** Copy constructor */ /** Copy constructor */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const Array& other) EIGEN_STRONG_INLINE Array(const Array& other)
: Base(other.rows() * other.cols(), other.rows(), other.cols()) : Base(other.rows() * other.cols(), other.rows(), other.cols())
{ {
@ -197,6 +208,7 @@ class Array
} }
/** Copy constructor with in-place evaluation */ /** Copy constructor with in-place evaluation */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const ReturnByValue<OtherDerived>& other) EIGEN_STRONG_INLINE Array(const ReturnByValue<OtherDerived>& other)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -206,6 +218,7 @@ class Array
/** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */ /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other) EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other)
: Base(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols()) : Base(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols())
{ {
@ -221,8 +234,8 @@ class Array
void swap(ArrayBase<OtherDerived> const & other) void swap(ArrayBase<OtherDerived> const & other)
{ this->_swap(other.derived()); } { this->_swap(other.derived()); }
inline Index innerStride() const { return 1; } EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; }
inline Index outerStride() const { return this->innerSize(); } EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); }
#ifdef EIGEN_ARRAY_PLUGIN #ifdef EIGEN_ARRAY_PLUGIN
#include EIGEN_ARRAY_PLUGIN #include EIGEN_ARRAY_PLUGIN

16
Eigen/src/Core/Assign.h
View File

@ -139,6 +139,7 @@ struct assign_DefaultTraversal_CompleteUnrolling
inner = Index % Derived1::InnerSizeAtCompileTime inner = Index % Derived1::InnerSizeAtCompileTime
}; };
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src) static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src)
{ {
dst.copyCoeffByOuterInner(outer, inner, src); dst.copyCoeffByOuterInner(outer, inner, src);
@ -149,12 +150,14 @@ struct assign_DefaultTraversal_CompleteUnrolling
template<typename Derived1, typename Derived2, int Stop> template<typename Derived1, typename Derived2, int Stop>
struct assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop> struct assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop>
{ {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &, const Derived2 &) {} static EIGEN_STRONG_INLINE void run(Derived1 &, const Derived2 &) {}
}; };
template<typename Derived1, typename Derived2, int Index, int Stop> template<typename Derived1, typename Derived2, int Index, int Stop>
struct assign_DefaultTraversal_InnerUnrolling struct assign_DefaultTraversal_InnerUnrolling
{ {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src, int outer) static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src, int outer)
{ {
dst.copyCoeffByOuterInner(outer, Index, src); dst.copyCoeffByOuterInner(outer, Index, src);
@ -165,6 +168,7 @@ struct assign_DefaultTraversal_InnerUnrolling
template<typename Derived1, typename Derived2, int Stop> template<typename Derived1, typename Derived2, int Stop>
struct assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, Stop, Stop> struct assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, Stop, Stop>
{ {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &, const Derived2 &, int) {} static EIGEN_STRONG_INLINE void run(Derived1 &, const Derived2 &, int) {}
}; };
@ -175,6 +179,7 @@ struct assign_DefaultTraversal_InnerUnrolling<Derived1, Derived2, Stop, Stop>
template<typename Derived1, typename Derived2, int Index, int Stop> template<typename Derived1, typename Derived2, int Index, int Stop>
struct assign_LinearTraversal_CompleteUnrolling struct assign_LinearTraversal_CompleteUnrolling
{ {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src) static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src)
{ {
dst.copyCoeff(Index, src); dst.copyCoeff(Index, src);
@ -185,6 +190,7 @@ struct assign_LinearTraversal_CompleteUnrolling
template<typename Derived1, typename Derived2, int Stop> template<typename Derived1, typename Derived2, int Stop>
struct assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop> struct assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, Stop, Stop>
{ {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &, const Derived2 &) {} static EIGEN_STRONG_INLINE void run(Derived1 &, const Derived2 &) {}
}; };
@ -249,6 +255,7 @@ struct assign_impl;
template<typename Derived1, typename Derived2, int Unrolling, int Version> template<typename Derived1, typename Derived2, int Unrolling, int Version>
struct assign_impl<Derived1, Derived2, InvalidTraversal, Unrolling, Version> struct assign_impl<Derived1, Derived2, InvalidTraversal, Unrolling, Version>
{ {
EIGEN_DEVICE_FUNC
static inline void run(Derived1 &, const Derived2 &) { } static inline void run(Derived1 &, const Derived2 &) { }
}; };
@ -256,6 +263,7 @@ template<typename Derived1, typename Derived2, int Version>
struct assign_impl<Derived1, Derived2, DefaultTraversal, NoUnrolling, Version> struct assign_impl<Derived1, Derived2, DefaultTraversal, NoUnrolling, Version>
{ {
typedef typename Derived1::Index Index; typedef typename Derived1::Index Index;
EIGEN_DEVICE_FUNC
static inline void run(Derived1 &dst, const Derived2 &src) static inline void run(Derived1 &dst, const Derived2 &src)
{ {
const Index innerSize = dst.innerSize(); const Index innerSize = dst.innerSize();
@ -269,6 +277,7 @@ struct assign_impl<Derived1, Derived2, DefaultTraversal, NoUnrolling, Version>
template<typename Derived1, typename Derived2, int Version> template<typename Derived1, typename Derived2, int Version>
struct assign_impl<Derived1, Derived2, DefaultTraversal, CompleteUnrolling, Version> struct assign_impl<Derived1, Derived2, DefaultTraversal, CompleteUnrolling, Version>
{ {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src) static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src)
{ {
assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> assign_DefaultTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime>
@ -280,6 +289,7 @@ template<typename Derived1, typename Derived2, int Version>
struct assign_impl<Derived1, Derived2, DefaultTraversal, InnerUnrolling, Version> struct assign_impl<Derived1, Derived2, DefaultTraversal, InnerUnrolling, Version>
{ {
typedef typename Derived1::Index Index; typedef typename Derived1::Index Index;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src) static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src)
{ {
const Index outerSize = dst.outerSize(); const Index outerSize = dst.outerSize();
@ -297,6 +307,7 @@ template<typename Derived1, typename Derived2, int Version>
struct assign_impl<Derived1, Derived2, LinearTraversal, NoUnrolling, Version> struct assign_impl<Derived1, Derived2, LinearTraversal, NoUnrolling, Version>
{ {
typedef typename Derived1::Index Index; typedef typename Derived1::Index Index;
EIGEN_DEVICE_FUNC
static inline void run(Derived1 &dst, const Derived2 &src) static inline void run(Derived1 &dst, const Derived2 &src)
{ {
const Index size = dst.size(); const Index size = dst.size();
@ -308,6 +319,7 @@ struct assign_impl<Derived1, Derived2, LinearTraversal, NoUnrolling, Version>
template<typename Derived1, typename Derived2, int Version> template<typename Derived1, typename Derived2, int Version>
struct assign_impl<Derived1, Derived2, LinearTraversal, CompleteUnrolling, Version> struct assign_impl<Derived1, Derived2, LinearTraversal, CompleteUnrolling, Version>
{ {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src) static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src)
{ {
assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime> assign_LinearTraversal_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime>
@ -519,18 +531,22 @@ struct assign_selector;
template<typename Derived, typename OtherDerived> template<typename Derived, typename OtherDerived>
struct assign_selector<Derived,OtherDerived,false,false> { struct assign_selector<Derived,OtherDerived,false,false> {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); } static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); }
}; };
template<typename Derived, typename OtherDerived> template<typename Derived, typename OtherDerived>
struct assign_selector<Derived,OtherDerived,true,false> { struct assign_selector<Derived,OtherDerived,true,false> {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.eval()); } static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.eval()); }
}; };
template<typename Derived, typename OtherDerived> template<typename Derived, typename OtherDerived>
struct assign_selector<Derived,OtherDerived,false,true> { struct assign_selector<Derived,OtherDerived,false,true> {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose()); } static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose()); }
}; };
template<typename Derived, typename OtherDerived> template<typename Derived, typename OtherDerived>
struct assign_selector<Derived,OtherDerived,true,true> { struct assign_selector<Derived,OtherDerived,true,true> {
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose().eval()); } static EIGEN_STRONG_INLINE Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose().eval()); }
}; };

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

@ -111,6 +111,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class
/** Column or Row constructor /** Column or Row constructor
*/ */
EIGEN_DEVICE_FUNC
inline Block(XprType& xpr, Index i) : Impl(xpr,i) inline Block(XprType& xpr, Index i) : Impl(xpr,i)
{ {
eigen_assert( (i>=0) && ( eigen_assert( (i>=0) && (
@ -120,6 +121,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class
/** Fixed-size constructor /** Fixed-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline Block(XprType& xpr, Index a_startRow, Index a_startCol) inline Block(XprType& xpr, Index a_startRow, Index a_startCol)
: Impl(xpr, a_startRow, a_startCol) : Impl(xpr, a_startRow, a_startCol)
{ {
@ -130,6 +132,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> class
/** Dynamic-size constructor /** Dynamic-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline Block(XprType& xpr, inline Block(XprType& xpr,
Index a_startRow, Index a_startCol, Index a_startRow, Index a_startCol,
Index blockRows, Index blockCols) Index blockRows, Index blockCols)
@ -153,8 +156,9 @@ class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Dense>
public: public:
typedef Impl Base; typedef Impl Base;
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl) EIGEN_INHERIT_ASSIGNMENT_OPERATORS(BlockImpl)
inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {} EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
inline BlockImpl(XprType& xpr, Index a_startRow, Index a_startCol) : Impl(xpr, a_startRow, a_startCol) {} EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index a_startRow, Index a_startCol) : Impl(xpr, a_startRow, a_startCol) {}
EIGEN_DEVICE_FUNC
inline BlockImpl(XprType& xpr, Index a_startRow, Index a_startCol, Index blockRows, Index blockCols) inline BlockImpl(XprType& xpr, Index a_startRow, Index a_startCol, Index blockRows, Index blockCols)
: Impl(xpr, a_startRow, a_startCol, blockRows, blockCols) {} : Impl(xpr, a_startRow, a_startCol, blockRows, blockCols) {}
}; };
@ -176,6 +180,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
/** Column or Row constructor /** Column or Row constructor
*/ */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index i) inline BlockImpl_dense(XprType& xpr, Index i)
: m_xpr(xpr), : m_xpr(xpr),
// It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime, // It is a row if and only if BlockRows==1 and BlockCols==XprType::ColsAtCompileTime,
@ -190,6 +195,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
/** Fixed-size constructor /** Fixed-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index a_startRow, Index a_startCol) inline BlockImpl_dense(XprType& xpr, Index a_startRow, Index a_startCol)
: m_xpr(xpr), m_startRow(a_startRow), m_startCol(a_startCol), : m_xpr(xpr), m_startRow(a_startRow), m_startCol(a_startCol),
m_blockRows(BlockRows), m_blockCols(BlockCols) m_blockRows(BlockRows), m_blockCols(BlockCols)
@ -197,6 +203,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
/** Dynamic-size constructor /** Dynamic-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, inline BlockImpl_dense(XprType& xpr,
Index a_startRow, Index a_startCol, Index a_startRow, Index a_startCol,
Index blockRows, Index blockCols) Index blockRows, Index blockCols)
@ -204,9 +211,10 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
m_blockRows(blockRows), m_blockCols(blockCols) m_blockRows(blockRows), m_blockCols(blockCols)
{} {}
inline Index rows() const { return m_blockRows.value(); } EIGEN_DEVICE_FUNC inline Index rows() const { return m_blockRows.value(); }
inline Index cols() const { return m_blockCols.value(); } EIGEN_DEVICE_FUNC inline Index cols() const { return m_blockCols.value(); }
EIGEN_DEVICE_FUNC
inline Scalar& coeffRef(Index rowId, Index colId) inline Scalar& coeffRef(Index rowId, Index colId)
{ {
EIGEN_STATIC_ASSERT_LVALUE(XprType) EIGEN_STATIC_ASSERT_LVALUE(XprType)
@ -214,17 +222,20 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value()); .coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
} }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index rowId, Index colId) const inline const Scalar& coeffRef(Index rowId, Index colId) const
{ {
return m_xpr.derived() return m_xpr.derived()
.coeffRef(rowId + m_startRow.value(), colId + m_startCol.value()); .coeffRef(rowId + m_startRow.value(), colId + m_startCol.value());
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const EIGEN_STRONG_INLINE const CoeffReturnType coeff(Index rowId, Index colId) const
{ {
return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value()); return m_xpr.coeff(rowId + m_startRow.value(), colId + m_startCol.value());
} }
EIGEN_DEVICE_FUNC
inline Scalar& coeffRef(Index index) inline Scalar& coeffRef(Index index)
{ {
EIGEN_STATIC_ASSERT_LVALUE(XprType) EIGEN_STATIC_ASSERT_LVALUE(XprType)
@ -233,6 +244,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
} }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index index) const inline const Scalar& coeffRef(Index index) const
{ {
return m_xpr.const_cast_derived() return m_xpr.const_cast_derived()
@ -240,6 +252,7 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
} }
EIGEN_DEVICE_FUNC
inline const CoeffReturnType coeff(Index index) const inline const CoeffReturnType coeff(Index index) const
{ {
return m_xpr return m_xpr
@ -279,21 +292,24 @@ template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel, bool H
#ifdef EIGEN_PARSED_BY_DOXYGEN #ifdef EIGEN_PARSED_BY_DOXYGEN
/** \sa MapBase::data() */ /** \sa MapBase::data() */
inline const Scalar* data() const; EIGEN_DEVICE_FUNC inline const Scalar* data() const;
inline Index innerStride() const; EIGEN_DEVICE_FUNC inline Index innerStride() const;
inline Index outerStride() const; EIGEN_DEVICE_FUNC inline Index outerStride() const;
#endif #endif
const typename internal::remove_all<typename XprType::Nested>::type& nestedExpression() const EIGEN_DEVICE_FUNC
const typename internal::remove_all<typename XprType::Nested>::type& nestedExpression() const
{ {
return m_xpr; return m_xpr;
} }
Index startRow() const EIGEN_DEVICE_FUNC
Index startRow() const
{ {
return m_startRow.value(); return m_startRow.value();
} }
EIGEN_DEVICE_FUNC
Index startCol() const Index startCol() const
{ {
return m_startCol.value(); return m_startCol.value();
@ -322,6 +338,7 @@ class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
/** Column or Row constructor /** Column or Row constructor
*/ */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index i) inline BlockImpl_dense(XprType& xpr, Index i)
: Base(internal::const_cast_ptr(&xpr.coeffRef( : Base(internal::const_cast_ptr(&xpr.coeffRef(
(BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0, (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? i : 0,
@ -335,6 +352,7 @@ class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
/** Fixed-size constructor /** Fixed-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol) inline BlockImpl_dense(XprType& xpr, Index startRow, Index startCol)
: Base(internal::const_cast_ptr(&xpr.coeffRef(startRow,startCol))), m_xpr(xpr) : Base(internal::const_cast_ptr(&xpr.coeffRef(startRow,startCol))), m_xpr(xpr)
{ {
@ -343,6 +361,7 @@ class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
/** Dynamic-size constructor /** Dynamic-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, inline BlockImpl_dense(XprType& xpr,
Index startRow, Index startCol, Index startRow, Index startCol,
Index blockRows, Index blockCols) Index blockRows, Index blockCols)
@ -352,12 +371,14 @@ class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
init(); init();
} }
const typename internal::remove_all<typename XprType::Nested>::type& nestedExpression() const EIGEN_DEVICE_FUNC
const typename internal::remove_all<typename XprType::Nested>::type& nestedExpression() const
{ {
return m_xpr; return m_xpr;
} }
/** \sa MapBase::innerStride() */ /** \sa MapBase::innerStride() */
EIGEN_DEVICE_FUNC
inline Index innerStride() const inline Index innerStride() const
{ {
return internal::traits<BlockType>::HasSameStorageOrderAsXprType return internal::traits<BlockType>::HasSameStorageOrderAsXprType
@ -366,6 +387,7 @@ class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
} }
/** \sa MapBase::outerStride() */ /** \sa MapBase::outerStride() */
EIGEN_DEVICE_FUNC
inline Index outerStride() const inline Index outerStride() const
{ {
return m_outerStride; return m_outerStride;
@ -379,6 +401,7 @@ class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
/** \internal used by allowAligned() */ /** \internal used by allowAligned() */
EIGEN_DEVICE_FUNC
inline BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols) inline BlockImpl_dense(XprType& xpr, const Scalar* data, Index blockRows, Index blockCols)
: Base(data, blockRows, blockCols), m_xpr(xpr) : Base(data, blockRows, blockCols), m_xpr(xpr)
{ {
@ -387,6 +410,7 @@ class BlockImpl_dense<XprType,BlockRows,BlockCols, InnerPanel,true>
#endif #endif
protected: protected:
EIGEN_DEVICE_FUNC
void init() void init()
{ {
m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType m_outerStride = internal::traits<BlockType>::HasSameStorageOrderAsXprType

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

@ -30,6 +30,7 @@ struct CommaInitializer
typedef typename XprType::Scalar Scalar; typedef typename XprType::Scalar Scalar;
typedef typename XprType::Index Index; typedef typename XprType::Index Index;
EIGEN_DEVICE_FUNC
inline CommaInitializer(XprType& xpr, const Scalar& s) inline CommaInitializer(XprType& xpr, const Scalar& s)
: m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1) : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1)
{ {
@ -37,6 +38,7 @@ struct CommaInitializer
} }
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other) inline CommaInitializer(XprType& xpr, const DenseBase<OtherDerived>& other)
: m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows()) : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
{ {
@ -44,6 +46,7 @@ struct CommaInitializer
} }
/* inserts a scalar value in the target matrix */ /* inserts a scalar value in the target matrix */
EIGEN_DEVICE_FUNC
CommaInitializer& operator,(const Scalar& s) CommaInitializer& operator,(const Scalar& s)
{ {
if (m_col==m_xpr.cols()) if (m_col==m_xpr.cols())
@ -63,6 +66,7 @@ struct CommaInitializer
/* inserts a matrix expression in the target matrix */ /* inserts a matrix expression in the target matrix */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
CommaInitializer& operator,(const DenseBase<OtherDerived>& other) CommaInitializer& operator,(const DenseBase<OtherDerived>& other)
{ {
if(other.cols()==0 || other.rows()==0) if(other.cols()==0 || other.rows()==0)
@ -88,6 +92,7 @@ struct CommaInitializer
return *this; return *this;
} }
EIGEN_DEVICE_FUNC
inline ~CommaInitializer() inline ~CommaInitializer()
{ {
eigen_assert((m_row+m_currentBlockRows) == m_xpr.rows() eigen_assert((m_row+m_currentBlockRows) == m_xpr.rows()
@ -102,6 +107,7 @@ struct CommaInitializer
* quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished()); * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
* \endcode * \endcode
*/ */
EIGEN_DEVICE_FUNC
inline XprType& finished() { return m_xpr; } inline XprType& finished() { return m_xpr; }
XprType& m_xpr; // target expression XprType& m_xpr; // target expression

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

@ -122,6 +122,7 @@ class CwiseBinaryOp : internal::no_assignment_operator,
typedef typename internal::remove_reference<LhsNested>::type _LhsNested; typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
typedef typename internal::remove_reference<RhsNested>::type _RhsNested; typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp()) EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
: m_lhs(aLhs), m_rhs(aRhs), m_functor(func) : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
{ {
@ -131,6 +132,7 @@ class CwiseBinaryOp : internal::no_assignment_operator,
eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols()); eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index rows() const { EIGEN_STRONG_INLINE Index rows() const {
// return the fixed size type if available to enable compile time optimizations // return the fixed size type if available to enable compile time optimizations
if (internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime==Dynamic) if (internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime==Dynamic)
@ -138,6 +140,7 @@ class CwiseBinaryOp : internal::no_assignment_operator,
else else
return m_lhs.rows(); return m_lhs.rows();
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index cols() const { EIGEN_STRONG_INLINE Index cols() const {
// return the fixed size type if available to enable compile time optimizations // return the fixed size type if available to enable compile time optimizations
if (internal::traits<typename internal::remove_all<LhsNested>::type>::ColsAtCompileTime==Dynamic) if (internal::traits<typename internal::remove_all<LhsNested>::type>::ColsAtCompileTime==Dynamic)
@ -147,10 +150,13 @@ class CwiseBinaryOp : internal::no_assignment_operator,
} }
/** \returns the left hand side nested expression */ /** \returns the left hand side nested expression */
EIGEN_DEVICE_FUNC
const _LhsNested& lhs() const { return m_lhs; } const _LhsNested& lhs() const { return m_lhs; }
/** \returns the right hand side nested expression */ /** \returns the right hand side nested expression */
EIGEN_DEVICE_FUNC
const _RhsNested& rhs() const { return m_rhs; } const _RhsNested& rhs() const { return m_rhs; }
/** \returns the functor representing the binary operation */ /** \returns the functor representing the binary operation */
EIGEN_DEVICE_FUNC
const BinaryOp& functor() const { return m_functor; } const BinaryOp& functor() const { return m_functor; }
protected: protected:
@ -169,6 +175,7 @@ class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Dense>
typedef typename internal::dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base; typedef typename internal::dense_xpr_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::type Base;
EIGEN_DENSE_PUBLIC_INTERFACE( Derived ) EIGEN_DENSE_PUBLIC_INTERFACE( Derived )
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const
{ {
return derived().functor()(derived().lhs().coeff(rowId, colId), return derived().functor()(derived().lhs().coeff(rowId, colId),
@ -182,6 +189,7 @@ class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Dense>
derived().rhs().template packet<LoadMode>(rowId, colId)); derived().rhs().template packet<LoadMode>(rowId, colId));
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar coeff(Index index) const EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
{ {
return derived().functor()(derived().lhs().coeff(index), return derived().functor()(derived().lhs().coeff(index),

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

@ -64,20 +64,26 @@ class CwiseUnaryOp : internal::no_assignment_operator,
typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base; typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base;
EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp) EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
EIGEN_DEVICE_FUNC
inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp()) inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
: m_xpr(xpr), m_functor(func) {} : m_xpr(xpr), m_functor(func) {}
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index rows() const { return m_xpr.rows(); } EIGEN_STRONG_INLINE Index rows() const { return m_xpr.rows(); }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index cols() const { return m_xpr.cols(); } EIGEN_STRONG_INLINE Index cols() const { return m_xpr.cols(); }
/** \returns the functor representing the unary operation */ /** \returns the functor representing the unary operation */
EIGEN_DEVICE_FUNC
const UnaryOp& functor() const { return m_functor; } const UnaryOp& functor() const { return m_functor; }
/** \returns the nested expression */ /** \returns the nested expression */
EIGEN_DEVICE_FUNC
const typename internal::remove_all<typename XprType::Nested>::type& const typename internal::remove_all<typename XprType::Nested>::type&
nestedExpression() const { return m_xpr; } nestedExpression() const { return m_xpr; }
/** \returns the nested expression */ /** \returns the nested expression */
EIGEN_DEVICE_FUNC
typename internal::remove_all<typename XprType::Nested>::type& typename internal::remove_all<typename XprType::Nested>::type&
nestedExpression() { return m_xpr.const_cast_derived(); } nestedExpression() { return m_xpr.const_cast_derived(); }
@ -98,6 +104,7 @@ class CwiseUnaryOpImpl<UnaryOp,XprType,Dense>
typedef typename internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base; typedef typename internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Derived) EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const
{ {
return derived().functor()(derived().nestedExpression().coeff(rowId, colId)); return derived().functor()(derived().nestedExpression().coeff(rowId, colId));
@ -109,12 +116,14 @@ class CwiseUnaryOpImpl<UnaryOp,XprType,Dense>
return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(rowId, colId)); return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(rowId, colId));
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar coeff(Index index) const EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
{ {
return derived().functor()(derived().nestedExpression().coeff(index)); return derived().functor()(derived().nestedExpression().coeff(index));
} }
template<int LoadMode> template<int LoadMode>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PacketScalar packet(Index index) const EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
{ {
return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(index)); return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(index));

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

@ -172,6 +172,7 @@ template<typename Derived> class DenseBase
/** \returns the number of nonzero coefficients which is in practice the number /** \returns the number of nonzero coefficients which is in practice the number
* of stored coefficients. */ * of stored coefficients. */
EIGEN_DEVICE_FUNC
inline Index nonZeros() const { return size(); } inline Index nonZeros() const { return size(); }
/** \returns true if either the number of rows or the number of columns is equal to 1. /** \returns true if either the number of rows or the number of columns is equal to 1.
* In other words, this function returns * In other words, this function returns
@ -183,6 +184,7 @@ template<typename Derived> class DenseBase
* \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension * \note For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension
* with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of columns for a
* column-major matrix, and the number of rows for a row-major matrix. */ * column-major matrix, and the number of rows for a row-major matrix. */
EIGEN_DEVICE_FUNC
Index outerSize() const Index outerSize() const
{ {
return IsVectorAtCompileTime ? 1 return IsVectorAtCompileTime ? 1
@ -194,6 +196,7 @@ template<typename Derived> class DenseBase
* \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension * \note For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension
* with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a * with respect to the \ref TopicStorageOrders "storage order", i.e., the number of rows for a
* column-major matrix, and the number of columns for a row-major matrix. */ * column-major matrix, and the number of columns for a row-major matrix. */
EIGEN_DEVICE_FUNC
Index innerSize() const Index innerSize() const
{ {
return IsVectorAtCompileTime ? this->size() return IsVectorAtCompileTime ? this->size()
@ -204,6 +207,7 @@ template<typename Derived> class DenseBase
* Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
* nothing else. * nothing else.
*/ */
EIGEN_DEVICE_FUNC
void resize(Index newSize) void resize(Index newSize)
{ {
EIGEN_ONLY_USED_FOR_DEBUG(newSize); EIGEN_ONLY_USED_FOR_DEBUG(newSize);
@ -214,6 +218,7 @@ template<typename Derived> class DenseBase
* Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does * Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does
* nothing else. * nothing else.
*/ */
EIGEN_DEVICE_FUNC
void resize(Index nbRows, Index nbCols) void resize(Index nbRows, Index nbCols)
{ {
EIGEN_ONLY_USED_FOR_DEBUG(nbRows); EIGEN_ONLY_USED_FOR_DEBUG(nbRows);
@ -237,42 +242,54 @@ template<typename Derived> class DenseBase
/** Copies \a other into *this. \returns a reference to *this. */ /** Copies \a other into *this. \returns a reference to *this. */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator=(const DenseBase<OtherDerived>& other); Derived& operator=(const DenseBase<OtherDerived>& other);
/** Special case of the template operator=, in order to prevent the compiler /** Special case of the template operator=, in order to prevent the compiler
* from generating a default operator= (issue hit with g++ 4.1) * from generating a default operator= (issue hit with g++ 4.1)
*/ */
EIGEN_DEVICE_FUNC
Derived& operator=(const DenseBase& other); Derived& operator=(const DenseBase& other);
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator=(const EigenBase<OtherDerived> &other); Derived& operator=(const EigenBase<OtherDerived> &other);
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator+=(const EigenBase<OtherDerived> &other); Derived& operator+=(const EigenBase<OtherDerived> &other);
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator-=(const EigenBase<OtherDerived> &other); Derived& operator-=(const EigenBase<OtherDerived> &other);
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator=(const ReturnByValue<OtherDerived>& func); Derived& operator=(const ReturnByValue<OtherDerived>& func);
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
/** Copies \a other into *this without evaluating other. \returns a reference to *this. */ /** Copies \a other into *this without evaluating other. \returns a reference to *this. */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& lazyAssign(const DenseBase<OtherDerived>& other); Derived& lazyAssign(const DenseBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN #endif // not EIGEN_PARSED_BY_DOXYGEN
EIGEN_DEVICE_FUNC
CommaInitializer<Derived> operator<< (const Scalar& s); CommaInitializer<Derived> operator<< (const Scalar& s);
template<unsigned int Added,unsigned int Removed> template<unsigned int Added,unsigned int Removed>
const Flagged<Derived, Added, Removed> flagged() const; const Flagged<Derived, Added, Removed> flagged() const;
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other); CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& other);
EIGEN_DEVICE_FUNC
Eigen::Transpose<Derived> transpose(); Eigen::Transpose<Derived> transpose();
typedef const Transpose<const Derived> ConstTransposeReturnType; typedef const Transpose<const Derived> ConstTransposeReturnType;
EIGEN_DEVICE_FUNC
ConstTransposeReturnType transpose() const; ConstTransposeReturnType transpose() const;
EIGEN_DEVICE_FUNC
void transposeInPlace(); void transposeInPlace();
#ifndef EIGEN_NO_DEBUG #ifndef EIGEN_NO_DEBUG
protected: protected:
@ -346,6 +363,7 @@ template<typename Derived> class DenseBase
* Notice that in the case of a plain matrix or vector (not an expression) this function just returns * Notice that in the case of a plain matrix or vector (not an expression) this function just returns
* a const reference, in order to avoid a useless copy. * a const reference, in order to avoid a useless copy.
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE EvalReturnType eval() const EIGEN_STRONG_INLINE EvalReturnType eval() const
{ {
// Even though MSVC does not honor strong inlining when the return type // Even though MSVC does not honor strong inlining when the return type
@ -380,14 +398,14 @@ template<typename Derived> class DenseBase
template<bool Enable> inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const; template<bool Enable> inline const typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf() const;
template<bool Enable> inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf(); template<bool Enable> inline typename internal::conditional<Enable,ForceAlignedAccess<Derived>,Derived&>::type forceAlignedAccessIf();
Scalar sum() const; EIGEN_DEVICE_FUNC Scalar sum() const;
Scalar mean() const; EIGEN_DEVICE_FUNC Scalar mean() const;
Scalar trace() const; EIGEN_DEVICE_FUNC Scalar trace() const;
Scalar prod() const; EIGEN_DEVICE_FUNC Scalar prod() const;
typename internal::traits<Derived>::Scalar minCoeff() const; EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar minCoeff() const;
typename internal::traits<Derived>::Scalar maxCoeff() const; EIGEN_DEVICE_FUNC typename internal::traits<Derived>::Scalar maxCoeff() const;
template<typename IndexType> template<typename IndexType>
typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const; typename internal::traits<Derived>::Scalar minCoeff(IndexType* row, IndexType* col) const;
@ -399,15 +417,18 @@ template<typename Derived> class DenseBase
typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const; typename internal::traits<Derived>::Scalar maxCoeff(IndexType* index) const;
template<typename BinaryOp> template<typename BinaryOp>
EIGEN_DEVICE_FUNC
typename internal::result_of<BinaryOp(typename internal::traits<Derived>::Scalar)>::type typename internal::result_of<BinaryOp(typename internal::traits<Derived>::Scalar)>::type
redux(const BinaryOp& func) const; redux(const BinaryOp& func) const;
template<typename Visitor> template<typename Visitor>
EIGEN_DEVICE_FUNC
void visit(Visitor& func) const; void visit(Visitor& func) const;
inline const WithFormat<Derived> format(const IOFormat& fmt) const; inline const WithFormat<Derived> format(const IOFormat& fmt) const;
/** \returns the unique coefficient of a 1x1 expression */ /** \returns the unique coefficient of a 1x1 expression */
EIGEN_DEVICE_FUNC
CoeffReturnType value() const CoeffReturnType value() const
{ {
EIGEN_STATIC_ASSERT_SIZE_1x1(Derived) EIGEN_STATIC_ASSERT_SIZE_1x1(Derived)
@ -417,8 +438,8 @@ template<typename Derived> class DenseBase
/////////// Array module /////////// /////////// Array module ///////////
bool all(void) const; bool all() const;
bool any(void) const; bool any() const;
Index count() const; Index count() const;
typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType; typedef VectorwiseOp<Derived, Horizontal> RowwiseReturnType;
@ -480,14 +501,16 @@ template<typename Derived> class DenseBase
// disable the use of evalTo for dense objects with a nice compilation error // disable the use of evalTo for dense objects with a nice compilation error
template<typename Dest> inline void evalTo(Dest& ) const template<typename Dest>
EIGEN_DEVICE_FUNC
inline void evalTo(Dest& ) const
{ {
EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS); EIGEN_STATIC_ASSERT((internal::is_same<Dest,void>::value),THE_EVAL_EVALTO_FUNCTION_SHOULD_NEVER_BE_CALLED_FOR_DENSE_OBJECTS);
} }
protected: protected:
/** Default constructor. Do nothing. */ /** Default constructor. Do nothing. */
DenseBase() EIGEN_DEVICE_FUNC DenseBase()
{ {
/* Just checks for self-consistency of the flags. /* Just checks for self-consistency of the flags.
* Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down
@ -500,9 +523,9 @@ template<typename Derived> class DenseBase
} }
private: private:
explicit DenseBase(int); EIGEN_DEVICE_FUNC explicit DenseBase(int);
DenseBase(int,int); EIGEN_DEVICE_FUNC DenseBase(int,int);
template<typename OtherDerived> explicit DenseBase(const DenseBase<OtherDerived>&); template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit DenseBase(const DenseBase<OtherDerived>&);
}; };
} // end namespace Eigen } // end namespace Eigen

33
Eigen/src/Core/DenseCoeffsBase.h
View File

@ -61,6 +61,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
using Base::size; using Base::size;
using Base::derived; using Base::derived;
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const EIGEN_STRONG_INLINE Index rowIndexByOuterInner(Index outer, Index inner) const
{ {
return int(Derived::RowsAtCompileTime) == 1 ? 0 return int(Derived::RowsAtCompileTime) == 1 ? 0
@ -69,6 +70,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
: inner; : inner;
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const EIGEN_STRONG_INLINE Index colIndexByOuterInner(Index outer, Index inner) const
{ {
return int(Derived::ColsAtCompileTime) == 1 ? 0 return int(Derived::ColsAtCompileTime) == 1 ? 0
@ -91,6 +93,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
* *
* \sa operator()(Index,Index) const, coeffRef(Index,Index), coeff(Index) const * \sa operator()(Index,Index) const, coeffRef(Index,Index), coeff(Index) const
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
{ {
eigen_internal_assert(row >= 0 && row < rows() eigen_internal_assert(row >= 0 && row < rows()
@ -98,6 +101,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
return derived().coeff(row, col); return derived().coeff(row, col);
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const EIGEN_STRONG_INLINE CoeffReturnType coeffByOuterInner(Index outer, Index inner) const
{ {
return coeff(rowIndexByOuterInner(outer, inner), return coeff(rowIndexByOuterInner(outer, inner),
@ -108,6 +112,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
* *
* \sa operator()(Index,Index), operator[](Index) * \sa operator()(Index,Index), operator[](Index)
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const EIGEN_STRONG_INLINE CoeffReturnType operator()(Index row, Index col) const
{ {
eigen_assert(row >= 0 && row < rows() eigen_assert(row >= 0 && row < rows()
@ -130,6 +135,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
* \sa operator[](Index) const, coeffRef(Index), coeff(Index,Index) const * \sa operator[](Index) const, coeffRef(Index), coeff(Index,Index) const
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType EIGEN_STRONG_INLINE CoeffReturnType
coeff(Index index) const coeff(Index index) const
{ {
@ -146,6 +152,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
* z() const, w() const * z() const, w() const
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType EIGEN_STRONG_INLINE CoeffReturnType
operator[](Index index) const operator[](Index index) const
{ {
@ -167,6 +174,7 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
* z() const, w() const * z() const, w() const
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType EIGEN_STRONG_INLINE CoeffReturnType
operator()(Index index) const operator()(Index index) const
{ {
@ -176,21 +184,25 @@ class DenseCoeffsBase<Derived,ReadOnlyAccessors> : public EigenBase<Derived>
/** equivalent to operator[](0). */ /** equivalent to operator[](0). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType EIGEN_STRONG_INLINE CoeffReturnType
x() const { return (*this)[0]; } x() const { return (*this)[0]; }
/** equivalent to operator[](1). */ /** equivalent to operator[](1). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType EIGEN_STRONG_INLINE CoeffReturnType
y() const { return (*this)[1]; } y() const { return (*this)[1]; }
/** equivalent to operator[](2). */ /** equivalent to operator[](2). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType EIGEN_STRONG_INLINE CoeffReturnType
z() const { return (*this)[2]; } z() const { return (*this)[2]; }
/** equivalent to operator[](3). */ /** equivalent to operator[](3). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE CoeffReturnType EIGEN_STRONG_INLINE CoeffReturnType
w() const { return (*this)[3]; } w() const { return (*this)[3]; }
@ -311,6 +323,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
* *
* \sa operator()(Index,Index), coeff(Index, Index) const, coeffRef(Index) * \sa operator()(Index,Index), coeff(Index, Index) const, coeffRef(Index)
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col) EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
{ {
eigen_internal_assert(row >= 0 && row < rows() eigen_internal_assert(row >= 0 && row < rows()
@ -318,6 +331,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
return derived().coeffRef(row, col); return derived().coeffRef(row, col);
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
coeffRefByOuterInner(Index outer, Index inner) coeffRefByOuterInner(Index outer, Index inner)
{ {
@ -330,6 +344,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
* \sa operator[](Index) * \sa operator[](Index)
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
operator()(Index row, Index col) operator()(Index row, Index col)
{ {
@ -354,6 +369,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
* \sa operator[](Index), coeff(Index) const, coeffRef(Index,Index) * \sa operator[](Index), coeff(Index) const, coeffRef(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
coeffRef(Index index) coeffRef(Index index)
{ {
@ -368,6 +384,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
* \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w() * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
operator[](Index index) operator[](Index index)
{ {
@ -388,6 +405,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
* \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w() * \sa operator[](Index) const, operator()(Index,Index), x(), y(), z(), w()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
operator()(Index index) operator()(Index index)
{ {
@ -397,21 +415,25 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
/** equivalent to operator[](0). */ /** equivalent to operator[](0). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
x() { return (*this)[0]; } x() { return (*this)[0]; }
/** equivalent to operator[](1). */ /** equivalent to operator[](1). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
y() { return (*this)[1]; } y() { return (*this)[1]; }
/** equivalent to operator[](2). */ /** equivalent to operator[](2). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
z() { return (*this)[2]; } z() { return (*this)[2]; }
/** equivalent to operator[](3). */ /** equivalent to operator[](3). */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& EIGEN_STRONG_INLINE Scalar&
w() { return (*this)[3]; } w() { return (*this)[3]; }
@ -473,6 +495,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, const DenseBase<OtherDerived>& other) EIGEN_STRONG_INLINE void copyCoeff(Index row, Index col, const DenseBase<OtherDerived>& other)
{ {
eigen_internal_assert(row >= 0 && row < rows() eigen_internal_assert(row >= 0 && row < rows()
@ -489,6 +512,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void copyCoeff(Index index, const DenseBase<OtherDerived>& other) EIGEN_STRONG_INLINE void copyCoeff(Index index, const DenseBase<OtherDerived>& other)
{ {
eigen_internal_assert(index >= 0 && index < size()); eigen_internal_assert(index >= 0 && index < size());
@ -497,6 +521,7 @@ class DenseCoeffsBase<Derived, WriteAccessors> : public DenseCoeffsBase<Derived,
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void copyCoeffByOuterInner(Index outer, Index inner, const DenseBase<OtherDerived>& other) EIGEN_STRONG_INLINE void copyCoeffByOuterInner(Index outer, Index inner, const DenseBase<OtherDerived>& other)
{ {
const Index row = rowIndexByOuterInner(outer,inner); const Index row = rowIndexByOuterInner(outer,inner);
@ -581,6 +606,7 @@ class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived
* *
* \sa outerStride(), rowStride(), colStride() * \sa outerStride(), rowStride(), colStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index innerStride() const inline Index innerStride() const
{ {
return derived().innerStride(); return derived().innerStride();
@ -591,6 +617,7 @@ class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived
* *
* \sa innerStride(), rowStride(), colStride() * \sa innerStride(), rowStride(), colStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index outerStride() const inline Index outerStride() const
{ {
return derived().outerStride(); return derived().outerStride();
@ -606,6 +633,7 @@ class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived
* *
* \sa innerStride(), outerStride(), colStride() * \sa innerStride(), outerStride(), colStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index rowStride() const inline Index rowStride() const
{ {
return Derived::IsRowMajor ? outerStride() : innerStride(); return Derived::IsRowMajor ? outerStride() : innerStride();
@ -615,6 +643,7 @@ class DenseCoeffsBase<Derived, DirectAccessors> : public DenseCoeffsBase<Derived
* *
* \sa innerStride(), outerStride(), rowStride() * \sa innerStride(), outerStride(), rowStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index colStride() const inline Index colStride() const
{ {
return Derived::IsRowMajor ? innerStride() : outerStride(); return Derived::IsRowMajor ? innerStride() : outerStride();
@ -652,6 +681,7 @@ class DenseCoeffsBase<Derived, DirectWriteAccessors>
* *
* \sa outerStride(), rowStride(), colStride() * \sa outerStride(), rowStride(), colStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index innerStride() const inline Index innerStride() const
{ {
return derived().innerStride(); return derived().innerStride();
@ -662,6 +692,7 @@ class DenseCoeffsBase<Derived, DirectWriteAccessors>
* *
* \sa innerStride(), rowStride(), colStride() * \sa innerStride(), rowStride(), colStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index outerStride() const inline Index outerStride() const
{ {
return derived().outerStride(); return derived().outerStride();
@ -677,6 +708,7 @@ class DenseCoeffsBase<Derived, DirectWriteAccessors>
* *
* \sa innerStride(), outerStride(), colStride() * \sa innerStride(), outerStride(), colStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index rowStride() const inline Index rowStride() const
{ {
return Derived::IsRowMajor ? outerStride() : innerStride(); return Derived::IsRowMajor ? outerStride() : innerStride();
@ -686,6 +718,7 @@ class DenseCoeffsBase<Derived, DirectWriteAccessors>
* *
* \sa innerStride(), outerStride(), rowStride() * \sa innerStride(), outerStride(), rowStride()
*/ */
EIGEN_DEVICE_FUNC
inline Index colStride() const inline Index colStride() const
{ {
return Derived::IsRowMajor ? innerStride() : outerStride(); return Derived::IsRowMajor ? innerStride() : outerStride();

32
Eigen/src/Core/DenseStorage.h
View File

@ -36,12 +36,14 @@ struct plain_array
{ {
T array[Size]; T array[Size];
plain_array() EIGEN_DEVICE_FUNC
plain_array()
{ {
EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG); EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
} }
plain_array(constructor_without_unaligned_array_assert) EIGEN_DEVICE_FUNC
plain_array(constructor_without_unaligned_array_assert)
{ {
EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG); EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
} }
@ -73,12 +75,14 @@ struct plain_array<T, Size, MatrixOrArrayOptions, 16>
{ {
EIGEN_USER_ALIGN16 T array[Size]; EIGEN_USER_ALIGN16 T array[Size];
EIGEN_DEVICE_FUNC
plain_array() plain_array()
{ {
EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(0xf); EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(0xf);
EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG); EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
} }
EIGEN_DEVICE_FUNC
plain_array(constructor_without_unaligned_array_assert) plain_array(constructor_without_unaligned_array_assert)
{ {
EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG); EIGEN_STATIC_ASSERT(Size * sizeof(T) <= 128 * 128 * 8, OBJECT_ALLOCATED_ON_STACK_IS_TOO_BIG);
@ -89,8 +93,8 @@ template <typename T, int MatrixOrArrayOptions, int Alignment>
struct plain_array<T, 0, MatrixOrArrayOptions, Alignment> struct plain_array<T, 0, MatrixOrArrayOptions, Alignment>
{ {
EIGEN_USER_ALIGN16 T array[1]; EIGEN_USER_ALIGN16 T array[1];
plain_array() {} EIGEN_DEVICE_FUNC plain_array() {}
plain_array(constructor_without_unaligned_array_assert) {} EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert) {}
}; };
} // end namespace internal } // end namespace internal
@ -114,17 +118,17 @@ template<typename T, int Size, int _Rows, int _Cols, int _Options> class DenseSt
{ {
internal::plain_array<T,Size,_Options> m_data; internal::plain_array<T,Size,_Options> m_data;
public: public:
inline explicit DenseStorage() {} EIGEN_DEVICE_FUNC inline explicit DenseStorage() {}
inline DenseStorage(internal::constructor_without_unaligned_array_assert) EIGEN_DEVICE_FUNC inline DenseStorage(internal::constructor_without_unaligned_array_assert)
: m_data(internal::constructor_without_unaligned_array_assert()) {} : m_data(internal::constructor_without_unaligned_array_assert()) {}
inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {} EIGEN_DEVICE_FUNC inline DenseStorage(DenseIndex,DenseIndex,DenseIndex) {}
inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); } EIGEN_DEVICE_FUNC inline void swap(DenseStorage& other) { std::swap(m_data,other.m_data); }
static inline DenseIndex rows(void) {return _Rows;} EIGEN_DEVICE_FUNC static inline DenseIndex rows(void) {return _Rows;}
static inline DenseIndex cols(void) {return _Cols;} EIGEN_DEVICE_FUNC static inline DenseIndex cols(void) {return _Cols;}
inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {} EIGEN_DEVICE_FUNC inline void conservativeResize(DenseIndex,DenseIndex,DenseIndex) {}
inline void resize(DenseIndex,DenseIndex,DenseIndex) {} EIGEN_DEVICE_FUNC inline void resize(DenseIndex,DenseIndex,DenseIndex) {}
inline const T *data() const { return m_data.array; } EIGEN_DEVICE_FUNC inline const T *data() const { return m_data.array; }
inline T *data() { return m_data.array; } EIGEN_DEVICE_FUNC inline T *data() { return m_data.array; }
}; };
// null matrix // null matrix

25
Eigen/src/Core/EigenBase.h
View File

@ -31,29 +31,40 @@ template<typename Derived> struct EigenBase
typedef typename internal::traits<Derived>::Index Index; typedef typename internal::traits<Derived>::Index Index;
/** \returns a reference to the derived object */ /** \returns a reference to the derived object */
EIGEN_DEVICE_FUNC
Derived& derived() { return *static_cast<Derived*>(this); } Derived& derived() { return *static_cast<Derived*>(this); }
/** \returns a const reference to the derived object */ /** \returns a const reference to the derived object */
EIGEN_DEVICE_FUNC
const Derived& derived() const { return *static_cast<const Derived*>(this); } const Derived& derived() const { return *static_cast<const Derived*>(this); }
EIGEN_DEVICE_FUNC
inline Derived& const_cast_derived() const inline Derived& const_cast_derived() const
{ return *static_cast<Derived*>(const_cast<EigenBase*>(this)); } { return *static_cast<Derived*>(const_cast<EigenBase*>(this)); }
EIGEN_DEVICE_FUNC
inline const Derived& const_derived() const inline const Derived& const_derived() const
{ return *static_cast<const Derived*>(this); } { return *static_cast<const Derived*>(this); }
/** \returns the number of rows. \sa cols(), RowsAtCompileTime */ /** \returns the number of rows. \sa cols(), RowsAtCompileTime */
EIGEN_DEVICE_FUNC
inline Index rows() const { return derived().rows(); } inline Index rows() const { return derived().rows(); }
/** \returns the number of columns. \sa rows(), ColsAtCompileTime*/ /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/
EIGEN_DEVICE_FUNC
inline Index cols() const { return derived().cols(); } inline Index cols() const { return derived().cols(); }
/** \returns the number of coefficients, which is rows()*cols(). /** \returns the number of coefficients, which is rows()*cols().
* \sa rows(), cols(), SizeAtCompileTime. */ * \sa rows(), cols(), SizeAtCompileTime. */
EIGEN_DEVICE_FUNC
inline Index size() const { return rows() * cols(); } inline Index size() const { return rows() * cols(); }
/** \internal Don't use it, but do the equivalent: \code dst = *this; \endcode */ /** \internal Don't use it, but do the equivalent: \code dst = *this; \endcode */
template<typename Dest> inline void evalTo(Dest& dst) const template<typename Dest>
EIGEN_DEVICE_FUNC
inline void evalTo(Dest& dst) const
{ derived().evalTo(dst); } { derived().evalTo(dst); }
/** \internal Don't use it, but do the equivalent: \code dst += *this; \endcode */ /** \internal Don't use it, but do the equivalent: \code dst += *this; \endcode */
template<typename Dest> inline void addTo(Dest& dst) const template<typename Dest>
EIGEN_DEVICE_FUNC
inline void addTo(Dest& dst) const
{ {
// This is the default implementation, // This is the default implementation,
// derived class can reimplement it in a more optimized way. // derived class can reimplement it in a more optimized way.
@ -63,7 +74,9 @@ template<typename Derived> struct EigenBase
} }
/** \internal Don't use it, but do the equivalent: \code dst -= *this; \endcode */ /** \internal Don't use it, but do the equivalent: \code dst -= *this; \endcode */
template<typename Dest> inline void subTo(Dest& dst) const template<typename Dest>
EIGEN_DEVICE_FUNC
inline void subTo(Dest& dst) const
{ {
// This is the default implementation, // This is the default implementation,
// derived class can reimplement it in a more optimized way. // derived class can reimplement it in a more optimized way.
@ -73,7 +86,8 @@ template<typename Derived> struct EigenBase
} }
/** \internal Don't use it, but do the equivalent: \code dst.applyOnTheRight(*this); \endcode */ /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheRight(*this); \endcode */
template<typename Dest> inline void applyThisOnTheRight(Dest& dst) const template<typename Dest>
EIGEN_DEVICE_FUNC inline void applyThisOnTheRight(Dest& dst) const
{ {
// This is the default implementation, // This is the default implementation,
// derived class can reimplement it in a more optimized way. // derived class can reimplement it in a more optimized way.
@ -81,7 +95,8 @@ template<typename Derived> struct EigenBase
} }
/** \internal Don't use it, but do the equivalent: \code dst.applyOnTheLeft(*this); \endcode */ /** \internal Don't use it, but do the equivalent: \code dst.applyOnTheLeft(*this); \endcode */
template<typename Dest> inline void applyThisOnTheLeft(Dest& dst) const template<typename Dest>
EIGEN_DEVICE_FUNC inline void applyThisOnTheLeft(Dest& dst) const
{ {
// This is the default implementation, // This is the default implementation,
// derived class can reimplement it in a more optimized way. // derived class can reimplement it in a more optimized way.

91
Eigen/src/Core/Functors.h
View File

@ -23,7 +23,7 @@ namespace internal {
*/ */
template<typename Scalar> struct scalar_sum_op { template<typename Scalar> struct scalar_sum_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_sum_op)
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
{ return internal::padd(a,b); } { return internal::padd(a,b); }
@ -51,7 +51,7 @@ template<typename LhsScalar,typename RhsScalar> struct scalar_product_op {
}; };
typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type; typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_product_op)
EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a * b; }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
{ return internal::pmul(a,b); } { return internal::pmul(a,b); }
@ -81,7 +81,7 @@ template<typename LhsScalar,typename RhsScalar> struct scalar_conj_product_op {
typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type; typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_conj_product_op)
EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const
{ return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); } { return conj_helper<LhsScalar,RhsScalar,Conj,false>().pmul(a,b); }
template<typename Packet> template<typename Packet>
@ -103,7 +103,7 @@ struct functor_traits<scalar_conj_product_op<LhsScalar,RhsScalar> > {
*/ */
template<typename Scalar> struct scalar_min_op { template<typename Scalar> struct scalar_min_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_min_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_min_op)
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { using std::min; return (min)(a, b); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { using std::min; return (min)(a, b); }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
{ return internal::pmin(a,b); } { return internal::pmin(a,b); }
@ -126,7 +126,7 @@ struct functor_traits<scalar_min_op<Scalar> > {
*/ */
template<typename Scalar> struct scalar_max_op { template<typename Scalar> struct scalar_max_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_max_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_max_op)
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { using std::max; return (max)(a, b); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { using std::max; return (max)(a, b); }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
{ return internal::pmax(a,b); } { return internal::pmax(a,b); }
@ -150,7 +150,7 @@ struct functor_traits<scalar_max_op<Scalar> > {
template<typename Scalar> struct scalar_hypot_op { template<typename Scalar> struct scalar_hypot_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_hypot_op)
// typedef typename NumTraits<Scalar>::Real result_type; // typedef typename NumTraits<Scalar>::Real result_type;
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& _x, const Scalar& _y) const EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& _x, const Scalar& _y) const
{ {
using std::max; using std::max;
using std::min; using std::min;
@ -170,7 +170,7 @@ struct functor_traits<scalar_hypot_op<Scalar> > {
*/ */
template<typename Scalar, typename OtherScalar> struct scalar_binary_pow_op { template<typename Scalar, typename OtherScalar> struct scalar_binary_pow_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_binary_pow_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_binary_pow_op)
inline Scalar operator() (const Scalar& a, const OtherScalar& b) const { return internal::pow(a, b); } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a, const OtherScalar& b) const { return internal::pow(a, b); }
}; };
template<typename Scalar, typename OtherScalar> template<typename Scalar, typename OtherScalar>
struct functor_traits<scalar_binary_pow_op<Scalar,OtherScalar> > { struct functor_traits<scalar_binary_pow_op<Scalar,OtherScalar> > {
@ -186,7 +186,7 @@ struct functor_traits<scalar_binary_pow_op<Scalar,OtherScalar> > {
*/ */
template<typename Scalar> struct scalar_difference_op { template<typename Scalar> struct scalar_difference_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_difference_op)
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
{ return internal::psub(a,b); } { return internal::psub(a,b); }
@ -211,7 +211,7 @@ template<typename LhsScalar,typename RhsScalar> struct scalar_quotient_op {
}; };
typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type; typedef typename scalar_product_traits<LhsScalar,RhsScalar>::ReturnType result_type;
EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_quotient_op)
EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, const RhsScalar& b) const { return a / b; }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet& b) const
{ return internal::pdiv(a,b); } { return internal::pdiv(a,b); }
@ -233,7 +233,7 @@ struct functor_traits<scalar_quotient_op<LhsScalar,RhsScalar> > {
*/ */
struct scalar_boolean_and_op { struct scalar_boolean_and_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_and_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_and_op)
EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a && b; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a && b; }
}; };
template<> struct functor_traits<scalar_boolean_and_op> { template<> struct functor_traits<scalar_boolean_and_op> {
enum { enum {
@ -249,7 +249,7 @@ template<> struct functor_traits<scalar_boolean_and_op> {
*/ */
struct scalar_boolean_or_op { struct scalar_boolean_or_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_or_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_boolean_or_op)
EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a || b; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator() (const bool& a, const bool& b) const { return a || b; }
}; };
template<> struct functor_traits<scalar_boolean_or_op> { template<> struct functor_traits<scalar_boolean_or_op> {
enum { enum {
@ -267,7 +267,7 @@ template<> struct functor_traits<scalar_boolean_or_op> {
*/ */
template<typename Scalar> struct scalar_opposite_op { template<typename Scalar> struct scalar_opposite_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_opposite_op)
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { return -a; }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
{ return internal::pnegate(a); } { return internal::pnegate(a); }
@ -287,7 +287,7 @@ struct functor_traits<scalar_opposite_op<Scalar> >
template<typename Scalar> struct scalar_abs_op { template<typename Scalar> struct scalar_abs_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_abs_op)
typedef typename NumTraits<Scalar>::Real result_type; typedef typename NumTraits<Scalar>::Real result_type;
EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { using std::abs; return abs(a); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { using std::abs; return abs(a); }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
{ return internal::pabs(a); } { return internal::pabs(a); }
@ -309,7 +309,7 @@ struct functor_traits<scalar_abs_op<Scalar> >
template<typename Scalar> struct scalar_abs2_op { template<typename Scalar> struct scalar_abs2_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_abs2_op)
typedef typename NumTraits<Scalar>::Real result_type; typedef typename NumTraits<Scalar>::Real result_type;
EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return internal::abs2(a); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const result_type operator() (const Scalar& a) const { return internal::abs2(a); }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
{ return internal::pmul(a,a); } { return internal::pmul(a,a); }
@ -325,7 +325,7 @@ struct functor_traits<scalar_abs2_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_conjugate_op { template<typename Scalar> struct scalar_conjugate_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_conjugate_op)
EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { using internal::conj; return conj(a); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { using internal::conj; return conj(a); }
template<typename Packet> template<typename Packet>
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); } EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const { return internal::pconj(a); }
}; };
@ -347,7 +347,7 @@ template<typename Scalar, typename NewType>
struct scalar_cast_op { struct scalar_cast_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_cast_op)
typedef NewType result_type; typedef NewType result_type;
EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const NewType operator() (const Scalar& a) const { return cast<Scalar, NewType>(a); }
}; };
template<typename Scalar, typename NewType> template<typename Scalar, typename NewType>
struct functor_traits<scalar_cast_op<Scalar,NewType> > struct functor_traits<scalar_cast_op<Scalar,NewType> >
@ -362,7 +362,7 @@ template<typename Scalar>
struct scalar_real_op { struct scalar_real_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_real_op)
typedef typename NumTraits<Scalar>::Real result_type; typedef typename NumTraits<Scalar>::Real result_type;
EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::real(a); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::real(a); }
}; };
template<typename Scalar> template<typename Scalar>
struct functor_traits<scalar_real_op<Scalar> > struct functor_traits<scalar_real_op<Scalar> >
@ -377,7 +377,7 @@ template<typename Scalar>
struct scalar_imag_op { struct scalar_imag_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_op)
typedef typename NumTraits<Scalar>::Real result_type; typedef typename NumTraits<Scalar>::Real result_type;
EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::imag(a); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar& a) const { return internal::imag(a); }
}; };
template<typename Scalar> template<typename Scalar>
struct functor_traits<scalar_imag_op<Scalar> > struct functor_traits<scalar_imag_op<Scalar> >
@ -392,7 +392,7 @@ template<typename Scalar>
struct scalar_real_ref_op { struct scalar_real_ref_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_real_ref_op)
typedef typename NumTraits<Scalar>::Real result_type; typedef typename NumTraits<Scalar>::Real result_type;
EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::real_ref(*const_cast<Scalar*>(&a)); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::real_ref(*const_cast<Scalar*>(&a)); }
}; };
template<typename Scalar> template<typename Scalar>
struct functor_traits<scalar_real_ref_op<Scalar> > struct functor_traits<scalar_real_ref_op<Scalar> >
@ -407,7 +407,7 @@ template<typename Scalar>
struct scalar_imag_ref_op { struct scalar_imag_ref_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_imag_ref_op)
typedef typename NumTraits<Scalar>::Real result_type; typedef typename NumTraits<Scalar>::Real result_type;
EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::imag_ref(*const_cast<Scalar*>(&a)); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type& operator() (const Scalar& a) const { return internal::imag_ref(*const_cast<Scalar*>(&a)); }
}; };
template<typename Scalar> template<typename Scalar>
struct functor_traits<scalar_imag_ref_op<Scalar> > struct functor_traits<scalar_imag_ref_op<Scalar> >
@ -421,7 +421,7 @@ struct functor_traits<scalar_imag_ref_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_exp_op { template<typename Scalar> struct scalar_exp_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_exp_op)
inline const Scalar operator() (const Scalar& a) const { using std::exp; return exp(a); } EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { using std::exp; return exp(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::pexp(a); } inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
}; };
@ -437,7 +437,7 @@ struct functor_traits<scalar_exp_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_log_op { template<typename Scalar> struct scalar_log_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_log_op)
inline const Scalar operator() (const Scalar& a) const { using std::log; return log(a); } EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { using std::log; return log(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::plog(a); } inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
}; };
@ -462,8 +462,11 @@ template<typename Scalar>
struct scalar_multiple_op { struct scalar_multiple_op {
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
// FIXME default copy constructors seems bugged with std::complex<> // FIXME default copy constructors seems bugged with std::complex<>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE scalar_multiple_op(const scalar_multiple_op& other) : m_other(other.m_other) { } EIGEN_STRONG_INLINE scalar_multiple_op(const scalar_multiple_op& other) : m_other(other.m_other) { }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE scalar_multiple_op(const Scalar& other) : m_other(other) { } EIGEN_STRONG_INLINE scalar_multiple_op(const Scalar& other) : m_other(other) { }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a * m_other; } EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a * m_other; }
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
{ return internal::pmul(a, pset1<Packet>(m_other)); } { return internal::pmul(a, pset1<Packet>(m_other)); }
@ -478,7 +481,7 @@ struct scalar_multiple2_op {
typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType result_type; typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType result_type;
EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { } EIGEN_STRONG_INLINE scalar_multiple2_op(const scalar_multiple2_op& other) : m_other(other.m_other) { }
EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { } EIGEN_STRONG_INLINE scalar_multiple2_op(const Scalar2& other) : m_other(other) { }
EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const Scalar1& a) const { return a * m_other; }
typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other; typename add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
}; };
template<typename Scalar1,typename Scalar2> template<typename Scalar1,typename Scalar2>
@ -499,7 +502,7 @@ struct scalar_quotient1_op {
// FIXME default copy constructors seems bugged with std::complex<> // FIXME default copy constructors seems bugged with std::complex<>
EIGEN_STRONG_INLINE scalar_quotient1_op(const scalar_quotient1_op& other) : m_other(other.m_other) { } EIGEN_STRONG_INLINE scalar_quotient1_op(const scalar_quotient1_op& other) : m_other(other.m_other) { }
EIGEN_STRONG_INLINE scalar_quotient1_op(const Scalar& other) : m_other(other) {} EIGEN_STRONG_INLINE scalar_quotient1_op(const Scalar& other) : m_other(other) {}
EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a / m_other; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator() (const Scalar& a) const { return a / m_other; }
EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a) const
{ return internal::pdiv(a, pset1<Packet>(m_other)); } { return internal::pdiv(a, pset1<Packet>(m_other)); }
typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other; typename add_const_on_value_type<typename NumTraits<Scalar>::Nested>::type m_other;
@ -516,7 +519,7 @@ struct scalar_constant_op {
EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { } EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other) : m_other(other.m_other) { }
EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { } EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other) : m_other(other) { }
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Scalar operator() (Index, Index = 0) const { return m_other; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (Index, Index = 0) const { return m_other; }
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return internal::pset1<Packet>(m_other); } EIGEN_STRONG_INLINE const Packet packetOp(Index, Index = 0) const { return internal::pset1<Packet>(m_other); }
const Scalar m_other; const Scalar m_other;
@ -529,7 +532,7 @@ struct functor_traits<scalar_constant_op<Scalar> >
template<typename Scalar> struct scalar_identity_op { template<typename Scalar> struct scalar_identity_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const { return row==col ? Scalar(1) : Scalar(0); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const { return row==col ? Scalar(1) : Scalar(0); }
}; };
template<typename Scalar> template<typename Scalar>
struct functor_traits<scalar_identity_op<Scalar> > struct functor_traits<scalar_identity_op<Scalar> >
@ -553,7 +556,7 @@ struct linspaced_op_impl<Scalar,false>
m_base(padd(pset1<Packet>(low),pmul(pset1<Packet>(step),plset<Scalar>(-packet_traits<Scalar>::size)))) {} m_base(padd(pset1<Packet>(low),pmul(pset1<Packet>(step),plset<Scalar>(-packet_traits<Scalar>::size)))) {}
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; }
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Packet packetOp(Index) const { return m_base = padd(m_base,m_packetStep); } EIGEN_STRONG_INLINE const Packet packetOp(Index) const { return m_base = padd(m_base,m_packetStep); }
@ -576,7 +579,7 @@ struct linspaced_op_impl<Scalar,true>
m_lowPacket(pset1<Packet>(m_low)), m_stepPacket(pset1<Packet>(m_step)), m_interPacket(plset<Scalar>(0)) {} m_lowPacket(pset1<Packet>(m_low)), m_stepPacket(pset1<Packet>(m_step)), m_interPacket(plset<Scalar>(0)) {}
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return m_low+i*m_step; }
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Packet packetOp(Index i) const EIGEN_STRONG_INLINE const Packet packetOp(Index i) const
@ -603,12 +606,12 @@ template <typename Scalar, bool RandomAccess> struct linspaced_op
linspaced_op(Scalar low, Scalar high, int num_steps) : impl((num_steps==1 ? high : low), (num_steps==1 ? Scalar() : (high-low)/(num_steps-1))) {} linspaced_op(Scalar low, Scalar high, int num_steps) : impl((num_steps==1 ? high : low), (num_steps==1 ? Scalar() : (high-low)/(num_steps-1))) {}
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return impl(i); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (Index i) const { return impl(i); }
// We need this function when assigning e.g. a RowVectorXd to a MatrixXd since // We need this function when assigning e.g. a RowVectorXd to a MatrixXd since
// there row==0 and col is used for the actual iteration. // there row==0 and col is used for the actual iteration.
template<typename Index> template<typename Index>
EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator() (Index row, Index col) const
{ {
eigen_assert(col==0 || row==0); eigen_assert(col==0 || row==0);
return impl(col + row); return impl(col + row);
@ -657,9 +660,9 @@ template<typename Scalar>
struct scalar_add_op { struct scalar_add_op {
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
// FIXME default copy constructors seems bugged with std::complex<> // FIXME default copy constructors seems bugged with std::complex<>
inline scalar_add_op(const scalar_add_op& other) : m_other(other.m_other) { } EIGEN_DEVICE_FUNC inline scalar_add_op(const scalar_add_op& other) : m_other(other.m_other) { }
inline scalar_add_op(const Scalar& other) : m_other(other) { } EIGEN_DEVICE_FUNC inline scalar_add_op(const Scalar& other) : m_other(other) { }
inline Scalar operator() (const Scalar& a) const { return a + m_other; } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a + m_other; }
inline const Packet packetOp(const Packet& a) const inline const Packet packetOp(const Packet& a) const
{ return internal::padd(a, pset1<Packet>(m_other)); } { return internal::padd(a, pset1<Packet>(m_other)); }
const Scalar m_other; const Scalar m_other;
@ -674,7 +677,7 @@ struct functor_traits<scalar_add_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_sqrt_op { template<typename Scalar> struct scalar_sqrt_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_sqrt_op)
inline const Scalar operator() (const Scalar& a) const { using std::sqrt; return sqrt(a); } EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { using std::sqrt; return sqrt(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); } inline Packet packetOp(const Packet& a) const { return internal::psqrt(a); }
}; };
@ -692,7 +695,7 @@ struct functor_traits<scalar_sqrt_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_cos_op { template<typename Scalar> struct scalar_cos_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_cos_op)
inline Scalar operator() (const Scalar& a) const { using std::cos; return cos(a); } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { using std::cos; return cos(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::pcos(a); } inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
}; };
@ -711,7 +714,7 @@ struct functor_traits<scalar_cos_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_sin_op { template<typename Scalar> struct scalar_sin_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_sin_op)
inline const Scalar operator() (const Scalar& a) const { using std::sin; return sin(a); } EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { using std::sin; return sin(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::psin(a); } inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
}; };
@ -731,7 +734,7 @@ struct functor_traits<scalar_sin_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_tan_op { template<typename Scalar> struct scalar_tan_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_tan_op)
inline const Scalar operator() (const Scalar& a) const { using std::tan; return tan(a); } EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { using std::tan; return tan(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::ptan(a); } inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
}; };
@ -750,7 +753,7 @@ struct functor_traits<scalar_tan_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_acos_op { template<typename Scalar> struct scalar_acos_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_acos_op)
inline const Scalar operator() (const Scalar& a) const { using std::acos; return acos(a); } EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { using std::acos; return acos(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::pacos(a); } inline Packet packetOp(const Packet& a) const { return internal::pacos(a); }
}; };
@ -769,7 +772,7 @@ struct functor_traits<scalar_acos_op<Scalar> >
*/ */
template<typename Scalar> struct scalar_asin_op { template<typename Scalar> struct scalar_asin_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_asin_op)
inline const Scalar operator() (const Scalar& a) const { using std::asin; return asin(a); } EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const { using std::asin; return asin(a); }
typedef typename packet_traits<Scalar>::type Packet; typedef typename packet_traits<Scalar>::type Packet;
inline Packet packetOp(const Packet& a) const { return internal::pasin(a); } inline Packet packetOp(const Packet& a) const { return internal::pasin(a); }
}; };
@ -791,7 +794,7 @@ struct scalar_pow_op {
// FIXME default copy constructors seems bugged with std::complex<> // FIXME default copy constructors seems bugged with std::complex<>
inline scalar_pow_op(const scalar_pow_op& other) : m_exponent(other.m_exponent) { } inline scalar_pow_op(const scalar_pow_op& other) : m_exponent(other.m_exponent) { }
inline scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {} inline scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {}
inline Scalar operator() (const Scalar& a) const { return internal::pow(a, m_exponent); } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return internal::pow(a, m_exponent); }
const Scalar m_exponent; const Scalar m_exponent;
}; };
template<typename Scalar> template<typename Scalar>
@ -805,7 +808,7 @@ struct functor_traits<scalar_pow_op<Scalar> >
template<typename Scalar> template<typename Scalar>
struct scalar_inverse_mult_op { struct scalar_inverse_mult_op {
scalar_inverse_mult_op(const Scalar& other) : m_other(other) {} scalar_inverse_mult_op(const Scalar& other) : m_other(other) {}
inline Scalar operator() (const Scalar& a) const { return m_other / a; } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return m_other / a; }
template<typename Packet> template<typename Packet>
inline const Packet packetOp(const Packet& a) const inline const Packet packetOp(const Packet& a) const
{ return internal::pdiv(pset1<Packet>(m_other),a); } { return internal::pdiv(pset1<Packet>(m_other),a); }
@ -819,7 +822,7 @@ struct scalar_inverse_mult_op {
template<typename Scalar> template<typename Scalar>
struct scalar_inverse_op { struct scalar_inverse_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_inverse_op)
inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
template<typename Packet> template<typename Packet>
inline const Packet packetOp(const Packet& a) const inline const Packet packetOp(const Packet& a) const
{ return internal::pdiv(pset1<Packet>(Scalar(1)),a); } { return internal::pdiv(pset1<Packet>(Scalar(1)),a); }
@ -835,7 +838,7 @@ struct functor_traits<scalar_inverse_op<Scalar> >
template<typename Scalar> template<typename Scalar>
struct scalar_square_op { struct scalar_square_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_square_op)
inline Scalar operator() (const Scalar& a) const { return a*a; } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a; }
template<typename Packet> template<typename Packet>
inline const Packet packetOp(const Packet& a) const inline const Packet packetOp(const Packet& a) const
{ return internal::pmul(a,a); } { return internal::pmul(a,a); }
@ -851,7 +854,7 @@ struct functor_traits<scalar_square_op<Scalar> >
template<typename Scalar> template<typename Scalar>
struct scalar_cube_op { struct scalar_cube_op {
EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op) EIGEN_EMPTY_STRUCT_CTOR(scalar_cube_op)
inline Scalar operator() (const Scalar& a) const { return a*a*a; } EIGEN_DEVICE_FUNC inline Scalar operator() (const Scalar& a) const { return a*a*a; }
template<typename Packet> template<typename Packet>
inline const Packet packetOp(const Packet& a) const inline const Packet packetOp(const Packet& a) const
{ return internal::pmul(a,pmul(a,a)); } { return internal::pmul(a,pmul(a,a)); }

3
Eigen/src/Core/GeneralProduct.h
View File

@ -543,6 +543,7 @@ template<> struct gemv_selector<OnTheRight,RowMajor,false>
* *
* \sa lazyProduct(), operator*=(const MatrixBase&), Cwise::operator*() * \sa lazyProduct(), operator*=(const MatrixBase&), Cwise::operator*()
*/ */
#ifndef __CUDACC__
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
inline const typename ProductReturnType<Derived, OtherDerived>::Type inline const typename ProductReturnType<Derived, OtherDerived>::Type
@ -572,7 +573,7 @@ MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const
#endif #endif
return typename ProductReturnType<Derived,OtherDerived>::Type(derived(), other.derived()); return typename ProductReturnType<Derived,OtherDerived>::Type(derived(), other.derived());
} }
#endif
/** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation. /** \returns an expression of the matrix product of \c *this and \a other without implicit evaluation.
* *
* The returned product will behave like any other expressions: the coefficients of the product will be * The returned product will behave like any other expressions: the coefficients of the product will be

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

@ -118,11 +118,13 @@ template<typename PlainObjectType, int MapOptions, typename StrideType> class Ma
inline PointerType cast_to_pointer_type(PointerArgType ptr) { return ptr; } inline PointerType cast_to_pointer_type(PointerArgType ptr) { return ptr; }
#endif #endif
EIGEN_DEVICE_FUNC
inline Index innerStride() const inline Index innerStride() const
{ {
return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1; return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
} }
EIGEN_DEVICE_FUNC
inline Index outerStride() const inline Index outerStride() const
{ {
return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer() return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
@ -136,6 +138,7 @@ template<typename PlainObjectType, int MapOptions, typename StrideType> class Ma
* \param dataPtr pointer to the array to map * \param dataPtr pointer to the array to map
* \param a_stride optional Stride object, passing the strides. * \param a_stride optional Stride object, passing the strides.
*/ */
EIGEN_DEVICE_FUNC
inline Map(PointerArgType dataPtr, const StrideType& a_stride = StrideType()) inline Map(PointerArgType dataPtr, const StrideType& a_stride = StrideType())
: Base(cast_to_pointer_type(dataPtr)), m_stride(a_stride) : Base(cast_to_pointer_type(dataPtr)), m_stride(a_stride)
{ {
@ -148,6 +151,7 @@ template<typename PlainObjectType, int MapOptions, typename StrideType> class Ma
* \param a_size the size of the vector expression * \param a_size the size of the vector expression
* \param a_stride optional Stride object, passing the strides. * \param a_stride optional Stride object, passing the strides.
*/ */
EIGEN_DEVICE_FUNC
inline Map(PointerArgType dataPtr, Index a_size, const StrideType& a_stride = StrideType()) inline Map(PointerArgType dataPtr, Index a_size, const StrideType& a_stride = StrideType())
: Base(cast_to_pointer_type(dataPtr), a_size), m_stride(a_stride) : Base(cast_to_pointer_type(dataPtr), a_size), m_stride(a_stride)
{ {
@ -161,6 +165,7 @@ template<typename PlainObjectType, int MapOptions, typename StrideType> class Ma
* \param nbCols the number of columns of the matrix expression * \param nbCols the number of columns of the matrix expression
* \param a_stride optional Stride object, passing the strides. * \param a_stride optional Stride object, passing the strides.
*/ */
EIGEN_DEVICE_FUNC
inline Map(PointerArgType dataPtr, Index nbRows, Index nbCols, const StrideType& a_stride = StrideType()) inline Map(PointerArgType dataPtr, Index nbRows, Index nbCols, const StrideType& a_stride = StrideType())
: Base(cast_to_pointer_type(dataPtr), nbRows, nbCols), m_stride(a_stride) : Base(cast_to_pointer_type(dataPtr), nbRows, nbCols), m_stride(a_stride)
{ {

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

@ -76,8 +76,8 @@ template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
typedef typename Base::CoeffReturnType CoeffReturnType; typedef typename Base::CoeffReturnType CoeffReturnType;
inline Index rows() const { return m_rows.value(); } EIGEN_DEVICE_FUNC inline Index rows() const { return m_rows.value(); }
inline Index cols() const { return m_cols.value(); } EIGEN_DEVICE_FUNC inline Index cols() const { return m_cols.value(); }
/** Returns a pointer to the first coefficient of the matrix or vector. /** Returns a pointer to the first coefficient of the matrix or vector.
* *
@ -87,22 +87,26 @@ template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
*/ */
inline const Scalar* data() const { return m_data; } inline const Scalar* data() const { return m_data; }
EIGEN_DEVICE_FUNC
inline const Scalar& coeff(Index rowId, Index colId) const inline const Scalar& coeff(Index rowId, Index colId) const
{ {
return m_data[colId * colStride() + rowId * rowStride()]; return m_data[colId * colStride() + rowId * rowStride()];
} }
EIGEN_DEVICE_FUNC
inline const Scalar& coeff(Index index) const inline const Scalar& coeff(Index index) const
{ {
EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
return m_data[index * innerStride()]; return m_data[index * innerStride()];
} }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index rowId, Index colId) const inline const Scalar& coeffRef(Index rowId, Index colId) const
{ {
return this->m_data[colId * colStride() + rowId * rowStride()]; return this->m_data[colId * colStride() + rowId * rowStride()];
} }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index index) const inline const Scalar& coeffRef(Index index) const
{ {
EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
@ -123,12 +127,14 @@ template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride()); return internal::ploadt<PacketScalar, LoadMode>(m_data + index * innerStride());
} }
EIGEN_DEVICE_FUNC
inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime) inline MapBase(PointerType dataPtr) : m_data(dataPtr), m_rows(RowsAtCompileTime), m_cols(ColsAtCompileTime)
{ {
EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
checkSanity(); checkSanity();
} }
EIGEN_DEVICE_FUNC
inline MapBase(PointerType dataPtr, Index vecSize) inline MapBase(PointerType dataPtr, Index vecSize)
: m_data(dataPtr), : m_data(dataPtr),
m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)), m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
@ -140,6 +146,7 @@ template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
checkSanity(); checkSanity();
} }
EIGEN_DEVICE_FUNC
inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols) inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols)
: m_data(dataPtr), m_rows(nbRows), m_cols(nbCols) : m_data(dataPtr), m_rows(nbRows), m_cols(nbCols)
{ {
@ -151,6 +158,7 @@ template<typename Derived> class MapBase<Derived, ReadOnlyAccessors>
protected: protected:
EIGEN_DEVICE_FUNC
void checkSanity() const void checkSanity() const
{ {
EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(internal::traits<Derived>::Flags&PacketAccessBit, EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(internal::traits<Derived>::Flags&PacketAccessBit,
@ -198,11 +206,13 @@ template<typename Derived> class MapBase<Derived, WriteAccessors>
inline const Scalar* data() const { return this->m_data; } inline const Scalar* data() const { return this->m_data; }
inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error inline ScalarWithConstIfNotLvalue* data() { return this->m_data; } // no const-cast here so non-const-correct code will give a compile error
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col) inline ScalarWithConstIfNotLvalue& coeffRef(Index row, Index col)
{ {
return this->m_data[col * colStride() + row * rowStride()]; return this->m_data[col * colStride() + row * rowStride()];
} }
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue& coeffRef(Index index) inline ScalarWithConstIfNotLvalue& coeffRef(Index index)
{ {
EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived) EIGEN_STATIC_ASSERT_INDEX_BASED_ACCESS(Derived)
@ -224,10 +234,11 @@ template<typename Derived> class MapBase<Derived, WriteAccessors>
(this->m_data + index * innerStride(), val); (this->m_data + index * innerStride(), val);
} }
explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {} EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(dataPtr) {}
inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {} EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : Base(dataPtr, vecSize) {}
inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols) : Base(dataPtr, nbRows, nbCols) {} EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols) : Base(dataPtr, nbRows, nbCols) {}
EIGEN_DEVICE_FUNC
Derived& operator=(const MapBase& other) Derived& operator=(const MapBase& other)
{ {
Base::Base::operator=(other); Base::Base::operator=(other);

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

@ -151,6 +151,7 @@ class Matrix
* *
* \callgraph * \callgraph
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix& operator=(const Matrix& other) EIGEN_STRONG_INLINE Matrix& operator=(const Matrix& other)
{ {
return Base::_set(other); return Base::_set(other);
@ -167,6 +168,7 @@ class Matrix
* remain row-vectors and vectors remain vectors. * remain row-vectors and vectors remain vectors.
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix& operator=(const MatrixBase<OtherDerived>& other) EIGEN_STRONG_INLINE Matrix& operator=(const MatrixBase<OtherDerived>& other)
{ {
return Base::_set(other); return Base::_set(other);
@ -179,12 +181,14 @@ class Matrix
* \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other) * \copydetails DenseBase::operator=(const EigenBase<OtherDerived> &other)
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix& operator=(const EigenBase<OtherDerived> &other) EIGEN_STRONG_INLINE Matrix& operator=(const EigenBase<OtherDerived> &other)
{ {
return Base::operator=(other); return Base::operator=(other);
} }
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix& operator=(const ReturnByValue<OtherDerived>& func) EIGEN_STRONG_INLINE Matrix& operator=(const ReturnByValue<OtherDerived>& func)
{ {
return Base::operator=(func); return Base::operator=(func);
@ -200,6 +204,7 @@ class Matrix
* *
* \sa resize(Index,Index) * \sa resize(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE explicit Matrix() : Base() EIGEN_STRONG_INLINE explicit Matrix() : Base()
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -207,6 +212,7 @@ class Matrix
} }
// FIXME is it still needed // FIXME is it still needed
EIGEN_DEVICE_FUNC
Matrix(internal::constructor_without_unaligned_array_assert) Matrix(internal::constructor_without_unaligned_array_assert)
: Base(internal::constructor_without_unaligned_array_assert()) : Base(internal::constructor_without_unaligned_array_assert())
{ Base::_check_template_params(); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED } { Base::_check_template_params(); EIGEN_INITIALIZE_BY_ZERO_IF_THAT_OPTION_IS_ENABLED }
@ -217,6 +223,7 @@ class Matrix
* it is redundant to pass the dimension here, so it makes more sense to use the default * it is redundant to pass the dimension here, so it makes more sense to use the default
* constructor Matrix() instead. * constructor Matrix() instead.
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE explicit Matrix(Index dim) EIGEN_STRONG_INLINE explicit Matrix(Index dim)
: Base(dim, RowsAtCompileTime == 1 ? 1 : dim, ColsAtCompileTime == 1 ? 1 : dim) : Base(dim, RowsAtCompileTime == 1 ? 1 : dim, ColsAtCompileTime == 1 ? 1 : dim)
{ {
@ -229,6 +236,7 @@ class Matrix
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename T0, typename T1> template<typename T0, typename T1>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y) EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -240,12 +248,14 @@ class Matrix
* This is useful for dynamic-size matrices. For fixed-size matrices, * This is useful for dynamic-size matrices. For fixed-size matrices,
* it is redundant to pass these parameters, so one should use the default constructor * it is redundant to pass these parameters, so one should use the default constructor
* Matrix() instead. */ * Matrix() instead. */
EIGEN_DEVICE_FUNC
Matrix(Index rows, Index cols); Matrix(Index rows, Index cols);
/** \brief Constructs an initialized 2D vector with given coefficients */ /** \brief Constructs an initialized 2D vector with given coefficients */
Matrix(const Scalar& x, const Scalar& y); Matrix(const Scalar& x, const Scalar& y);
#endif #endif
/** \brief Constructs an initialized 3D vector with given coefficients */ /** \brief Constructs an initialized 3D vector with given coefficients */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z) EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -255,6 +265,7 @@ class Matrix
m_storage.data()[2] = z; m_storage.data()[2] = z;
} }
/** \brief Constructs an initialized 4D vector with given coefficients */ /** \brief Constructs an initialized 4D vector with given coefficients */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w) EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -265,10 +276,12 @@ class Matrix
m_storage.data()[3] = w; m_storage.data()[3] = w;
} }
EIGEN_DEVICE_FUNC
explicit Matrix(const Scalar *data); explicit Matrix(const Scalar *data);
/** \brief Constructor copying the value of the expression \a other */ /** \brief Constructor copying the value of the expression \a other */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix(const MatrixBase<OtherDerived>& other) EIGEN_STRONG_INLINE Matrix(const MatrixBase<OtherDerived>& other)
: Base(other.rows() * other.cols(), other.rows(), other.cols()) : Base(other.rows() * other.cols(), other.rows(), other.cols())
{ {
@ -281,6 +294,7 @@ class Matrix
Base::_set_noalias(other); Base::_set_noalias(other);
} }
/** \brief Copy constructor */ /** \brief Copy constructor */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix(const Matrix& other) EIGEN_STRONG_INLINE Matrix(const Matrix& other)
: Base(other.rows() * other.cols(), other.rows(), other.cols()) : Base(other.rows() * other.cols(), other.rows(), other.cols())
{ {
@ -289,6 +303,7 @@ class Matrix
} }
/** \brief Copy constructor with in-place evaluation */ /** \brief Copy constructor with in-place evaluation */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix(const ReturnByValue<OtherDerived>& other) EIGEN_STRONG_INLINE Matrix(const ReturnByValue<OtherDerived>& other)
{ {
Base::_check_template_params(); Base::_check_template_params();
@ -300,6 +315,7 @@ class Matrix
* \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) * \sa MatrixBase::operator=(const EigenBase<OtherDerived>&)
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other) EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
: Base(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols()) : Base(other.derived().rows() * other.derived().cols(), other.derived().rows(), other.derived().cols())
{ {
@ -318,14 +334,16 @@ class Matrix
void swap(MatrixBase<OtherDerived> const & other) void swap(MatrixBase<OtherDerived> const & other)
{ this->_swap(other.derived()); } { this->_swap(other.derived()); }
inline Index innerStride() const { return 1; } EIGEN_DEVICE_FUNC inline Index innerStride() const { return 1; }
inline Index outerStride() const { return this->innerSize(); } EIGEN_DEVICE_FUNC inline Index outerStride() const { return this->innerSize(); }
/////////// Geometry module /////////// /////////// Geometry module ///////////
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
explicit Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r); explicit Matrix(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Matrix& operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r); Matrix& operator=(const RotationBase<OtherDerived,ColsAtCompileTime>& r);
#ifdef EIGEN2_SUPPORT #ifdef EIGEN2_SUPPORT

30
Eigen/src/Core/MatrixBase.h
View File

@ -145,22 +145,27 @@ template<typename Derived> class MatrixBase
/** Special case of the template operator=, in order to prevent the compiler /** Special case of the template operator=, in order to prevent the compiler
* from generating a default operator= (issue hit with g++ 4.1) * from generating a default operator= (issue hit with g++ 4.1)
*/ */
EIGEN_DEVICE_FUNC
Derived& operator=(const MatrixBase& other); Derived& operator=(const MatrixBase& other);
// We cannot inherit here via Base::operator= since it is causing // We cannot inherit here via Base::operator= since it is causing
// trouble with MSVC. // trouble with MSVC.
template <typename OtherDerived> template <typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator=(const DenseBase<OtherDerived>& other); Derived& operator=(const DenseBase<OtherDerived>& other);
template <typename OtherDerived> template <typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator=(const EigenBase<OtherDerived>& other); Derived& operator=(const EigenBase<OtherDerived>& other);
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator=(const ReturnByValue<OtherDerived>& other); Derived& operator=(const ReturnByValue<OtherDerived>& other);
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename ProductDerived, typename Lhs, typename Rhs> template<typename ProductDerived, typename Lhs, typename Rhs>
EIGEN_DEVICE_FUNC
Derived& lazyAssign(const ProductBase<ProductDerived, Lhs,Rhs>& other); Derived& lazyAssign(const ProductBase<ProductDerived, Lhs,Rhs>& other);
template<typename MatrixPower, typename Lhs, typename Rhs> template<typename MatrixPower, typename Lhs, typename Rhs>
@ -168,15 +173,26 @@ template<typename Derived> class MatrixBase
#endif // not EIGEN_PARSED_BY_DOXYGEN #endif // not EIGEN_PARSED_BY_DOXYGEN
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator+=(const MatrixBase<OtherDerived>& other); Derived& operator+=(const MatrixBase<OtherDerived>& other);
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
Derived& operator-=(const MatrixBase<OtherDerived>& other); Derived& operator-=(const MatrixBase<OtherDerived>& other);
#ifdef __CUDACC__
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
const typename LazyProductReturnType<Derived,OtherDerived>::Type
operator*(const MatrixBase<OtherDerived> &other) const
{ return this->lazyProduct(other); }
#else
template<typename OtherDerived> template<typename OtherDerived>
const typename ProductReturnType<Derived,OtherDerived>::Type const typename ProductReturnType<Derived,OtherDerived>::Type
operator*(const MatrixBase<OtherDerived> &other) const; operator*(const MatrixBase<OtherDerived> &other) const;
#endif
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
const typename LazyProductReturnType<Derived,OtherDerived>::Type const typename LazyProductReturnType<Derived,OtherDerived>::Type
lazyProduct(const MatrixBase<OtherDerived> &other) const; lazyProduct(const MatrixBase<OtherDerived> &other) const;
@ -194,6 +210,7 @@ template<typename Derived> class MatrixBase
operator*(const DiagonalBase<DiagonalDerived> &diagonal) const; operator*(const DiagonalBase<DiagonalDerived> &diagonal) const;
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType typename internal::scalar_product_traits<typename internal::traits<Derived>::Scalar,typename internal::traits<OtherDerived>::Scalar>::ReturnType
dot(const MatrixBase<OtherDerived>& other) const; dot(const MatrixBase<OtherDerived>& other) const;
@ -324,8 +341,8 @@ template<typename Derived> class MatrixBase
/////////// LU module /////////// /////////// LU module ///////////
const FullPivLU<PlainObject> fullPivLu() const; EIGEN_DEVICE_FUNC const FullPivLU<PlainObject> fullPivLu() const;
const PartialPivLU<PlainObject> partialPivLu() const; EIGEN_DEVICE_FUNC const PartialPivLU<PlainObject> partialPivLu() const;
#if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS #if EIGEN2_SUPPORT_STAGE < STAGE20_RESOLVE_API_CONFLICTS
const LU<PlainObject> lu() const; const LU<PlainObject> lu() const;
@ -346,6 +363,7 @@ template<typename Derived> class MatrixBase
} }
#endif #endif
EIGEN_DEVICE_FUNC
const internal::inverse_impl<Derived> inverse() const; const internal::inverse_impl<Derived> inverse() const;
template<typename ResultType> template<typename ResultType>
void computeInverseAndDetWithCheck( void computeInverseAndDetWithCheck(
@ -495,12 +513,12 @@ template<typename Derived> class MatrixBase
#endif #endif
protected: protected:
MatrixBase() : Base() {} EIGEN_DEVICE_FUNC MatrixBase() : Base() {}
private: private:
explicit MatrixBase(int); EIGEN_DEVICE_FUNC explicit MatrixBase(int);
MatrixBase(int,int); EIGEN_DEVICE_FUNC MatrixBase(int,int);
template<typename OtherDerived> explicit MatrixBase(const MatrixBase<OtherDerived>&); template<typename OtherDerived> EIGEN_DEVICE_FUNC explicit MatrixBase(const MatrixBase<OtherDerived>&);
protected: protected:
// mixing arrays and matrices is not legal // mixing arrays and matrices is not legal
template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& ) template<typename OtherDerived> Derived& operator+=(const ArrayBase<OtherDerived>& )

7
Eigen/src/Core/NoAlias.h
View File

@ -37,11 +37,13 @@ class NoAlias
/** Behaves like MatrixBase::lazyAssign(other) /** Behaves like MatrixBase::lazyAssign(other)
* \sa MatrixBase::lazyAssign() */ * \sa MatrixBase::lazyAssign() */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other) EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase<OtherDerived>& other)
{ return internal::assign_selector<ExpressionType,OtherDerived,false>::run(m_expression,other.derived()); } { return internal::assign_selector<ExpressionType,OtherDerived,false>::run(m_expression,other.derived()); }
/** \sa MatrixBase::operator+= */ /** \sa MatrixBase::operator+= */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other) EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase<OtherDerived>& other)
{ {
typedef SelfCwiseBinaryOp<internal::scalar_sum_op<Scalar>, ExpressionType, OtherDerived> SelfAdder; typedef SelfCwiseBinaryOp<internal::scalar_sum_op<Scalar>, ExpressionType, OtherDerived> SelfAdder;
@ -54,6 +56,7 @@ class NoAlias
/** \sa MatrixBase::operator-= */ /** \sa MatrixBase::operator-= */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other) EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase<OtherDerived>& other)
{ {
typedef SelfCwiseBinaryOp<internal::scalar_difference_op<Scalar>, ExpressionType, OtherDerived> SelfAdder; typedef SelfCwiseBinaryOp<internal::scalar_difference_op<Scalar>, ExpressionType, OtherDerived> SelfAdder;
@ -66,10 +69,12 @@ class NoAlias
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename ProductDerived, typename Lhs, typename Rhs> template<typename ProductDerived, typename Lhs, typename Rhs>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE ExpressionType& operator+=(const ProductBase<ProductDerived, Lhs,Rhs>& other) EIGEN_STRONG_INLINE ExpressionType& operator+=(const ProductBase<ProductDerived, Lhs,Rhs>& other)
{ other.derived().addTo(m_expression); return m_expression; } { other.derived().addTo(m_expression); return m_expression; }
template<typename ProductDerived, typename Lhs, typename Rhs> template<typename ProductDerived, typename Lhs, typename Rhs>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE ExpressionType& operator-=(const ProductBase<ProductDerived, Lhs,Rhs>& other) EIGEN_STRONG_INLINE ExpressionType& operator-=(const ProductBase<ProductDerived, Lhs,Rhs>& other)
{ other.derived().subTo(m_expression); return m_expression; } { other.derived().subTo(m_expression); return m_expression; }
@ -78,10 +83,12 @@ class NoAlias
{ return m_expression.derived() += CoeffBasedProduct<Lhs,Rhs,NestByRefBit>(other.lhs(), other.rhs()); } { return m_expression.derived() += CoeffBasedProduct<Lhs,Rhs,NestByRefBit>(other.lhs(), other.rhs()); }
template<typename Lhs, typename Rhs, int NestingFlags> template<typename Lhs, typename Rhs, int NestingFlags>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE ExpressionType& operator-=(const CoeffBasedProduct<Lhs,Rhs,NestingFlags>& other) EIGEN_STRONG_INLINE ExpressionType& operator-=(const CoeffBasedProduct<Lhs,Rhs,NestingFlags>& other)
{ return m_expression.derived() -= CoeffBasedProduct<Lhs,Rhs,NestByRefBit>(other.lhs(), other.rhs()); } { return m_expression.derived() -= CoeffBasedProduct<Lhs,Rhs,NestByRefBit>(other.lhs(), other.rhs()); }
#endif #endif
EIGEN_DEVICE_FUNC
ExpressionType& expression() const ExpressionType& expression() const
{ {
return m_expression; return m_expression;

30
Eigen/src/Core/PlainObjectBase.h
View File

@ -23,6 +23,7 @@ namespace internal {
template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow { template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow {
template<typename Index> template<typename Index>
EIGEN_DEVICE_FUNC
static EIGEN_ALWAYS_INLINE void run(Index, Index) static EIGEN_ALWAYS_INLINE void run(Index, Index)
{ {
} }
@ -30,6 +31,7 @@ template<int MaxSizeAtCompileTime> struct check_rows_cols_for_overflow {
template<> struct check_rows_cols_for_overflow<Dynamic> { template<> struct check_rows_cols_for_overflow<Dynamic> {
template<typename Index> template<typename Index>
EIGEN_DEVICE_FUNC
static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols) static EIGEN_ALWAYS_INLINE void run(Index rows, Index cols)
{ {
// http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242 // http://hg.mozilla.org/mozilla-central/file/6c8a909977d3/xpcom/ds/CheckedInt.h#l242
@ -124,9 +126,12 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
Base& base() { return *static_cast<Base*>(this); } Base& base() { return *static_cast<Base*>(this); }
const Base& base() const { return *static_cast<const Base*>(this); } const Base& base() const { return *static_cast<const Base*>(this); }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); } EIGEN_STRONG_INLINE Index rows() const { return m_storage.rows(); }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); } EIGEN_STRONG_INLINE Index cols() const { return m_storage.cols(); }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const EIGEN_STRONG_INLINE const Scalar& coeff(Index rowId, Index colId) const
{ {
if(Flags & RowMajorBit) if(Flags & RowMajorBit)
@ -135,11 +140,13 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
return m_storage.data()[rowId + colId * m_storage.rows()]; return m_storage.data()[rowId + colId * m_storage.rows()];
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const EIGEN_STRONG_INLINE const Scalar& coeff(Index index) const
{ {
return m_storage.data()[index]; return m_storage.data()[index];
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId) EIGEN_STRONG_INLINE Scalar& coeffRef(Index rowId, Index colId)
{ {
if(Flags & RowMajorBit) if(Flags & RowMajorBit)
@ -148,11 +155,13 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
return m_storage.data()[rowId + colId * m_storage.rows()]; return m_storage.data()[rowId + colId * m_storage.rows()];
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
{ {
return m_storage.data()[index]; return m_storage.data()[index];
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const EIGEN_STRONG_INLINE const Scalar& coeffRef(Index rowId, Index colId) const
{ {
if(Flags & RowMajorBit) if(Flags & RowMajorBit)
@ -161,6 +170,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
return m_storage.data()[rowId + colId * m_storage.rows()]; return m_storage.data()[rowId + colId * m_storage.rows()];
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const EIGEN_STRONG_INLINE const Scalar& coeffRef(Index index) const
{ {
return m_storage.data()[index]; return m_storage.data()[index];
@ -224,6 +234,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* *
* \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t) * \sa resize(Index) for vectors, resize(NoChange_t, Index), resize(Index, NoChange_t)
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void resize(Index nbRows, Index nbCols) EIGEN_STRONG_INLINE void resize(Index nbRows, Index nbCols)
{ {
eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,nbRows==RowsAtCompileTime) eigen_assert( EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,nbRows==RowsAtCompileTime)
@ -254,6 +265,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* *
* \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t) * \sa resize(Index,Index), resize(NoChange_t, Index), resize(Index, NoChange_t)
*/ */
EIGEN_DEVICE_FUNC
inline void resize(Index size) inline void resize(Index size)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase) EIGEN_STATIC_ASSERT_VECTOR_ONLY(PlainObjectBase)
@ -278,6 +290,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* *
* \sa resize(Index,Index) * \sa resize(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline void resize(NoChange_t, Index nbCols) inline void resize(NoChange_t, Index nbCols)
{ {
resize(rows(), nbCols); resize(rows(), nbCols);
@ -291,6 +304,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* *
* \sa resize(Index,Index) * \sa resize(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline void resize(Index nbRows, NoChange_t) inline void resize(Index nbRows, NoChange_t)
{ {
resize(nbRows, cols()); resize(nbRows, cols());
@ -304,6 +318,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* remain row-vectors and vectors remain vectors. * remain row-vectors and vectors remain vectors.
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other) EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
{ {
const OtherDerived& other = _other.derived(); const OtherDerived& other = _other.derived();
@ -393,6 +408,7 @@ class PlainObjectBase : public internal::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_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other) EIGEN_STRONG_INLINE Derived& operator=(const PlainObjectBase& other)
{ {
return _set(other); return _set(other);
@ -400,6 +416,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
/** \sa MatrixBase::lazyAssign() */ /** \sa MatrixBase::lazyAssign() */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other) EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
{ {
_resize_to_match(other); _resize_to_match(other);
@ -407,12 +424,14 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
} }
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func) EIGEN_STRONG_INLINE Derived& operator=(const ReturnByValue<OtherDerived>& func)
{ {
resize(func.rows(), func.cols()); resize(func.rows(), func.cols());
return Base::operator=(func); return Base::operator=(func);
} }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE explicit PlainObjectBase() : m_storage() EIGEN_STRONG_INLINE explicit PlainObjectBase() : m_storage()
{ {
// _check_template_params(); // _check_template_params();
@ -422,6 +441,7 @@ class PlainObjectBase : public internal::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 */
EIGEN_DEVICE_FUNC
PlainObjectBase(internal::constructor_without_unaligned_array_assert) PlainObjectBase(internal::constructor_without_unaligned_array_assert)
: m_storage(internal::constructor_without_unaligned_array_assert()) : m_storage(internal::constructor_without_unaligned_array_assert())
{ {
@ -429,6 +449,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
} }
#endif #endif
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(Index a_size, Index nbRows, Index nbCols) EIGEN_STRONG_INLINE PlainObjectBase(Index a_size, Index nbRows, Index nbCols)
: m_storage(a_size, nbRows, nbCols) : m_storage(a_size, nbRows, nbCols)
{ {
@ -439,6 +460,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
/** \copydoc MatrixBase::operator=(const EigenBase<OtherDerived>&) /** \copydoc MatrixBase::operator=(const EigenBase<OtherDerived>&)
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other) EIGEN_STRONG_INLINE Derived& operator=(const EigenBase<OtherDerived> &other)
{ {
_resize_to_match(other); _resize_to_match(other);
@ -448,6 +470,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
/** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */ /** \sa MatrixBase::operator=(const EigenBase<OtherDerived>&) */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(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())
{ {
@ -558,6 +581,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* remain row-vectors and vectors remain vectors. * remain row-vectors and vectors remain vectors.
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other) EIGEN_STRONG_INLINE void _resize_to_match(const EigenBase<OtherDerived>& other)
{ {
#ifdef EIGEN_NO_AUTOMATIC_RESIZING #ifdef EIGEN_NO_AUTOMATIC_RESIZING
@ -585,6 +609,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* \internal * \internal
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other) EIGEN_STRONG_INLINE Derived& _set(const DenseBase<OtherDerived>& other)
{ {
_set_selector(other.derived(), typename internal::conditional<static_cast<bool>(int(OtherDerived::Flags) & EvalBeforeAssigningBit), internal::true_type, internal::false_type>::type()); _set_selector(other.derived(), typename internal::conditional<static_cast<bool>(int(OtherDerived::Flags) & EvalBeforeAssigningBit), internal::true_type, internal::false_type>::type());
@ -592,9 +617,11 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
} }
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::true_type&) { _set_noalias(other.eval()); } EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::true_type&) { _set_noalias(other.eval()); }
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::false_type&) { _set_noalias(other); } EIGEN_STRONG_INLINE void _set_selector(const OtherDerived& other, const internal::false_type&) { _set_noalias(other); }
/** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which /** \internal Like _set() but additionally makes the assumption that no aliasing effect can happen (which
@ -603,6 +630,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
* \sa operator=(const MatrixBase<OtherDerived>&), _set() * \sa operator=(const MatrixBase<OtherDerived>&), _set()
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other) EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
{ {
// I don't think we need this resize call since the lazyAssign will anyways resize // I don't think we need this resize call since the lazyAssign will anyways resize
@ -622,6 +650,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
resize(nbRows,nbCols); resize(nbRows,nbCols);
} }
template<typename T0, typename T1> template<typename T0, typename T1>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE void _init2(const Scalar& val0, const Scalar& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0) EIGEN_STRONG_INLINE void _init2(const Scalar& val0, const Scalar& val1, typename internal::enable_if<Base::SizeAtCompileTime==2,T0>::type* = 0)
{ {
EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2) EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(PlainObjectBase, 2)
@ -644,6 +673,7 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
public: public:
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void _check_template_params() static EIGEN_STRONG_INLINE void _check_template_params()
{ {
EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor) EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (Options&RowMajor)==RowMajor)

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

@ -82,6 +82,7 @@ struct redux_novec_unroller
typedef typename Derived::Scalar Scalar; typedef typename Derived::Scalar Scalar;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func) static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func& func)
{ {
return func(redux_novec_unroller<Func, Derived, Start, HalfLength>::run(mat,func), return func(redux_novec_unroller<Func, Derived, Start, HalfLength>::run(mat,func),
@ -99,6 +100,7 @@ struct redux_novec_unroller<Func, Derived, Start, 1>
typedef typename Derived::Scalar Scalar; typedef typename Derived::Scalar Scalar;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func&) static EIGEN_STRONG_INLINE Scalar run(const Derived &mat, const Func&)
{ {
return mat.coeffByOuterInner(outer, inner); return mat.coeffByOuterInner(outer, inner);
@ -112,6 +114,7 @@ template<typename Func, typename Derived, int Start>
struct redux_novec_unroller<Func, Derived, Start, 0> struct redux_novec_unroller<Func, Derived, Start, 0>
{ {
typedef typename Derived::Scalar Scalar; typedef typename Derived::Scalar Scalar;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Derived&, const Func&) { return Scalar(); } static EIGEN_STRONG_INLINE Scalar run(const Derived&, const Func&) { return Scalar(); }
}; };
@ -170,6 +173,7 @@ struct redux_impl<Func, Derived, DefaultTraversal, NoUnrolling>
{ {
typedef typename Derived::Scalar Scalar; typedef typename Derived::Scalar Scalar;
typedef typename Derived::Index Index; typedef typename Derived::Index Index;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE Scalar run(const Derived& mat, const Func& func) static EIGEN_STRONG_INLINE Scalar run(const Derived& mat, const Func& func)
{ {
eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix"); eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");

5
Eigen/src/Core/ReturnByValue.h
View File

@ -57,10 +57,11 @@ template<typename Derived> class ReturnByValue
EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue) EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue)
template<typename Dest> template<typename Dest>
EIGEN_DEVICE_FUNC
inline void evalTo(Dest& dst) const inline void evalTo(Dest& dst) const
{ static_cast<const Derived*>(this)->evalTo(dst); } { static_cast<const Derived*>(this)->evalTo(dst); }
inline Index rows() const { return static_cast<const Derived*>(this)->rows(); } EIGEN_DEVICE_FUNC inline Index rows() const { return static_cast<const Derived*>(this)->rows(); }
inline Index cols() const { return static_cast<const Derived*>(this)->cols(); } EIGEN_DEVICE_FUNC inline Index cols() const { return static_cast<const Derived*>(this)->cols(); }
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
#define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT #define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT

13
Eigen/src/Core/Stride.h
View File

@ -51,6 +51,7 @@ class Stride
}; };
/** Default constructor, for use when strides are fixed at compile time */ /** Default constructor, for use when strides are fixed at compile time */
EIGEN_DEVICE_FUNC
Stride() Stride()
: m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime) : m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime)
{ {
@ -58,6 +59,7 @@ class Stride
} }
/** Constructor allowing to pass the strides at runtime */ /** Constructor allowing to pass the strides at runtime */
EIGEN_DEVICE_FUNC
Stride(Index outerStride, Index innerStride) Stride(Index outerStride, Index innerStride)
: m_outer(outerStride), m_inner(innerStride) : m_outer(outerStride), m_inner(innerStride)
{ {
@ -65,13 +67,16 @@ class Stride
} }
/** Copy constructor */ /** Copy constructor */
EIGEN_DEVICE_FUNC
Stride(const Stride& other) Stride(const Stride& other)
: m_outer(other.outer()), m_inner(other.inner()) : m_outer(other.outer()), m_inner(other.inner())
{} {}
/** \returns the outer stride */ /** \returns the outer stride */
EIGEN_DEVICE_FUNC
inline Index outer() const { return m_outer.value(); } inline Index outer() const { return m_outer.value(); }
/** \returns the inner stride */ /** \returns the inner stride */
EIGEN_DEVICE_FUNC
inline Index inner() const { return m_inner.value(); } inline Index inner() const { return m_inner.value(); }
protected: protected:
@ -87,8 +92,8 @@ class InnerStride : public Stride<0, Value>
typedef Stride<0, Value> Base; typedef Stride<0, Value> Base;
public: public:
typedef DenseIndex Index; typedef DenseIndex Index;
InnerStride() : Base() {} EIGEN_DEVICE_FUNC InnerStride() : Base() {}
InnerStride(Index v) : Base(0, v) {} EIGEN_DEVICE_FUNC InnerStride(Index v) : Base(0, v) {}
}; };
/** \brief Convenience specialization of Stride to specify only an outer stride /** \brief Convenience specialization of Stride to specify only an outer stride
@ -99,8 +104,8 @@ class OuterStride : public Stride<Value, 0>
typedef Stride<Value, 0> Base; typedef Stride<Value, 0> Base;
public: public:
typedef DenseIndex Index; typedef DenseIndex Index;
OuterStride() : Base() {} EIGEN_DEVICE_FUNC OuterStride() : Base() {}
OuterStride(Index v) : Base(v,0) {} EIGEN_DEVICE_FUNC OuterStride(Index v) : Base(v,0) {}
}; };
} // end namespace Eigen } // end namespace Eigen

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

@ -62,18 +62,21 @@ template<typename MatrixType> class Transpose
typedef typename TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base; typedef typename TransposeImpl<MatrixType,typename internal::traits<MatrixType>::StorageKind>::Base Base;
EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose) EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose)
EIGEN_DEVICE_FUNC
inline Transpose(MatrixType& a_matrix) : m_matrix(a_matrix) {} inline Transpose(MatrixType& a_matrix) : m_matrix(a_matrix) {}
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Transpose) EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Transpose)
inline Index rows() const { return m_matrix.cols(); } EIGEN_DEVICE_FUNC inline Index rows() const { return m_matrix.cols(); }
inline Index cols() const { return m_matrix.rows(); } EIGEN_DEVICE_FUNC inline Index cols() const { return m_matrix.rows(); }
/** \returns the nested expression */ /** \returns the nested expression */
EIGEN_DEVICE_FUNC
const typename internal::remove_all<typename MatrixType::Nested>::type& const typename internal::remove_all<typename MatrixType::Nested>::type&
nestedExpression() const { return m_matrix; } nestedExpression() const { return m_matrix; }
/** \returns the nested expression */ /** \returns the nested expression */
EIGEN_DEVICE_FUNC
typename internal::remove_all<typename MatrixType::Nested>::type& typename internal::remove_all<typename MatrixType::Nested>::type&
nestedExpression() { return m_matrix.const_cast_derived(); } nestedExpression() { return m_matrix.const_cast_derived(); }
@ -105,8 +108,8 @@ template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
typedef typename internal::TransposeImpl_base<MatrixType>::type Base; typedef typename internal::TransposeImpl_base<MatrixType>::type Base;
EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>) EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>)
inline Index innerStride() const { return derived().nestedExpression().innerStride(); } EIGEN_DEVICE_FUNC inline Index innerStride() const { return derived().nestedExpression().innerStride(); }
inline Index outerStride() const { return derived().nestedExpression().outerStride(); } EIGEN_DEVICE_FUNC inline Index outerStride() const { return derived().nestedExpression().outerStride(); }
typedef typename internal::conditional< typedef typename internal::conditional<
internal::is_lvalue<MatrixType>::value, internal::is_lvalue<MatrixType>::value,
@ -117,33 +120,39 @@ template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
inline ScalarWithConstIfNotLvalue* data() { return derived().nestedExpression().data(); } inline ScalarWithConstIfNotLvalue* data() { return derived().nestedExpression().data(); }
inline const Scalar* data() const { return derived().nestedExpression().data(); } inline const Scalar* data() const { return derived().nestedExpression().data(); }
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue& coeffRef(Index rowId, Index colId) inline ScalarWithConstIfNotLvalue& coeffRef(Index rowId, Index colId)
{ {
EIGEN_STATIC_ASSERT_LVALUE(MatrixType) EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
return derived().nestedExpression().const_cast_derived().coeffRef(colId, rowId); return derived().nestedExpression().const_cast_derived().coeffRef(colId, rowId);
} }
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue& coeffRef(Index index) inline ScalarWithConstIfNotLvalue& coeffRef(Index index)
{ {
EIGEN_STATIC_ASSERT_LVALUE(MatrixType) EIGEN_STATIC_ASSERT_LVALUE(MatrixType)
return derived().nestedExpression().const_cast_derived().coeffRef(index); return derived().nestedExpression().const_cast_derived().coeffRef(index);
} }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index rowId, Index colId) const inline const Scalar& coeffRef(Index rowId, Index colId) const
{ {
return derived().nestedExpression().coeffRef(colId, rowId); return derived().nestedExpression().coeffRef(colId, rowId);
} }
EIGEN_DEVICE_FUNC
inline const Scalar& coeffRef(Index index) const inline const Scalar& coeffRef(Index index) const
{ {
return derived().nestedExpression().coeffRef(index); return derived().nestedExpression().coeffRef(index);
} }
EIGEN_DEVICE_FUNC
inline CoeffReturnType coeff(Index rowId, Index colId) const inline CoeffReturnType coeff(Index rowId, Index colId) const
{ {
return derived().nestedExpression().coeff(colId, rowId); return derived().nestedExpression().coeff(colId, rowId);
} }
EIGEN_DEVICE_FUNC
inline CoeffReturnType coeff(Index index) const inline CoeffReturnType coeff(Index index) const
{ {
return derived().nestedExpression().coeff(index); return derived().nestedExpression().coeff(index);

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

@ -72,6 +72,7 @@ template<typename VectorType, int Size> class VectorBlock
/** Dynamic-size constructor /** Dynamic-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline VectorBlock(VectorType& vector, Index start, Index size) inline VectorBlock(VectorType& vector, Index start, Index size)
: Base(vector, : Base(vector,
IsColVector ? start : 0, IsColVector ? 0 : start, IsColVector ? start : 0, IsColVector ? 0 : start,
@ -82,6 +83,7 @@ template<typename VectorType, int Size> class VectorBlock
/** Fixed-size constructor /** Fixed-size constructor
*/ */
EIGEN_DEVICE_FUNC
inline VectorBlock(VectorType& vector, Index start) inline VectorBlock(VectorType& vector, Index start)
: Base(vector, IsColVector ? start : 0, IsColVector ? 0 : start) : Base(vector, IsColVector ? start : 0, IsColVector ? 0 : start)
{ {

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

@ -140,11 +140,13 @@ class CoeffBasedProduct
public: public:
EIGEN_DEVICE_FUNC
inline CoeffBasedProduct(const CoeffBasedProduct& other) inline CoeffBasedProduct(const CoeffBasedProduct& other)
: Base(), m_lhs(other.m_lhs), m_rhs(other.m_rhs) : Base(), m_lhs(other.m_lhs), m_rhs(other.m_rhs)
{} {}
template<typename Lhs, typename Rhs> template<typename Lhs, typename Rhs>
EIGEN_DEVICE_FUNC
inline CoeffBasedProduct(const Lhs& lhs, const Rhs& rhs) inline CoeffBasedProduct(const Lhs& lhs, const Rhs& rhs)
: m_lhs(lhs), m_rhs(rhs) : m_lhs(lhs), m_rhs(rhs)
{ {
@ -157,9 +159,10 @@ class CoeffBasedProduct
&& "if you wanted a coeff-wise or a dot product use the respective explicit functions"); && "if you wanted a coeff-wise or a dot product use the respective explicit functions");
} }
EIGEN_STRONG_INLINE Index rows() const { return m_lhs.rows(); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index rows() const { return m_lhs.rows(); }
EIGEN_STRONG_INLINE Index cols() const { return m_rhs.cols(); } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index cols() const { return m_rhs.cols(); }
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
{ {
Scalar res; Scalar res;
@ -170,6 +173,7 @@ class CoeffBasedProduct
/* Allow index-based non-packet access. It is impossible though to allow index-based packed access, /* Allow index-based non-packet access. It is impossible though to allow index-based packed access,
* which is why we don't set the LinearAccessBit. * which is why we don't set the LinearAccessBit.
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const Scalar coeff(Index index) const EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
{ {
Scalar res; Scalar res;
@ -191,22 +195,26 @@ class CoeffBasedProduct
} }
// Implicit conversion to the nested type (trigger the evaluation of the product) // Implicit conversion to the nested type (trigger the evaluation of the product)
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE operator const PlainObject& () const EIGEN_STRONG_INLINE operator const PlainObject& () const
{ {
m_result.lazyAssign(*this); m_result.lazyAssign(*this);
return m_result; return m_result;
} }
const _LhsNested& lhs() const { return m_lhs; } EIGEN_DEVICE_FUNC const _LhsNested& lhs() const { return m_lhs; }
const _RhsNested& rhs() const { return m_rhs; } EIGEN_DEVICE_FUNC const _RhsNested& rhs() const { return m_rhs; }
EIGEN_DEVICE_FUNC
const Diagonal<const LazyCoeffBasedProductType,0> diagonal() const const Diagonal<const LazyCoeffBasedProductType,0> diagonal() const
{ return reinterpret_cast<const LazyCoeffBasedProductType&>(*this); } { return reinterpret_cast<const LazyCoeffBasedProductType&>(*this); }
template<int DiagonalIndex> template<int DiagonalIndex>
EIGEN_DEVICE_FUNC
const Diagonal<const LazyCoeffBasedProductType,DiagonalIndex> diagonal() const const Diagonal<const LazyCoeffBasedProductType,DiagonalIndex> diagonal() const
{ return reinterpret_cast<const LazyCoeffBasedProductType&>(*this); } { return reinterpret_cast<const LazyCoeffBasedProductType&>(*this); }
EIGEN_DEVICE_FUNC
const Diagonal<const LazyCoeffBasedProductType,Dynamic> diagonal(Index index) const const Diagonal<const LazyCoeffBasedProductType,Dynamic> diagonal(Index index) const
{ return reinterpret_cast<const LazyCoeffBasedProductType&>(*this).diagonal(index); } { return reinterpret_cast<const LazyCoeffBasedProductType&>(*this).diagonal(index); }
@ -239,6 +247,7 @@ template<int UnrollingIndex, typename Lhs, typename Rhs, typename RetScalar>
struct product_coeff_impl<DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar> struct product_coeff_impl<DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar>
{ {
typedef typename Lhs::Index Index; typedef typename Lhs::Index Index;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar &res) static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar &res)
{ {
product_coeff_impl<DefaultTraversal, UnrollingIndex-1, Lhs, Rhs, RetScalar>::run(row, col, lhs, rhs, res); product_coeff_impl<DefaultTraversal, UnrollingIndex-1, Lhs, Rhs, RetScalar>::run(row, col, lhs, rhs, res);
@ -250,6 +259,7 @@ template<typename Lhs, typename Rhs, typename RetScalar>
struct product_coeff_impl<DefaultTraversal, 0, Lhs, Rhs, RetScalar> struct product_coeff_impl<DefaultTraversal, 0, Lhs, Rhs, RetScalar>
{ {
typedef typename Lhs::Index Index; typedef typename Lhs::Index Index;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar &res) static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar &res)
{ {
res = lhs.coeff(row, 0) * rhs.coeff(0, col); res = lhs.coeff(row, 0) * rhs.coeff(0, col);
@ -260,6 +270,7 @@ template<typename Lhs, typename Rhs, typename RetScalar>
struct product_coeff_impl<DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar> struct product_coeff_impl<DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar>
{ {
typedef typename Lhs::Index Index; typedef typename Lhs::Index Index;
EIGEN_DEVICE_FUNC
static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar& res) static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, RetScalar& res)
{ {
eigen_assert(lhs.cols()>0 && "you are using a non initialized matrix"); eigen_assert(lhs.cols()>0 && "you are using a non initialized matrix");

2
Eigen/src/Core/util/Macros.h
View File

@ -396,7 +396,7 @@
#define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR) \ #define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR) \
template<typename OtherDerived> \ template<typename OtherDerived> \
EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> \ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived> \
(METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \ (METHOD)(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
{ \ { \
return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(), other.derived()); \ return CwiseBinaryOp<FUNCTOR<Scalar>, const Derived, const OtherDerived>(derived(), other.derived()); \

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

@ -16,8 +16,8 @@
// so currently we simply disable this optimization for gcc 4.3 // so currently we simply disable this optimization for gcc 4.3
#if (defined __GNUG__) && !((__GNUC__==4) && (__GNUC_MINOR__==3)) #if (defined __GNUG__) && !((__GNUC__==4) && (__GNUC_MINOR__==3))
#define EIGEN_EMPTY_STRUCT_CTOR(X) \ #define EIGEN_EMPTY_STRUCT_CTOR(X) \
EIGEN_STRONG_INLINE X() {} \ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X() {} \
EIGEN_STRONG_INLINE X(const X& ) {} EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X(const X& ) {}
#else #else
#define EIGEN_EMPTY_STRUCT_CTOR(X) #define EIGEN_EMPTY_STRUCT_CTOR(X)
#endif #endif
@ -50,19 +50,19 @@ template<typename T, int Value> class variable_if_dynamic
{ {
public: public:
EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamic) EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamic)
explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); assert(v == T(Value)); } EIGEN_DEVICE_FUNC explicit variable_if_dynamic(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
static T value() { return T(Value); } EIGEN_DEVICE_FUNC static T value() { return T(Value); }
void setValue(T) {} EIGEN_DEVICE_FUNC void setValue(T) {}
}; };
template<typename T> class variable_if_dynamic<T, Dynamic> template<typename T> class variable_if_dynamic<T, Dynamic>
{ {
T m_value; T m_value;
variable_if_dynamic() { assert(false); } EIGEN_DEVICE_FUNC variable_if_dynamic() { eigen_assert(false); }
public: public:
explicit variable_if_dynamic(T value) : m_value(value) {} EIGEN_DEVICE_FUNC explicit variable_if_dynamic(T value) : m_value(value) {}
T value() const { return m_value; } EIGEN_DEVICE_FUNC T value() const { return m_value; }
void setValue(T value) { m_value = value; } EIGEN_DEVICE_FUNC void setValue(T value) { m_value = value; }
}; };
/** \internal like variable_if_dynamic but for DynamicIndex /** \internal like variable_if_dynamic but for DynamicIndex
@ -71,19 +71,19 @@ template<typename T, int Value> class variable_if_dynamicindex
{ {
public: public:
EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamicindex) EIGEN_EMPTY_STRUCT_CTOR(variable_if_dynamicindex)
explicit variable_if_dynamicindex(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); assert(v == T(Value)); } EIGEN_DEVICE_FUNC explicit variable_if_dynamicindex(T v) { EIGEN_ONLY_USED_FOR_DEBUG(v); eigen_assert(v == T(Value)); }
static T value() { return T(Value); } EIGEN_DEVICE_FUNC static T value() { return T(Value); }
void setValue(T) {} EIGEN_DEVICE_FUNC void setValue(T) {}
}; };
template<typename T> class variable_if_dynamicindex<T, DynamicIndex> template<typename T> class variable_if_dynamicindex<T, DynamicIndex>
{ {
T m_value; T m_value;
variable_if_dynamicindex() { assert(false); } EIGEN_DEVICE_FUNC variable_if_dynamicindex() { eigen_assert(false); }
public: public:
explicit variable_if_dynamicindex(T value) : m_value(value) {} EIGEN_DEVICE_FUNC explicit variable_if_dynamicindex(T value) : m_value(value) {}
T value() const { return m_value; } EIGEN_DEVICE_FUNC T value() const { return m_value; }
void setValue(T value) { m_value = value; } EIGEN_DEVICE_FUNC void setValue(T value) { m_value = value; }
}; };
template<typename T> struct functor_traits template<typename T> struct functor_traits
@ -340,6 +340,7 @@ template<typename T, int n=1, typename PlainObject = typename eval<T>::type> str
}; };
template<typename T> template<typename T>
EIGEN_DEVICE_FUNC
T* const_cast_ptr(const T* ptr) T* const_cast_ptr(const T* ptr)
{ {
return const_cast<T*>(ptr); return const_cast<T*>(ptr);

2
Eigen/src/LU/FullPivLU.h
View File

@ -727,12 +727,14 @@ struct solve_retval<FullPivLU<_MatrixType>, Rhs>
* *
* \sa class FullPivLU * \sa class FullPivLU
*/ */
#ifndef __CUDACC__
template<typename Derived> template<typename Derived>
inline const FullPivLU<typename MatrixBase<Derived>::PlainObject> inline const FullPivLU<typename MatrixBase<Derived>::PlainObject>
MatrixBase<Derived>::fullPivLu() const MatrixBase<Derived>::fullPivLu() const
{ {
return FullPivLU<PlainObject>(eval()); return FullPivLU<PlainObject>(eval());
} }
#endif
} // end namespace Eigen } // end namespace Eigen

23
Eigen/src/LU/Inverse.h
View File

@ -21,6 +21,7 @@ namespace internal {
template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime> template<typename MatrixType, typename ResultType, int Size = MatrixType::RowsAtCompileTime>
struct compute_inverse struct compute_inverse
{ {
EIGEN_DEVICE_FUNC
static inline void run(const MatrixType& matrix, ResultType& result) static inline void run(const MatrixType& matrix, ResultType& result)
{ {
result = matrix.partialPivLu().inverse(); result = matrix.partialPivLu().inverse();
@ -37,6 +38,7 @@ struct compute_inverse_and_det_with_check { /* nothing! general case not support
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
struct compute_inverse<MatrixType, ResultType, 1> struct compute_inverse<MatrixType, ResultType, 1>
{ {
EIGEN_DEVICE_FUNC
static inline void run(const MatrixType& matrix, ResultType& result) static inline void run(const MatrixType& matrix, ResultType& result)
{ {
typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Scalar Scalar;
@ -47,6 +49,7 @@ struct compute_inverse<MatrixType, ResultType, 1>
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
struct compute_inverse_and_det_with_check<MatrixType, ResultType, 1> struct compute_inverse_and_det_with_check<MatrixType, ResultType, 1>
{ {
EIGEN_DEVICE_FUNC
static inline void run( static inline void run(
const MatrixType& matrix, const MatrixType& matrix,
const typename MatrixType::RealScalar& absDeterminantThreshold, const typename MatrixType::RealScalar& absDeterminantThreshold,
@ -67,6 +70,7 @@ struct compute_inverse_and_det_with_check<MatrixType, ResultType, 1>
****************************/ ****************************/
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
EIGEN_DEVICE_FUNC
inline void compute_inverse_size2_helper( inline void compute_inverse_size2_helper(
const MatrixType& matrix, const typename ResultType::Scalar& invdet, const MatrixType& matrix, const typename ResultType::Scalar& invdet,
ResultType& result) ResultType& result)
@ -80,6 +84,7 @@ inline void compute_inverse_size2_helper(
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
struct compute_inverse<MatrixType, ResultType, 2> struct compute_inverse<MatrixType, ResultType, 2>
{ {
EIGEN_DEVICE_FUNC
static inline void run(const MatrixType& matrix, ResultType& result) static inline void run(const MatrixType& matrix, ResultType& result)
{ {
typedef typename ResultType::Scalar Scalar; typedef typename ResultType::Scalar Scalar;
@ -91,6 +96,7 @@ struct compute_inverse<MatrixType, ResultType, 2>
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
struct compute_inverse_and_det_with_check<MatrixType, ResultType, 2> struct compute_inverse_and_det_with_check<MatrixType, ResultType, 2>
{ {
EIGEN_DEVICE_FUNC
static inline void run( static inline void run(
const MatrixType& matrix, const MatrixType& matrix,
const typename MatrixType::RealScalar& absDeterminantThreshold, const typename MatrixType::RealScalar& absDeterminantThreshold,
@ -114,6 +120,7 @@ struct compute_inverse_and_det_with_check<MatrixType, ResultType, 2>
****************************/ ****************************/
template<typename MatrixType, int i, int j> template<typename MatrixType, int i, int j>
EIGEN_DEVICE_FUNC
inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m) inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m)
{ {
enum { enum {
@ -127,6 +134,7 @@ inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m)
} }
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
EIGEN_DEVICE_FUNC
inline void compute_inverse_size3_helper( inline void compute_inverse_size3_helper(
const MatrixType& matrix, const MatrixType& matrix,
const typename ResultType::Scalar& invdet, const typename ResultType::Scalar& invdet,
@ -145,6 +153,7 @@ inline void compute_inverse_size3_helper(
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
struct compute_inverse<MatrixType, ResultType, 3> struct compute_inverse<MatrixType, ResultType, 3>
{ {
EIGEN_DEVICE_FUNC
static inline void run(const MatrixType& matrix, ResultType& result) static inline void run(const MatrixType& matrix, ResultType& result)
{ {
typedef typename ResultType::Scalar Scalar; typedef typename ResultType::Scalar Scalar;
@ -161,6 +170,7 @@ struct compute_inverse<MatrixType, ResultType, 3>
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
struct compute_inverse_and_det_with_check<MatrixType, ResultType, 3> struct compute_inverse_and_det_with_check<MatrixType, ResultType, 3>
{ {
EIGEN_DEVICE_FUNC
static inline void run( static inline void run(
const MatrixType& matrix, const MatrixType& matrix,
const typename MatrixType::RealScalar& absDeterminantThreshold, const typename MatrixType::RealScalar& absDeterminantThreshold,
@ -188,6 +198,7 @@ struct compute_inverse_and_det_with_check<MatrixType, ResultType, 3>
****************************/ ****************************/
template<typename Derived> template<typename Derived>
EIGEN_DEVICE_FUNC
inline const typename Derived::Scalar general_det3_helper inline const typename Derived::Scalar general_det3_helper
(const MatrixBase<Derived>& matrix, int i1, int i2, int i3, int j1, int j2, int j3) (const MatrixBase<Derived>& matrix, int i1, int i2, int i3, int j1, int j2, int j3)
{ {
@ -196,6 +207,7 @@ inline const typename Derived::Scalar general_det3_helper
} }
template<typename MatrixType, int i, int j> template<typename MatrixType, int i, int j>
EIGEN_DEVICE_FUNC
inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix) inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix)
{ {
enum { enum {
@ -214,6 +226,7 @@ inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix)
template<int Arch, typename Scalar, typename MatrixType, typename ResultType> template<int Arch, typename Scalar, typename MatrixType, typename ResultType>
struct compute_inverse_size4 struct compute_inverse_size4
{ {
EIGEN_DEVICE_FUNC
static void run(const MatrixType& matrix, ResultType& result) static void run(const MatrixType& matrix, ResultType& result)
{ {
result.coeffRef(0,0) = cofactor_4x4<MatrixType,0,0>(matrix); result.coeffRef(0,0) = cofactor_4x4<MatrixType,0,0>(matrix);
@ -246,6 +259,7 @@ struct compute_inverse<MatrixType, ResultType, 4>
template<typename MatrixType, typename ResultType> template<typename MatrixType, typename ResultType>
struct compute_inverse_and_det_with_check<MatrixType, ResultType, 4> struct compute_inverse_and_det_with_check<MatrixType, ResultType, 4>
{ {
EIGEN_DEVICE_FUNC
static inline void run( static inline void run(
const MatrixType& matrix, const MatrixType& matrix,
const typename MatrixType::RealScalar& absDeterminantThreshold, const typename MatrixType::RealScalar& absDeterminantThreshold,
@ -279,14 +293,17 @@ struct inverse_impl : public ReturnByValue<inverse_impl<MatrixType> >
typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned; typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
MatrixTypeNested m_matrix; MatrixTypeNested m_matrix;
EIGEN_DEVICE_FUNC
inverse_impl(const MatrixType& matrix) inverse_impl(const MatrixType& matrix)
: m_matrix(matrix) : m_matrix(matrix)
{} {}
inline Index rows() const { return m_matrix.rows(); } EIGEN_DEVICE_FUNC inline Index rows() const { return m_matrix.rows(); }
inline Index cols() const { return m_matrix.cols(); } EIGEN_DEVICE_FUNC inline Index cols() const { return m_matrix.cols(); }
template<typename Dest> inline void evalTo(Dest& dst) const template<typename Dest>
EIGEN_DEVICE_FUNC
inline void evalTo(Dest& dst) const
{ {
const int Size = EIGEN_PLAIN_ENUM_MIN(MatrixType::ColsAtCompileTime,Dest::ColsAtCompileTime); const int Size = EIGEN_PLAIN_ENUM_MIN(MatrixType::ColsAtCompileTime,Dest::ColsAtCompileTime);
EIGEN_ONLY_USED_FOR_DEBUG(Size); EIGEN_ONLY_USED_FOR_DEBUG(Size);

5
Eigen/src/LU/PartialPivLU.h
View File

@ -469,12 +469,14 @@ struct solve_retval<PartialPivLU<_MatrixType>, Rhs>
* *
* \sa class PartialPivLU * \sa class PartialPivLU
*/ */
#ifndef __CUDACC__
template<typename Derived> template<typename Derived>
inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject> inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
MatrixBase<Derived>::partialPivLu() const MatrixBase<Derived>::partialPivLu() const
{ {
return PartialPivLU<PlainObject>(eval()); return PartialPivLU<PlainObject>(eval());
} }
#endif
#if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS
/** \lu_module /** \lu_module
@ -485,6 +487,7 @@ MatrixBase<Derived>::partialPivLu() const
* *
* \sa class PartialPivLU * \sa class PartialPivLU
*/ */
#ifndef __CUDACC__
template<typename Derived> template<typename Derived>
inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject> inline const PartialPivLU<typename MatrixBase<Derived>::PlainObject>
MatrixBase<Derived>::lu() const MatrixBase<Derived>::lu() const
@ -493,6 +496,8 @@ MatrixBase<Derived>::lu() const
} }
#endif #endif
#endif
} // end namespace Eigen } // end namespace Eigen
#endif // EIGEN_PARTIALLU_H #endif // EIGEN_PARTIALLU_H

14
Eigen/src/plugins/ArrayCwiseUnaryOps.h
View File

@ -7,6 +7,7 @@
* *
* \sa abs2() * \sa abs2()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived>
abs() const abs() const
{ {
@ -20,6 +21,7 @@ abs() const
* *
* \sa abs(), square() * \sa abs(), square()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived>
abs2() const abs2() const
{ {
@ -33,6 +35,7 @@ abs2() const
* *
* \sa pow(), log(), sin(), cos() * \sa pow(), log(), sin(), cos()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_exp_op<Scalar>, const Derived>
exp() const exp() const
{ {
@ -46,6 +49,7 @@ exp() const
* *
* \sa exp() * \sa exp()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_log_op<Scalar>, const Derived>
log() const log() const
{ {
@ -59,6 +63,7 @@ log() const
* *
* \sa pow(), square() * \sa pow(), square()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived>
sqrt() const sqrt() const
{ {
@ -72,6 +77,7 @@ sqrt() const
* *
* \sa sin(), acos() * \sa sin(), acos()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_cos_op<Scalar>, const Derived>
cos() const cos() const
{ {
@ -86,6 +92,7 @@ cos() const
* *
* \sa cos(), asin() * \sa cos(), asin()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_sin_op<Scalar>, const Derived>
sin() const sin() const
{ {
@ -99,6 +106,7 @@ sin() const
* *
* \sa cos(), asin() * \sa cos(), asin()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_acos_op<Scalar>, const Derived>
acos() const acos() const
{ {
@ -112,6 +120,7 @@ acos() const
* *
* \sa sin(), acos() * \sa sin(), acos()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_asin_op<Scalar>, const Derived>
asin() const asin() const
{ {
@ -125,6 +134,7 @@ asin() const
* *
* \sa cos(), sin() * \sa cos(), sin()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_tan_op<Scalar>, Derived> inline const CwiseUnaryOp<internal::scalar_tan_op<Scalar>, Derived>
tan() const tan() const
{ {
@ -139,6 +149,7 @@ tan() const
* *
* \sa exp(), log() * \sa exp(), log()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_pow_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_pow_op<Scalar>, const Derived>
pow(const Scalar& exponent) const pow(const Scalar& exponent) const
{ {
@ -154,6 +165,7 @@ pow(const Scalar& exponent) const
* *
* \sa operator/(), operator*() * \sa operator/(), operator*()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived>
inverse() const inverse() const
{ {
@ -167,6 +179,7 @@ inverse() const
* *
* \sa operator/(), operator*(), abs2() * \sa operator/(), operator*(), abs2()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_square_op<Scalar>, const Derived>
square() const square() const
{ {
@ -180,6 +193,7 @@ square() const
* *
* \sa square(), pow() * \sa square(), pow()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_cube_op<Scalar>, const Derived>
cube() const cube() const
{ {

60
Eigen/src/plugins/BlockMethods.h
View File

@ -53,12 +53,14 @@ template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBloc
* *
* \sa class Block, block(Index,Index) * \sa class Block, block(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) inline Block<Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols)
{ {
return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols); return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols);
} }
/** This is the const version of block(Index,Index,Index,Index). */ /** This is the const version of block(Index,Index,Index,Index). */
EIGEN_DEVICE_FUNC
inline const Block<const Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) const inline const Block<const Derived> block(Index startRow, Index startCol, Index blockRows, Index blockCols) const
{ {
return Block<const Derived>(derived(), startRow, startCol, blockRows, blockCols); return Block<const Derived>(derived(), startRow, startCol, blockRows, blockCols);
@ -77,12 +79,14 @@ inline const Block<const Derived> block(Index startRow, Index startCol, Index bl
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline Block<Derived> topRightCorner(Index cRows, Index cCols) inline Block<Derived> topRightCorner(Index cRows, Index cCols)
{ {
return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols); return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols);
} }
/** This is the const version of topRightCorner(Index, Index).*/ /** This is the const version of topRightCorner(Index, Index).*/
EIGEN_DEVICE_FUNC
inline const Block<const Derived> topRightCorner(Index cRows, Index cCols) const inline const Block<const Derived> topRightCorner(Index cRows, Index cCols) const
{ {
return Block<const Derived>(derived(), 0, cols() - cCols, cRows, cCols); return Block<const Derived>(derived(), 0, cols() - cCols, cRows, cCols);
@ -98,6 +102,7 @@ inline const Block<const Derived> topRightCorner(Index cRows, Index cCols) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline Block<Derived, CRows, CCols> topRightCorner() inline Block<Derived, CRows, CCols> topRightCorner()
{ {
return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols); return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols);
@ -105,6 +110,7 @@ inline Block<Derived, CRows, CCols> topRightCorner()
/** This is the const version of topRightCorner<int, int>().*/ /** This is the const version of topRightCorner<int, int>().*/
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline const Block<const Derived, CRows, CCols> topRightCorner() const inline const Block<const Derived, CRows, CCols> topRightCorner() const
{ {
return Block<const Derived, CRows, CCols>(derived(), 0, cols() - CCols); return Block<const Derived, CRows, CCols>(derived(), 0, cols() - CCols);
@ -123,12 +129,14 @@ inline const Block<const Derived, CRows, CCols> topRightCorner() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline Block<Derived> topLeftCorner(Index cRows, Index cCols) inline Block<Derived> topLeftCorner(Index cRows, Index cCols)
{ {
return Block<Derived>(derived(), 0, 0, cRows, cCols); return Block<Derived>(derived(), 0, 0, cRows, cCols);
} }
/** This is the const version of topLeftCorner(Index, Index).*/ /** This is the const version of topLeftCorner(Index, Index).*/
EIGEN_DEVICE_FUNC
inline const Block<const Derived> topLeftCorner(Index cRows, Index cCols) const inline const Block<const Derived> topLeftCorner(Index cRows, Index cCols) const
{ {
return Block<const Derived>(derived(), 0, 0, cRows, cCols); return Block<const Derived>(derived(), 0, 0, cRows, cCols);
@ -144,6 +152,7 @@ inline const Block<const Derived> topLeftCorner(Index cRows, Index cCols) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline Block<Derived, CRows, CCols> topLeftCorner() inline Block<Derived, CRows, CCols> topLeftCorner()
{ {
return Block<Derived, CRows, CCols>(derived(), 0, 0); return Block<Derived, CRows, CCols>(derived(), 0, 0);
@ -151,6 +160,7 @@ inline Block<Derived, CRows, CCols> topLeftCorner()
/** This is the const version of topLeftCorner<int, int>().*/ /** This is the const version of topLeftCorner<int, int>().*/
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline const Block<const Derived, CRows, CCols> topLeftCorner() const inline const Block<const Derived, CRows, CCols> topLeftCorner() const
{ {
return Block<const Derived, CRows, CCols>(derived(), 0, 0); return Block<const Derived, CRows, CCols>(derived(), 0, 0);
@ -168,12 +178,14 @@ inline const Block<const Derived, CRows, CCols> topLeftCorner() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline Block<Derived> bottomRightCorner(Index cRows, Index cCols) inline Block<Derived> bottomRightCorner(Index cRows, Index cCols)
{ {
return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
} }
/** This is the const version of bottomRightCorner(Index, Index).*/ /** This is the const version of bottomRightCorner(Index, Index).*/
EIGEN_DEVICE_FUNC
inline const Block<const Derived> bottomRightCorner(Index cRows, Index cCols) const inline const Block<const Derived> bottomRightCorner(Index cRows, Index cCols) const
{ {
return Block<const Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols); return Block<const Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
@ -189,6 +201,7 @@ inline const Block<const Derived> bottomRightCorner(Index cRows, Index cCols) co
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline Block<Derived, CRows, CCols> bottomRightCorner() inline Block<Derived, CRows, CCols> bottomRightCorner()
{ {
return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
@ -196,6 +209,7 @@ inline Block<Derived, CRows, CCols> bottomRightCorner()
/** This is the const version of bottomRightCorner<int, int>().*/ /** This is the const version of bottomRightCorner<int, int>().*/
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline const Block<const Derived, CRows, CCols> bottomRightCorner() const inline const Block<const Derived, CRows, CCols> bottomRightCorner() const
{ {
return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols); return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
@ -213,12 +227,14 @@ inline const Block<const Derived, CRows, CCols> bottomRightCorner() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline Block<Derived> bottomLeftCorner(Index cRows, Index cCols) inline Block<Derived> bottomLeftCorner(Index cRows, Index cCols)
{ {
return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols); return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols);
} }
/** This is the const version of bottomLeftCorner(Index, Index).*/ /** This is the const version of bottomLeftCorner(Index, Index).*/
EIGEN_DEVICE_FUNC
inline const Block<const Derived> bottomLeftCorner(Index cRows, Index cCols) const inline const Block<const Derived> bottomLeftCorner(Index cRows, Index cCols) const
{ {
return Block<const Derived>(derived(), rows() - cRows, 0, cRows, cCols); return Block<const Derived>(derived(), rows() - cRows, 0, cRows, cCols);
@ -234,6 +250,7 @@ inline const Block<const Derived> bottomLeftCorner(Index cRows, Index cCols) con
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline Block<Derived, CRows, CCols> bottomLeftCorner() inline Block<Derived, CRows, CCols> bottomLeftCorner()
{ {
return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0); return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0);
@ -241,6 +258,7 @@ inline Block<Derived, CRows, CCols> bottomLeftCorner()
/** This is the const version of bottomLeftCorner<int, int>().*/ /** This is the const version of bottomLeftCorner<int, int>().*/
template<int CRows, int CCols> template<int CRows, int CCols>
EIGEN_DEVICE_FUNC
inline const Block<const Derived, CRows, CCols> bottomLeftCorner() const inline const Block<const Derived, CRows, CCols> bottomLeftCorner() const
{ {
return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, 0); return Block<const Derived, CRows, CCols>(derived(), rows() - CRows, 0);
@ -257,12 +275,14 @@ inline const Block<const Derived, CRows, CCols> bottomLeftCorner() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline RowsBlockXpr topRows(Index n) inline RowsBlockXpr topRows(Index n)
{ {
return RowsBlockXpr(derived(), 0, 0, n, cols()); return RowsBlockXpr(derived(), 0, 0, n, cols());
} }
/** This is the const version of topRows(Index).*/ /** This is the const version of topRows(Index).*/
EIGEN_DEVICE_FUNC
inline ConstRowsBlockXpr topRows(Index n) const inline ConstRowsBlockXpr topRows(Index n) const
{ {
return ConstRowsBlockXpr(derived(), 0, 0, n, cols()); return ConstRowsBlockXpr(derived(), 0, 0, n, cols());
@ -278,6 +298,7 @@ inline ConstRowsBlockXpr topRows(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename NRowsBlockXpr<N>::Type topRows() inline typename NRowsBlockXpr<N>::Type topRows()
{ {
return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols());
@ -285,6 +306,7 @@ inline typename NRowsBlockXpr<N>::Type topRows()
/** This is the const version of topRows<int>().*/ /** This is the const version of topRows<int>().*/
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename ConstNRowsBlockXpr<N>::Type topRows() const inline typename ConstNRowsBlockXpr<N>::Type topRows() const
{ {
return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols()); return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, N, cols());
@ -301,12 +323,14 @@ inline typename ConstNRowsBlockXpr<N>::Type topRows() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline RowsBlockXpr bottomRows(Index n) inline RowsBlockXpr bottomRows(Index n)
{ {
return RowsBlockXpr(derived(), rows() - n, 0, n, cols()); return RowsBlockXpr(derived(), rows() - n, 0, n, cols());
} }
/** This is the const version of bottomRows(Index).*/ /** This is the const version of bottomRows(Index).*/
EIGEN_DEVICE_FUNC
inline ConstRowsBlockXpr bottomRows(Index n) const inline ConstRowsBlockXpr bottomRows(Index n) const
{ {
return ConstRowsBlockXpr(derived(), rows() - n, 0, n, cols()); return ConstRowsBlockXpr(derived(), rows() - n, 0, n, cols());
@ -322,6 +346,7 @@ inline ConstRowsBlockXpr bottomRows(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename NRowsBlockXpr<N>::Type bottomRows() inline typename NRowsBlockXpr<N>::Type bottomRows()
{ {
return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); return typename NRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols());
@ -329,6 +354,7 @@ inline typename NRowsBlockXpr<N>::Type bottomRows()
/** This is the const version of bottomRows<int>().*/ /** This is the const version of bottomRows<int>().*/
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename ConstNRowsBlockXpr<N>::Type bottomRows() const inline typename ConstNRowsBlockXpr<N>::Type bottomRows() const
{ {
return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols()); return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - N, 0, N, cols());
@ -346,12 +372,14 @@ inline typename ConstNRowsBlockXpr<N>::Type bottomRows() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline RowsBlockXpr middleRows(Index startRow, Index numRows) inline RowsBlockXpr middleRows(Index startRow, Index numRows)
{ {
return RowsBlockXpr(derived(), startRow, 0, numRows, cols()); return RowsBlockXpr(derived(), startRow, 0, numRows, cols());
} }
/** This is the const version of middleRows(Index,Index).*/ /** This is the const version of middleRows(Index,Index).*/
EIGEN_DEVICE_FUNC
inline ConstRowsBlockXpr middleRows(Index startRow, Index numRows) const inline ConstRowsBlockXpr middleRows(Index startRow, Index numRows) const
{ {
return ConstRowsBlockXpr(derived(), startRow, 0, numRows, cols()); return ConstRowsBlockXpr(derived(), startRow, 0, numRows, cols());
@ -368,6 +396,7 @@ inline ConstRowsBlockXpr middleRows(Index startRow, Index numRows) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow) inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow)
{ {
return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols());
@ -375,6 +404,7 @@ inline typename NRowsBlockXpr<N>::Type middleRows(Index startRow)
/** This is the const version of middleRows<int>().*/ /** This is the const version of middleRows<int>().*/
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow) const inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow) const
{ {
return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols()); return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, N, cols());
@ -391,12 +421,14 @@ inline typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow) const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline ColsBlockXpr leftCols(Index n) inline ColsBlockXpr leftCols(Index n)
{ {
return ColsBlockXpr(derived(), 0, 0, rows(), n); return ColsBlockXpr(derived(), 0, 0, rows(), n);
} }
/** This is the const version of leftCols(Index).*/ /** This is the const version of leftCols(Index).*/
EIGEN_DEVICE_FUNC
inline ConstColsBlockXpr leftCols(Index n) const inline ConstColsBlockXpr leftCols(Index n) const
{ {
return ConstColsBlockXpr(derived(), 0, 0, rows(), n); return ConstColsBlockXpr(derived(), 0, 0, rows(), n);
@ -412,6 +444,7 @@ inline ConstColsBlockXpr leftCols(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename NColsBlockXpr<N>::Type leftCols() inline typename NColsBlockXpr<N>::Type leftCols()
{ {
return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N);
@ -419,6 +452,7 @@ inline typename NColsBlockXpr<N>::Type leftCols()
/** This is the const version of leftCols<int>().*/ /** This is the const version of leftCols<int>().*/
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename ConstNColsBlockXpr<N>::Type leftCols() const inline typename ConstNColsBlockXpr<N>::Type leftCols() const
{ {
return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N); return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), N);
@ -435,12 +469,14 @@ inline typename ConstNColsBlockXpr<N>::Type leftCols() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline ColsBlockXpr rightCols(Index n) inline ColsBlockXpr rightCols(Index n)
{ {
return ColsBlockXpr(derived(), 0, cols() - n, rows(), n); return ColsBlockXpr(derived(), 0, cols() - n, rows(), n);
} }
/** This is the const version of rightCols(Index).*/ /** This is the const version of rightCols(Index).*/
EIGEN_DEVICE_FUNC
inline ConstColsBlockXpr rightCols(Index n) const inline ConstColsBlockXpr rightCols(Index n) const
{ {
return ConstColsBlockXpr(derived(), 0, cols() - n, rows(), n); return ConstColsBlockXpr(derived(), 0, cols() - n, rows(), n);
@ -456,6 +492,7 @@ inline ConstColsBlockXpr rightCols(Index n) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename NColsBlockXpr<N>::Type rightCols() inline typename NColsBlockXpr<N>::Type rightCols()
{ {
return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N);
@ -463,6 +500,7 @@ inline typename NColsBlockXpr<N>::Type rightCols()
/** This is the const version of rightCols<int>().*/ /** This is the const version of rightCols<int>().*/
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename ConstNColsBlockXpr<N>::Type rightCols() const inline typename ConstNColsBlockXpr<N>::Type rightCols() const
{ {
return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N); return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - N, rows(), N);
@ -480,12 +518,14 @@ inline typename ConstNColsBlockXpr<N>::Type rightCols() const
* *
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline ColsBlockXpr middleCols(Index startCol, Index numCols) inline ColsBlockXpr middleCols(Index startCol, Index numCols)
{ {
return ColsBlockXpr(derived(), 0, startCol, rows(), numCols); return ColsBlockXpr(derived(), 0, startCol, rows(), numCols);
} }
/** This is the const version of middleCols(Index,Index).*/ /** This is the const version of middleCols(Index,Index).*/
EIGEN_DEVICE_FUNC
inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const
{ {
return ConstColsBlockXpr(derived(), 0, startCol, rows(), numCols); return ConstColsBlockXpr(derived(), 0, startCol, rows(), numCols);
@ -502,6 +542,7 @@ inline ConstColsBlockXpr middleCols(Index startCol, Index numCols) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename NColsBlockXpr<N>::Type middleCols(Index startCol) inline typename NColsBlockXpr<N>::Type middleCols(Index startCol)
{ {
return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N);
@ -509,6 +550,7 @@ inline typename NColsBlockXpr<N>::Type middleCols(Index startCol)
/** This is the const version of middleCols<int>().*/ /** This is the const version of middleCols<int>().*/
template<int N> template<int N>
EIGEN_DEVICE_FUNC
inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol) const inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol) const
{ {
return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N); return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), N);
@ -533,6 +575,7 @@ inline typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol) const
* \sa class Block, block(Index,Index,Index,Index) * \sa class Block, block(Index,Index,Index,Index)
*/ */
template<int BlockRows, int BlockCols> template<int BlockRows, int BlockCols>
EIGEN_DEVICE_FUNC
inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol)
{ {
return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
@ -540,6 +583,7 @@ inline Block<Derived, BlockRows, BlockCols> block(Index startRow, Index startCol
/** This is the const version of block<>(Index, Index). */ /** This is the const version of block<>(Index, Index). */
template<int BlockRows, int BlockCols> template<int BlockRows, int BlockCols>
EIGEN_DEVICE_FUNC
inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) const inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, Index startCol) const
{ {
return Block<const Derived, BlockRows, BlockCols>(derived(), startRow, startCol); return Block<const Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
@ -551,12 +595,14 @@ inline const Block<const Derived, BlockRows, BlockCols> block(Index startRow, In
* Output: \verbinclude MatrixBase_col.out * Output: \verbinclude MatrixBase_col.out
* *
* \sa row(), class Block */ * \sa row(), class Block */
EIGEN_DEVICE_FUNC
inline ColXpr col(Index i) inline ColXpr col(Index i)
{ {
return ColXpr(derived(), i); return ColXpr(derived(), i);
} }
/** This is the const version of col(). */ /** This is the const version of col(). */
EIGEN_DEVICE_FUNC
inline ConstColXpr col(Index i) const inline ConstColXpr col(Index i) const
{ {
return ConstColXpr(derived(), i); return ConstColXpr(derived(), i);
@ -568,12 +614,14 @@ inline ConstColXpr col(Index i) const
* Output: \verbinclude MatrixBase_row.out * Output: \verbinclude MatrixBase_row.out
* *
* \sa col(), class Block */ * \sa col(), class Block */
EIGEN_DEVICE_FUNC
inline RowXpr row(Index i) inline RowXpr row(Index i)
{ {
return RowXpr(derived(), i); return RowXpr(derived(), i);
} }
/** This is the const version of row(). */ /** This is the const version of row(). */
EIGEN_DEVICE_FUNC
inline ConstRowXpr row(Index i) const inline ConstRowXpr row(Index i) const
{ {
return ConstRowXpr(derived(), i); return ConstRowXpr(derived(), i);
@ -595,6 +643,7 @@ inline ConstRowXpr row(Index i) const
* *
* \sa class Block, segment(Index) * \sa class Block, segment(Index)
*/ */
EIGEN_DEVICE_FUNC
inline SegmentReturnType segment(Index start, Index vecSize) inline SegmentReturnType segment(Index start, Index vecSize)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -603,6 +652,7 @@ inline SegmentReturnType segment(Index start, Index vecSize)
/** This is the const version of segment(Index,Index).*/ /** This is the const version of segment(Index,Index).*/
EIGEN_DEVICE_FUNC
inline ConstSegmentReturnType segment(Index start, Index vecSize) const inline ConstSegmentReturnType segment(Index start, Index vecSize) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -624,6 +674,7 @@ inline ConstSegmentReturnType segment(Index start, Index vecSize) const
* *
* \sa class Block, block(Index,Index) * \sa class Block, block(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline SegmentReturnType head(Index vecSize) inline SegmentReturnType head(Index vecSize)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -631,6 +682,7 @@ inline SegmentReturnType head(Index vecSize)
} }
/** This is the const version of head(Index).*/ /** This is the const version of head(Index).*/
EIGEN_DEVICE_FUNC
inline ConstSegmentReturnType inline ConstSegmentReturnType
head(Index vecSize) const head(Index vecSize) const
{ {
@ -653,6 +705,7 @@ inline ConstSegmentReturnType
* *
* \sa class Block, block(Index,Index) * \sa class Block, block(Index,Index)
*/ */
EIGEN_DEVICE_FUNC
inline SegmentReturnType tail(Index vecSize) inline SegmentReturnType tail(Index vecSize)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -660,6 +713,7 @@ inline SegmentReturnType tail(Index vecSize)
} }
/** This is the const version of tail(Index).*/ /** This is the const version of tail(Index).*/
EIGEN_DEVICE_FUNC
inline ConstSegmentReturnType tail(Index vecSize) const inline ConstSegmentReturnType tail(Index vecSize) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -680,6 +734,7 @@ inline ConstSegmentReturnType tail(Index vecSize) const
* \sa class Block * \sa class Block
*/ */
template<int Size> template<int Size>
EIGEN_DEVICE_FUNC
inline typename FixedSegmentReturnType<Size>::Type segment(Index start) inline typename FixedSegmentReturnType<Size>::Type segment(Index start)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -688,6 +743,7 @@ inline typename FixedSegmentReturnType<Size>::Type segment(Index start)
/** This is the const version of segment<int>(Index).*/ /** This is the const version of segment<int>(Index).*/
template<int Size> template<int Size>
EIGEN_DEVICE_FUNC
inline typename ConstFixedSegmentReturnType<Size>::Type segment(Index start) const inline typename ConstFixedSegmentReturnType<Size>::Type segment(Index start) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -706,6 +762,7 @@ inline typename ConstFixedSegmentReturnType<Size>::Type segment(Index start) con
* \sa class Block * \sa class Block
*/ */
template<int Size> template<int Size>
EIGEN_DEVICE_FUNC
inline typename FixedSegmentReturnType<Size>::Type head() inline typename FixedSegmentReturnType<Size>::Type head()
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -714,6 +771,7 @@ inline typename FixedSegmentReturnType<Size>::Type head()
/** This is the const version of head<int>().*/ /** This is the const version of head<int>().*/
template<int Size> template<int Size>
EIGEN_DEVICE_FUNC
inline typename ConstFixedSegmentReturnType<Size>::Type head() const inline typename ConstFixedSegmentReturnType<Size>::Type head() const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -732,6 +790,7 @@ inline typename ConstFixedSegmentReturnType<Size>::Type head() const
* \sa class Block * \sa class Block
*/ */
template<int Size> template<int Size>
EIGEN_DEVICE_FUNC
inline typename FixedSegmentReturnType<Size>::Type tail() inline typename FixedSegmentReturnType<Size>::Type tail()
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -740,6 +799,7 @@ inline typename FixedSegmentReturnType<Size>::Type tail()
/** This is the const version of tail<int>.*/ /** This is the const version of tail<int>.*/
template<int Size> template<int Size>
EIGEN_DEVICE_FUNC
inline typename ConstFixedSegmentReturnType<Size>::Type tail() const inline typename ConstFixedSegmentReturnType<Size>::Type tail() const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)

1
Eigen/src/plugins/CommonCwiseBinaryOps.h
View File

@ -38,6 +38,7 @@ EIGEN_MAKE_CWISE_BINARY_OP(operator+,internal::scalar_sum_op)
* \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct() * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct()
*/ */
template<typename CustomBinaryOp, typename OtherDerived> template<typename CustomBinaryOp, typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived> EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived>
binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other, const CustomBinaryOp& func = CustomBinaryOp()) const binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other, const CustomBinaryOp& func = CustomBinaryOp()) const
{ {

14
Eigen/src/plugins/CommonCwiseUnaryOps.h
View File

@ -40,11 +40,13 @@ typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstIm
/** \returns an expression of the opposite of \c *this /** \returns an expression of the opposite of \c *this
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_opposite_op<typename internal::traits<Derived>::Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_opposite_op<typename internal::traits<Derived>::Scalar>, const Derived>
operator-() const { return derived(); } operator-() const { return derived(); }
/** \returns an expression of \c *this scaled by the scalar factor \a scalar */ /** \returns an expression of \c *this scaled by the scalar factor \a scalar */
EIGEN_DEVICE_FUNC
inline const ScalarMultipleReturnType inline const ScalarMultipleReturnType
operator*(const Scalar& scalar) const operator*(const Scalar& scalar) const
{ {
@ -57,6 +59,7 @@ const ScalarMultipleReturnType operator*(const RealScalar& scalar) const;
#endif #endif
/** \returns an expression of \c *this divided by the scalar value \a scalar */ /** \returns an expression of \c *this divided by the scalar value \a scalar */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>, const Derived>
operator/(const Scalar& scalar) const operator/(const Scalar& scalar) const
{ {
@ -65,6 +68,7 @@ operator/(const Scalar& scalar) const
} }
/** Overloaded for efficient real matrix times complex scalar value */ /** Overloaded for efficient real matrix times complex scalar value */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived> inline const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived>
operator*(const std::complex<Scalar>& scalar) const operator*(const std::complex<Scalar>& scalar) const
{ {
@ -72,10 +76,12 @@ operator*(const std::complex<Scalar>& scalar) const
(*static_cast<const Derived*>(this), internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar)); (*static_cast<const Derived*>(this), internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar));
} }
EIGEN_DEVICE_FUNC
inline friend const ScalarMultipleReturnType inline friend const ScalarMultipleReturnType
operator*(const Scalar& scalar, const StorageBaseType& matrix) operator*(const Scalar& scalar, const StorageBaseType& matrix)
{ return matrix*scalar; } { return matrix*scalar; }
EIGEN_DEVICE_FUNC
inline friend const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived> inline friend const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived>
operator*(const std::complex<Scalar>& scalar, const StorageBaseType& matrix) operator*(const std::complex<Scalar>& scalar, const StorageBaseType& matrix)
{ return matrix*scalar; } { return matrix*scalar; }
@ -88,6 +94,7 @@ operator*(const std::complex<Scalar>& scalar, const StorageBaseType& matrix)
* \sa class CwiseUnaryOp * \sa class CwiseUnaryOp
*/ */
template<typename NewType> template<typename NewType>
EIGEN_DEVICE_FUNC
typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<typename internal::traits<Derived>::Scalar, NewType>, const Derived> >::type typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<typename internal::traits<Derived>::Scalar, NewType>, const Derived> >::type
cast() const cast() const
{ {
@ -97,6 +104,7 @@ cast() const
/** \returns an expression of the complex conjugate of \c *this. /** \returns an expression of the complex conjugate of \c *this.
* *
* \sa adjoint() */ * \sa adjoint() */
EIGEN_DEVICE_FUNC
inline ConjugateReturnType inline ConjugateReturnType
conjugate() const conjugate() const
{ {
@ -106,12 +114,14 @@ conjugate() const
/** \returns a read-only expression of the real part of \c *this. /** \returns a read-only expression of the real part of \c *this.
* *
* \sa imag() */ * \sa imag() */
EIGEN_DEVICE_FUNC
inline RealReturnType inline RealReturnType
real() const { return derived(); } real() const { return derived(); }
/** \returns an read-only expression of the imaginary part of \c *this. /** \returns an read-only expression of the imaginary part of \c *this.
* *
* \sa real() */ * \sa real() */
EIGEN_DEVICE_FUNC
inline const ImagReturnType inline const ImagReturnType
imag() const { return derived(); } imag() const { return derived(); }
@ -135,6 +145,7 @@ imag() const { return derived(); }
* \sa class CwiseUnaryOp, class CwiseBinaryOp * \sa class CwiseUnaryOp, class CwiseBinaryOp
*/ */
template<typename CustomUnaryOp> template<typename CustomUnaryOp>
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<CustomUnaryOp, const Derived> inline const CwiseUnaryOp<CustomUnaryOp, const Derived>
unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const
{ {
@ -153,6 +164,7 @@ unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const
* \sa class CwiseUnaryOp, class CwiseBinaryOp * \sa class CwiseUnaryOp, class CwiseBinaryOp
*/ */
template<typename CustomViewOp> template<typename CustomViewOp>
EIGEN_DEVICE_FUNC
inline const CwiseUnaryView<CustomViewOp, const Derived> inline const CwiseUnaryView<CustomViewOp, const Derived>
unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const
{ {
@ -162,11 +174,13 @@ unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const
/** \returns a non const expression of the real part of \c *this. /** \returns a non const expression of the real part of \c *this.
* *
* \sa imag() */ * \sa imag() */
EIGEN_DEVICE_FUNC
inline NonConstRealReturnType inline NonConstRealReturnType
real() { return derived(); } real() { return derived(); }
/** \returns a non const expression of the imaginary part of \c *this. /** \returns a non const expression of the imaginary part of \c *this.
* *
* \sa real() */ * \sa real() */
EIGEN_DEVICE_FUNC
inline NonConstImagReturnType inline NonConstImagReturnType
imag() { return derived(); } imag() { return derived(); }

8
Eigen/src/plugins/MatrixCwiseBinaryOps.h
View File

@ -18,6 +18,7 @@
* \sa class CwiseBinaryOp, cwiseAbs2 * \sa class CwiseBinaryOp, cwiseAbs2
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const EIGEN_CWISE_PRODUCT_RETURN_TYPE(Derived,OtherDerived) EIGEN_STRONG_INLINE const EIGEN_CWISE_PRODUCT_RETURN_TYPE(Derived,OtherDerived)
cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{ {
@ -37,6 +38,7 @@ cwiseProduct(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
* \sa cwiseNotEqual(), isApprox(), isMuchSmallerThan() * \sa cwiseNotEqual(), isApprox(), isMuchSmallerThan()
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
inline const CwiseBinaryOp<std::equal_to<Scalar>, const Derived, const OtherDerived> inline const CwiseBinaryOp<std::equal_to<Scalar>, const Derived, const OtherDerived>
cwiseEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const cwiseEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{ {
@ -56,6 +58,7 @@ cwiseEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
* \sa cwiseEqual(), isApprox(), isMuchSmallerThan() * \sa cwiseEqual(), isApprox(), isMuchSmallerThan()
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
inline const CwiseBinaryOp<std::not_equal_to<Scalar>, const Derived, const OtherDerived> inline const CwiseBinaryOp<std::not_equal_to<Scalar>, const Derived, const OtherDerived>
cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{ {
@ -70,6 +73,7 @@ cwiseNotEqual(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
* \sa class CwiseBinaryOp, max() * \sa class CwiseBinaryOp, max()
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar>, const Derived, const OtherDerived> EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar>, const Derived, const OtherDerived>
cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{ {
@ -80,6 +84,7 @@ cwiseMin(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
* *
* \sa class CwiseBinaryOp, min() * \sa class CwiseBinaryOp, min()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar>, const Derived, const ConstantReturnType> EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_min_op<Scalar>, const Derived, const ConstantReturnType>
cwiseMin(const Scalar &other) const cwiseMin(const Scalar &other) const
{ {
@ -94,6 +99,7 @@ cwiseMin(const Scalar &other) const
* \sa class CwiseBinaryOp, min() * \sa class CwiseBinaryOp, min()
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar>, const Derived, const OtherDerived> EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar>, const Derived, const OtherDerived>
cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{ {
@ -104,6 +110,7 @@ cwiseMax(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
* *
* \sa class CwiseBinaryOp, min() * \sa class CwiseBinaryOp, min()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar>, const Derived, const ConstantReturnType> EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_max_op<Scalar>, const Derived, const ConstantReturnType>
cwiseMax(const Scalar &other) const cwiseMax(const Scalar &other) const
{ {
@ -119,6 +126,7 @@ cwiseMax(const Scalar &other) const
* \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse() * \sa class CwiseBinaryOp, cwiseProduct(), cwiseInverse()
*/ */
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived> EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived>
cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const cwiseQuotient(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{ {

5
Eigen/src/plugins/MatrixCwiseUnaryOps.h
View File

@ -17,6 +17,7 @@
* *
* \sa cwiseAbs2() * \sa cwiseAbs2()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived>
cwiseAbs() const { return derived(); } cwiseAbs() const { return derived(); }
@ -27,6 +28,7 @@ cwiseAbs() const { return derived(); }
* *
* \sa cwiseAbs() * \sa cwiseAbs()
*/ */
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> EIGEN_STRONG_INLINE const CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived>
cwiseAbs2() const { return derived(); } cwiseAbs2() const { return derived(); }
@ -37,6 +39,7 @@ cwiseAbs2() const { return derived(); }
* *
* \sa cwisePow(), cwiseSquare() * \sa cwisePow(), cwiseSquare()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived>
cwiseSqrt() const { return derived(); } cwiseSqrt() const { return derived(); }
@ -47,6 +50,7 @@ cwiseSqrt() const { return derived(); }
* *
* \sa cwiseProduct() * \sa cwiseProduct()
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> inline const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived>
cwiseInverse() const { return derived(); } cwiseInverse() const { return derived(); }
@ -59,6 +63,7 @@ cwiseInverse() const { return derived(); }
* *
* \sa cwiseEqual(const MatrixBase<OtherDerived> &) const * \sa cwiseEqual(const MatrixBase<OtherDerived> &) const
*/ */
EIGEN_DEVICE_FUNC
inline const CwiseUnaryOp<std::binder1st<std::equal_to<Scalar> >, const Derived> inline const CwiseUnaryOp<std::binder1st<std::equal_to<Scalar> >, const Derived>
cwiseEqual(const Scalar& s) const cwiseEqual(const Scalar& s) const
{ {