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

a lot of renaming

Browse Source 
internal classes: AaBb -> ei_aa_bb
IntAtRunTimeIfDynamic -> ei_int_if_dynamic
unify UNROLLING_LIMIT (there was no reason to have operator= use
a higher limit)
etc...
This commit is contained in:
Benoit Jacob 2008-03-13 09:33:26 +00:00
parent 16257d44dd
commit afc64f3332
27 changed files with 190 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -75,7 +75,7 @@ template<typename MatrixType, int BlockRows, int BlockCols> class Block
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Block)
EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
typedef typename MatrixType::AsArg MatRef;
@ -142,10 +142,10 @@ template<typename MatrixType, int BlockRows, int BlockCols> class Block
protected:
MatRef m_matrix;
IntAtRunTimeIfDynamic<MatrixType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
IntAtRunTimeIfDynamic<MatrixType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
IntAtRunTimeIfDynamic<RowsAtCompileTime> m_blockRows;
IntAtRunTimeIfDynamic<ColsAtCompileTime> m_blockCols;
ei_int_if_dynamic<MatrixType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
ei_int_if_dynamic<MatrixType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
ei_int_if_dynamic<RowsAtCompileTime> m_blockRows;
ei_int_if_dynamic<ColsAtCompileTime> m_blockCols;
};
/** \returns a dynamic-size expression of a block in *this.

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

@ -44,7 +44,7 @@
* Here is an example illustrating this:
* \include class_CwiseBinaryOp.cpp
*
* \sa class ScalarProductOp, class ScalarQuotientOp
* \sa class ei_scalar_product_op, class ei_scalar_quotient_op
*/
template<typename BinaryOp, typename Lhs, typename Rhs>
struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
@ -64,12 +64,12 @@ struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
};
template<typename BinaryOp, typename Lhs, typename Rhs>
class CwiseBinaryOp : NoOperatorEquals,
class CwiseBinaryOp : ei_no_assignment_operator,
public MatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(CwiseBinaryOp)
EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
typedef typename Lhs::AsArg LhsRef;
typedef typename Rhs::AsArg RhsRef;
@ -102,7 +102,7 @@ class CwiseBinaryOp : NoOperatorEquals,
*
* \sa class CwiseBinaryOp, MatrixBase::operator+
*/
struct ScalarSumOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_sum_op EIGEN_EMPTY_STRUCT {
template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; }
};
@ -111,7 +111,7 @@ struct ScalarSumOp EIGEN_EMPTY_STRUCT {
*
* \sa class CwiseBinaryOp, MatrixBase::operator-
*/
struct ScalarDifferenceOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_difference_op EIGEN_EMPTY_STRUCT {
template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; }
};
@ -120,7 +120,7 @@ struct ScalarDifferenceOp EIGEN_EMPTY_STRUCT {
*
* \sa class CwiseBinaryOp, MatrixBase::cwiseProduct()
*/
struct ScalarProductOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_product_op EIGEN_EMPTY_STRUCT {
template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a * b; }
};
@ -129,7 +129,7 @@ struct ScalarProductOp EIGEN_EMPTY_STRUCT {
*
* \sa class CwiseBinaryOp, MatrixBase::cwiseQuotient()
*/
struct ScalarQuotientOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_quotient_op EIGEN_EMPTY_STRUCT {
template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a / b; }
};
@ -140,10 +140,10 @@ struct ScalarQuotientOp EIGEN_EMPTY_STRUCT {
* \sa class CwiseBinaryOp, MatrixBase::operator-=()
*/
template<typename Derived1, typename Derived2>
const CwiseBinaryOp<ScalarDifferenceOp, Derived1, Derived2>
const CwiseBinaryOp<ei_scalar_difference_op, Derived1, Derived2>
operator-(const MatrixBase<Derived1> &mat1, const MatrixBase<Derived2> &mat2)
{
return CwiseBinaryOp<ScalarDifferenceOp, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
return CwiseBinaryOp<ei_scalar_difference_op, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
}
/** replaces \c *this by \c *this - \a other.
@ -158,7 +158,6 @@ MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
return *this = *this - other;
}
/** \relates MatrixBase
*
* \returns an expression of the sum of \a mat1 and \a mat2
@ -166,10 +165,10 @@ MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
* \sa class CwiseBinaryOp, MatrixBase::operator+=()
*/
template<typename Derived1, typename Derived2>
const CwiseBinaryOp<ScalarSumOp, Derived1, Derived2>
const CwiseBinaryOp<ei_scalar_sum_op, Derived1, Derived2>
operator+(const MatrixBase<Derived1> &mat1, const MatrixBase<Derived2> &mat2)
{
return CwiseBinaryOp<ScalarSumOp, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
return CwiseBinaryOp<ei_scalar_sum_op, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
}
/** replaces \c *this by \c *this + \a other.
@ -184,33 +183,30 @@ MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
return *this = *this + other;
}
/** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
*
* \sa class CwiseBinaryOp
*/
template<typename Derived>
template<typename OtherDerived>
const CwiseBinaryOp<ScalarProductOp, Derived, OtherDerived>
const CwiseBinaryOp<ei_scalar_product_op, Derived, OtherDerived>
MatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) const
{
return CwiseBinaryOp<ScalarProductOp, Derived, OtherDerived>(asArg(), other.asArg());
return CwiseBinaryOp<ei_scalar_product_op, Derived, OtherDerived>(asArg(), other.asArg());
}
/** \returns an expression of the coefficient-wise quotient of *this and \a other
*
* \sa class CwiseBinaryOp
*/
template<typename Derived>
template<typename OtherDerived>
const CwiseBinaryOp<ScalarQuotientOp, Derived, OtherDerived>
const CwiseBinaryOp<ei_scalar_quotient_op, Derived, OtherDerived>
MatrixBase<Derived>::cwiseQuotient(const MatrixBase<OtherDerived> &other) const
{
return CwiseBinaryOp<ScalarQuotientOp, Derived, OtherDerived>(asArg(), other.asArg());
return CwiseBinaryOp<ei_scalar_quotient_op, Derived, OtherDerived>(asArg(), other.asArg());
}
/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
*
* The template parameter \a CustomBinaryOp is the type of the functor
@ -226,5 +222,4 @@ MatrixBase<Derived>::cwise(const MatrixBase<OtherDerived> &other, const CustomBi
return CwiseBinaryOp<CustomBinaryOp, Derived, OtherDerived>(asArg(), other.asArg(), func);
}
#endif // EIGEN_CWISE_BINARY_OP_H

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

@ -54,12 +54,12 @@ struct ei_traits<CwiseUnaryOp<UnaryOp, MatrixType> >
};
template<typename UnaryOp, typename MatrixType>
class CwiseUnaryOp : NoOperatorEquals,
class CwiseUnaryOp : ei_no_assignment_operator,
public MatrixBase<CwiseUnaryOp<UnaryOp, MatrixType> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(CwiseUnaryOp)
EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
typedef typename MatrixType::AsArg MatRef;
@ -86,7 +86,7 @@ class CwiseUnaryOp : NoOperatorEquals,
*
* \sa class CwiseUnaryOp, MatrixBase::operator-
*/
struct ScalarOppositeOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_opposite_op EIGEN_EMPTY_STRUCT {
template<typename Scalar> Scalar operator() (const Scalar& a) const { return -a; }
};
@ -95,7 +95,7 @@ struct ScalarOppositeOp EIGEN_EMPTY_STRUCT {
*
* \sa class CwiseUnaryOp, MatrixBase::cwiseAbs
*/
struct ScalarAbsOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_abs_op EIGEN_EMPTY_STRUCT {
template<typename Scalar> Scalar operator() (const Scalar& a) const { return ei_abs(a); }
};
@ -103,19 +103,19 @@ struct ScalarAbsOp EIGEN_EMPTY_STRUCT {
/** \returns an expression of the opposite of \c *this
*/
template<typename Derived>
const CwiseUnaryOp<ScalarOppositeOp,Derived>
const CwiseUnaryOp<ei_scalar_opposite_op,Derived>
MatrixBase<Derived>::operator-() const
{
return CwiseUnaryOp<ScalarOppositeOp,Derived>(asArg());
return CwiseUnaryOp<ei_scalar_opposite_op,Derived>(asArg());
}
/** \returns an expression of the opposite of \c *this
*/
template<typename Derived>
const CwiseUnaryOp<ScalarAbsOp,Derived>
const CwiseUnaryOp<ei_scalar_abs_op,Derived>
MatrixBase<Derived>::cwiseAbs() const
{
return CwiseUnaryOp<ScalarAbsOp,Derived>(asArg());
return CwiseUnaryOp<ei_scalar_abs_op,Derived>(asArg());
}
@ -143,7 +143,7 @@ MatrixBase<Derived>::cwise(const CustomUnaryOp& func) const
*
* \sa class CwiseUnaryOp, MatrixBase::conjugate()
*/
struct ScalarConjugateOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_conjugate_op EIGEN_EMPTY_STRUCT {
template<typename Scalar> Scalar operator() (const Scalar& a) const { return ei_conj(a); }
};
@ -151,10 +151,10 @@ struct ScalarConjugateOp EIGEN_EMPTY_STRUCT {
*
* \sa adjoint() */
template<typename Derived>
const CwiseUnaryOp<ScalarConjugateOp, Derived>
const CwiseUnaryOp<ei_scalar_conjugate_op, Derived>
MatrixBase<Derived>::conjugate() const
{
return CwiseUnaryOp<ScalarConjugateOp, Derived>(asArg());
return CwiseUnaryOp<ei_scalar_conjugate_op, Derived>(asArg());
}
/** \internal
@ -163,7 +163,7 @@ MatrixBase<Derived>::conjugate() const
* \sa class CwiseUnaryOp, MatrixBase::cast()
*/
template<typename NewType>
struct ScalarCastOp EIGEN_EMPTY_STRUCT {
struct ei_scalar_cast_op EIGEN_EMPTY_STRUCT {
typedef NewType result_type;
template<typename Scalar> NewType operator() (const Scalar& a) const { return static_cast<NewType>(a); }
};
@ -176,14 +176,14 @@ struct ScalarCastOp EIGEN_EMPTY_STRUCT {
* Example: \include MatrixBase_cast.cpp
* Output: \verbinclude MatrixBase_cast.out
*
* \sa class CwiseUnaryOp, class ScalarCastOp
* \sa class CwiseUnaryOp, class ei_scalar_cast_op
*/
template<typename Derived>
template<typename NewType>
const CwiseUnaryOp<ScalarCastOp<NewType>, Derived>
const CwiseUnaryOp<ei_scalar_cast_op<NewType>, Derived>
MatrixBase<Derived>::cast() const
{
return CwiseUnaryOp<ScalarCastOp<NewType>, Derived>(asArg());
return CwiseUnaryOp<ei_scalar_cast_op<NewType>, Derived>(asArg());
}
/** \internal
@ -192,31 +192,31 @@ MatrixBase<Derived>::cast() const
* \sa class CwiseUnaryOp, MatrixBase::operator*, MatrixBase::operator/
*/
template<typename Scalar>
struct ScalarMultipleOp {
ScalarMultipleOp(const Scalar& other) : m_other(other) {}
struct ei_scalar_multiple_op {
ei_scalar_multiple_op(const Scalar& other) : m_other(other) {}
Scalar operator() (const Scalar& a) const { return a * m_other; }
const Scalar m_other;
};
/** \relates MatrixBase \sa class ScalarMultipleOp */
/** \relates MatrixBase \sa class ei_scalar_multiple_op */
template<typename Derived>
const CwiseUnaryOp<ScalarMultipleOp<typename ei_traits<Derived>::Scalar>, Derived>
const CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived>
MatrixBase<Derived>::operator*(const Scalar& scalar) const
{
return CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived>(asArg(), ScalarMultipleOp<Scalar>(scalar));
return CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived>(asArg(), ei_scalar_multiple_op<Scalar>(scalar));
}
/** \relates MatrixBase \sa class ScalarMultipleOp */
/** \relates MatrixBase \sa class ei_scalar_multiple_op */
template<typename Derived>
const CwiseUnaryOp<ScalarMultipleOp<typename ei_traits<Derived>::Scalar>, Derived>
const CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived>
MatrixBase<Derived>::operator/(const Scalar& scalar) const
{
assert(NumTraits<Scalar>::HasFloatingPoint);
return CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived>
(asArg(), ScalarMultipleOp<Scalar>(static_cast<Scalar>(1) / scalar));
return CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived>
(asArg(), ei_scalar_multiple_op<Scalar>(static_cast<Scalar>(1) / scalar));
}
/** \sa ScalarMultipleOp */
/** \sa ei_scalar_multiple_op */
template<typename Derived>
Derived&
MatrixBase<Derived>::operator*=(const Scalar& other)
@ -224,7 +224,7 @@ MatrixBase<Derived>::operator*=(const Scalar& other)
return *this = *this * other;
}
/** \sa ScalarMultipleOp */
/** \sa ei_scalar_multiple_op */
template<typename Derived>
Derived&
MatrixBase<Derived>::operator/=(const Scalar& other)

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

@ -58,7 +58,7 @@ template<typename MatrixType> class DiagonalCoeffs
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(DiagonalCoeffs)
EIGEN_GENERIC_PUBLIC_INTERFACE(DiagonalCoeffs)
typedef typename MatrixType::AsArg MatRef;

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

@ -51,12 +51,12 @@ struct ei_traits<DiagonalMatrix<CoeffsVectorType> >
};
template<typename CoeffsVectorType>
class DiagonalMatrix : NoOperatorEquals,
class DiagonalMatrix : ei_no_assignment_operator,
public MatrixBase<DiagonalMatrix<CoeffsVectorType> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(DiagonalMatrix)
EIGEN_GENERIC_PUBLIC_INTERFACE(DiagonalMatrix)
typedef typename CoeffsVectorType::AsArg CoeffsVecRef;

18
Eigen/src/Core/Dot.h
View File

@ -26,17 +26,17 @@
#define EIGEN_DOT_H
template<int Index, int Size, typename Derived1, typename Derived2>
struct DotUnroller
struct ei_dot_unroller
{
static void run(const Derived1 &v1, const Derived2& v2, typename Derived1::Scalar &dot)
{
DotUnroller<Index-1, Size, Derived1, Derived2>::run(v1, v2, dot);
ei_dot_unroller<Index-1, Size, Derived1, Derived2>::run(v1, v2, dot);
dot += v1.coeff(Index) * ei_conj(v2.coeff(Index));
}
};
template<int Size, typename Derived1, typename Derived2>
struct DotUnroller<0, Size, Derived1, Derived2>
struct ei_dot_unroller<0, Size, Derived1, Derived2>
{
static void run(const Derived1 &v1, const Derived2& v2, typename Derived1::Scalar &dot)
{
@ -45,14 +45,14 @@ struct DotUnroller<0, Size, Derived1, Derived2>
};
template<int Index, typename Derived1, typename Derived2>
struct DotUnroller<Index, Dynamic, Derived1, Derived2>
struct ei_dot_unroller<Index, Dynamic, Derived1, Derived2>
{
static void run(const Derived1&, const Derived2&, typename Derived1::Scalar&) {}
};
// prevent buggy user code from causing an infinite recursion
template<int Index, typename Derived1, typename Derived2>
struct DotUnroller<Index, 0, Derived1, Derived2>
struct ei_dot_unroller<Index, 0, Derived1, Derived2>
{
static void run(const Derived1&, const Derived2&, typename Derived1::Scalar&) {}
};
@ -78,9 +78,9 @@ MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
Scalar res;
if(EIGEN_UNROLLED_LOOPS
&& SizeAtCompileTime != Dynamic
&& SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT)
DotUnroller<SizeAtCompileTime-1,
SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT ? SizeAtCompileTime : Dynamic,
&& SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT)
ei_dot_unroller<SizeAtCompileTime-1,
SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT ? SizeAtCompileTime : Dynamic,
Derived, MatrixBase<OtherDerived> >
::run(*static_cast<const Derived*>(this), other, res);
else
@ -123,7 +123,7 @@ typename NumTraits<typename ei_traits<Derived>::Scalar>::Real MatrixBase<Derived
* \sa norm()
*/
template<typename Derived>
const CwiseUnaryOp<ScalarMultipleOp<typename ei_traits<Derived>::Scalar>, Derived>
const CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived>
MatrixBase<Derived>::normalized() const
{
return (*this) / norm();

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

@ -56,7 +56,7 @@ struct ei_traits<Eval<ExpressionType> >
};
};
template<typename ExpressionType> class Eval : NoOperatorEquals,
template<typename ExpressionType> class Eval : ei_no_assignment_operator,
public Matrix< typename ExpressionType::Scalar,
ExpressionType::RowsAtCompileTime,
ExpressionType::ColsAtCompileTime,
@ -81,7 +81,7 @@ template<typename ExpressionType> class Eval : NoOperatorEquals,
ExpressionType::MaxRowsAtCompileTime,
ExpressionType::MaxColsAtCompileTime> MatrixType;
_EIGEN_BASIC_PUBLIC_INTERFACE(Eval, MatrixType)
_EIGEN_GENERIC_PUBLIC_INTERFACE(Eval, MatrixType)
explicit Eval(const ExpressionType& expr) : MatrixType(expr) {}
};

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

@ -51,7 +51,7 @@ struct ei_traits<EvalOMP<ExpressionType> >
};
};
template<typename ExpressionType> class EvalOMP : NoOperatorEquals,
template<typename ExpressionType> class EvalOMP : ei_no_assignment_operator,
public Matrix< typename ExpressionType::Scalar,
ExpressionType::RowsAtCompileTime,
ExpressionType::ColsAtCompileTime,
@ -72,7 +72,7 @@ template<typename ExpressionType> class EvalOMP : NoOperatorEquals,
ExpressionType::MaxRowsAtCompileTime,
ExpressionType::MaxColsAtCompileTime> MatrixType;
_EIGEN_BASIC_PUBLIC_INTERFACE(EvalOMP, MatrixType)
_EIGEN_GENERIC_PUBLIC_INTERFACE(EvalOMP, MatrixType)
#ifdef _OPENMP
explicit EvalOMP(const ExpressionType& other)

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

@ -46,13 +46,15 @@ template<typename MatrixType> class Map;
template<typename Derived> class Eval;
template<typename Derived> class EvalOMP;
struct ScalarProductOp;
struct ScalarQuotientOp;
struct ScalarOppositeOp;
struct ScalarConjugateOp;
struct ScalarAbsOp;
template<typename NewType> struct ScalarCastOp;
template<typename Scalar> struct ScalarMultipleOp;
struct ei_scalar_sum_op;
struct ei_scalar_difference_op;
struct ei_scalar_product_op;
struct ei_scalar_quotient_op;
struct ei_scalar_opposite_op;
struct ei_scalar_conjugate_op;
struct ei_scalar_abs_op;
template<typename NewType> struct ei_scalar_cast_op;
template<typename Scalar> struct ei_scalar_multiple_op;
template<typename T> struct Reference
{

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

@ -43,12 +43,12 @@ struct ei_traits<Identity<MatrixType> >
};
};
template<typename MatrixType> class Identity : NoOperatorEquals,
template<typename MatrixType> class Identity : ei_no_assignment_operator,
public MatrixBase<Identity<MatrixType> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Identity)
EIGEN_GENERIC_PUBLIC_INTERFACE(Identity)
Identity(int rows, int cols) : m_rows(rows), m_cols(cols)
{
@ -70,8 +70,8 @@ template<typename MatrixType> class Identity : NoOperatorEquals,
}
protected:
const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
};
/** \returns an expression of the identity matrix (not necessarily square).

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

@ -55,7 +55,7 @@ template<typename MatrixType> class Map
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Map)
EIGEN_GENERIC_PUBLIC_INTERFACE(Map)
private:

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

@ -91,7 +91,7 @@ class Matrix : public MatrixBase<Matrix<_Scalar, _Rows, _Cols,
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Matrix)
EIGEN_GENERIC_PUBLIC_INTERFACE(Matrix)
enum { StorageOrder = _StorageOrder };
@ -102,7 +102,7 @@ class Matrix : public MatrixBase<Matrix<_Scalar, _Rows, _Cols,
private:
MatrixStorage<Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime> m_storage;
ei_matrix_storage<Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime> m_storage;
AsArg _asArg() const { return AsArg(*this); }
int _rows() const { return m_storage.rows(); }

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

@ -230,17 +230,17 @@ template<typename Derived> class MatrixBase
/// \name matrix transformation
//@{
template<typename NewType>
const CwiseUnaryOp<ScalarCastOp<NewType>, Derived> cast() const;
const CwiseUnaryOp<ei_scalar_cast_op<NewType>, Derived> cast() const;
const DiagonalMatrix<Derived> asDiagonal() const;
Transpose<Derived> transpose();
const Transpose<Derived> transpose() const;
const CwiseUnaryOp<ScalarConjugateOp, Derived> conjugate() const;
const Transpose<CwiseUnaryOp<ScalarConjugateOp, Derived> > adjoint() const;
const CwiseUnaryOp<ei_scalar_conjugate_op, Derived> conjugate() const;
const Transpose<CwiseUnaryOp<ei_scalar_conjugate_op, Derived> > adjoint() const;
const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived> normalized() const;
const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> normalized() const;
//@}
// FIXME not sure about the following name
@ -295,7 +295,7 @@ template<typename Derived> class MatrixBase
/// \name arithemetic operators
//@{
const CwiseUnaryOp<ScalarOppositeOp,Derived> operator-() const;
const CwiseUnaryOp<ei_scalar_opposite_op,Derived> operator-() const;
template<typename OtherDerived>
Derived& operator+=(const MatrixBase<OtherDerived>& other);
@ -307,10 +307,10 @@ template<typename Derived> class MatrixBase
Derived& operator*=(const Scalar& other);
Derived& operator/=(const Scalar& other);
const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived> operator*(const Scalar& scalar) const;
const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived> operator/(const Scalar& scalar) const;
const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> operator*(const Scalar& scalar) const;
const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> operator/(const Scalar& scalar) const;
friend const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived>
friend const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived>
operator*(const Scalar& scalar, const MatrixBase& matrix)
{ return matrix*scalar; }
@ -318,14 +318,14 @@ template<typename Derived> class MatrixBase
const Product<Derived, OtherDerived>
lazyProduct(const MatrixBase<OtherDerived>& other) const EIGEN_ALWAYS_INLINE;
const CwiseUnaryOp<ScalarAbsOp,Derived> cwiseAbs() const;
const CwiseUnaryOp<ei_scalar_abs_op,Derived> cwiseAbs() const;
template<typename OtherDerived>
const CwiseBinaryOp<ScalarProductOp, Derived, OtherDerived>
const CwiseBinaryOp<ei_scalar_product_op, Derived, OtherDerived>
cwiseProduct(const MatrixBase<OtherDerived> &other) const;
template<typename OtherDerived>
const CwiseBinaryOp<ScalarQuotientOp, Derived, OtherDerived>
const CwiseBinaryOp<ei_scalar_quotient_op, Derived, OtherDerived>
cwiseQuotient(const MatrixBase<OtherDerived> &other) const;
//@}

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

@ -42,7 +42,7 @@ template<typename MatrixType> class MatrixRef
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(MatrixRef)
EIGEN_GENERIC_PUBLIC_INTERFACE(MatrixRef)
MatrixRef(const MatrixType& matrix) : m_matrix(matrix) {}
~MatrixRef() {}

47
Eigen/src/Core/MatrixStorage.h
View File

@ -26,8 +26,7 @@
#ifndef EIGEN_MATRIXSTORAGE_H
#define EIGEN_MATRIXSTORAGE_H
/** \class MatrixStorage
/** \class ei_matrix_storage
*
* \brief Stores the data of a matrix
*
@ -38,15 +37,15 @@
*
* \sa Matrix
*/
template<typename T, int Size, int _Rows, int _Cols> class MatrixStorage;
template<typename T, int Size, int _Rows, int _Cols> class ei_matrix_storage;
// purely fixed-size matrix.
template<typename T, int Size, int _Rows, int _Cols> class MatrixStorage
template<typename T, int Size, int _Rows, int _Cols> class ei_matrix_storage
{
T m_data[Size];
public:
MatrixStorage() {}
MatrixStorage(int,int,int) {}
ei_matrix_storage() {}
ei_matrix_storage(int,int,int) {}
static int rows(void) {return _Rows;}
static int cols(void) {return _Cols;}
void resize(int,int,int) {}
@ -55,14 +54,14 @@ template<typename T, int Size, int _Rows, int _Cols> class MatrixStorage
};
// dynamic-size matrix with fixed-size storage
template<typename T, int Size> class MatrixStorage<T, Size, Dynamic, Dynamic>
template<typename T, int Size> class ei_matrix_storage<T, Size, Dynamic, Dynamic>
{
T m_data[Size];
int m_rows;
int m_cols;
public:
MatrixStorage(int, int rows, int cols) : m_rows(rows), m_cols(cols) {}
~MatrixStorage() {}
ei_matrix_storage(int, int rows, int cols) : m_rows(rows), m_cols(cols) {}
~ei_matrix_storage() {}
int rows(void) const {return m_rows;}
int cols(void) const {return m_cols;}
void resize(int, int rows, int cols)
@ -75,13 +74,13 @@ template<typename T, int Size> class MatrixStorage<T, Size, Dynamic, Dynamic>
};
// dynamic-size matrix with fixed-size storage and fixed width
template<typename T, int Size, int _Cols> class MatrixStorage<T, Size, Dynamic, _Cols>
template<typename T, int Size, int _Cols> class ei_matrix_storage<T, Size, Dynamic, _Cols>
{
T m_data[Size];
int m_rows;
public:
MatrixStorage(int, int rows, int) : m_rows(rows) {}
~MatrixStorage() {}
ei_matrix_storage(int, int rows, int) : m_rows(rows) {}
~ei_matrix_storage() {}
int rows(void) const {return m_rows;}
int cols(void) const {return _Cols;}
void resize(int size, int rows, int)
@ -93,13 +92,13 @@ template<typename T, int Size, int _Cols> class MatrixStorage<T, Size, Dynamic,
};
// dynamic-size matrix with fixed-size storage and fixed height
template<typename T, int Size, int _Rows> class MatrixStorage<T, Size, _Rows, Dynamic>
template<typename T, int Size, int _Rows> class ei_matrix_storage<T, Size, _Rows, Dynamic>
{
T m_data[Size];
int m_cols;
public:
MatrixStorage(int, int, int cols) : m_cols(cols) {}
~MatrixStorage() {}
ei_matrix_storage(int, int, int cols) : m_cols(cols) {}
~ei_matrix_storage() {}
int rows(void) const {return _Rows;}
int cols(void) const {return m_cols;}
void resize(int size, int, int cols)
@ -111,15 +110,15 @@ template<typename T, int Size, int _Rows> class MatrixStorage<T, Size, _Rows, Dy
};
// purely dynamic matrix.
template<typename T> class MatrixStorage<T, Dynamic, Dynamic, Dynamic>
template<typename T> class ei_matrix_storage<T, Dynamic, Dynamic, Dynamic>
{
T *m_data;
int m_rows;
int m_cols;
public:
MatrixStorage(int size, int rows, int cols)
ei_matrix_storage(int size, int rows, int cols)
: m_data(new T[size]), m_rows(rows), m_cols(cols) {}
~MatrixStorage() { delete[] m_data; }
~ei_matrix_storage() { delete[] m_data; }
int rows(void) const {return m_rows;}
int cols(void) const {return m_cols;}
void resize(int size, int rows, int cols)
@ -137,13 +136,13 @@ template<typename T> class MatrixStorage<T, Dynamic, Dynamic, Dynamic>
};
// matrix with dynamic width and fixed height (so that matrix has dynamic size).
template<typename T, int _Rows> class MatrixStorage<T, Dynamic, _Rows, Dynamic>
template<typename T, int _Rows> class ei_matrix_storage<T, Dynamic, _Rows, Dynamic>
{
T *m_data;
int m_cols;
public:
MatrixStorage(int size, int, int cols) : m_data(new T[size]), m_cols(cols) {}
~MatrixStorage() { delete[] m_data; }
ei_matrix_storage(int size, int, int cols) : m_data(new T[size]), m_cols(cols) {}
~ei_matrix_storage() { delete[] m_data; }
static int rows(void) {return _Rows;}
int cols(void) const {return m_cols;}
void resize(int size, int, int cols)
@ -160,13 +159,13 @@ template<typename T, int _Rows> class MatrixStorage<T, Dynamic, _Rows, Dynamic>
};
// matrix with dynamic height and fixed width (so that matrix has dynamic size).
template<typename T, int _Cols> class MatrixStorage<T, Dynamic, Dynamic, _Cols>
template<typename T, int _Cols> class ei_matrix_storage<T, Dynamic, Dynamic, _Cols>
{
T *m_data;
int m_rows;
public:
MatrixStorage(int size, int rows, int) : m_data(new T[size]), m_rows(rows) {}
~MatrixStorage() { delete[] m_data; }
ei_matrix_storage(int size, int rows, int) : m_data(new T[size]), m_rows(rows) {}
~ei_matrix_storage() { delete[] m_data; }
int rows(void) const {return m_rows;}
static int cols(void) {return _Cols;}
void resize(int size, int rows, int)

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

@ -58,7 +58,7 @@ template<typename MatrixType> class Minor
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Minor)
EIGEN_GENERIC_PUBLIC_INTERFACE(Minor)
typedef typename MatrixType::AsArg MatRef;

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

@ -44,12 +44,12 @@ struct ei_traits<Ones<MatrixType> >
};
};
template<typename MatrixType> class Ones : NoOperatorEquals,
template<typename MatrixType> class Ones : ei_no_assignment_operator,
public MatrixBase<Ones<MatrixType> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Ones)
EIGEN_GENERIC_PUBLIC_INTERFACE(Ones)
private:
@ -72,8 +72,8 @@ template<typename MatrixType> class Ones : NoOperatorEquals,
}
protected:
const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
};
/** \returns an expression of a matrix where all coefficients equal one.

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

@ -27,7 +27,7 @@
#define EIGEN_OPERATOREQUALS_H
template<typename Derived1, typename Derived2, int UnrollCount>
struct MatrixOperatorEqualsUnroller
struct ei_matrix_operator_equals_unroller
{
enum {
col = (UnrollCount-1) / Derived1::RowsAtCompileTime,
@ -36,13 +36,13 @@ struct MatrixOperatorEqualsUnroller
static void run(Derived1 &dst, const Derived2 &src)
{
MatrixOperatorEqualsUnroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
ei_matrix_operator_equals_unroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
dst.coeffRef(row, col) = src.coeff(row, col);
}
};
template<typename Derived1, typename Derived2>
struct MatrixOperatorEqualsUnroller<Derived1, Derived2, 1>
struct ei_matrix_operator_equals_unroller<Derived1, Derived2, 1>
{
static void run(Derived1 &dst, const Derived2 &src)
{
@ -52,38 +52,38 @@ struct MatrixOperatorEqualsUnroller<Derived1, Derived2, 1>
// prevent buggy user code from causing an infinite recursion
template<typename Derived1, typename Derived2>
struct MatrixOperatorEqualsUnroller<Derived1, Derived2, 0>
struct ei_matrix_operator_equals_unroller<Derived1, Derived2, 0>
{
static void run(Derived1 &, const Derived2 &) {}
};
template<typename Derived1, typename Derived2>
struct MatrixOperatorEqualsUnroller<Derived1, Derived2, Dynamic>
struct ei_matrix_operator_equals_unroller<Derived1, Derived2, Dynamic>
{
static void run(Derived1 &, const Derived2 &) {}
};
template<typename Derived1, typename Derived2, int UnrollCount>
struct VectorOperatorEqualsUnroller
struct ei_vector_operator_equals_unroller
{
enum { index = UnrollCount - 1 };
static void run(Derived1 &dst, const Derived2 &src)
{
VectorOperatorEqualsUnroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
ei_vector_operator_equals_unroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
dst.coeffRef(index) = src.coeff(index);
}
};
// prevent buggy user code from causing an infinite recursion
template<typename Derived1, typename Derived2>
struct VectorOperatorEqualsUnroller<Derived1, Derived2, 0>
struct ei_vector_operator_equals_unroller<Derived1, Derived2, 0>
{
static void run(Derived1 &, const Derived2 &) {}
};
template<typename Derived1, typename Derived2>
struct VectorOperatorEqualsUnroller<Derived1, Derived2, 1>
struct ei_vector_operator_equals_unroller<Derived1, Derived2, 1>
{
static void run(Derived1 &dst, const Derived2 &src)
{
@ -92,7 +92,7 @@ struct VectorOperatorEqualsUnroller<Derived1, Derived2, 1>
};
template<typename Derived1, typename Derived2>
struct VectorOperatorEqualsUnroller<Derived1, Derived2, Dynamic>
struct ei_vector_operator_equals_unroller<Derived1, Derived2, Dynamic>
{
static void run(Derived1 &, const Derived2 &) {}
};
@ -108,10 +108,10 @@ Derived& MatrixBase<Derived>
assert(size() == other.size());
if(EIGEN_UNROLLED_LOOPS
&& SizeAtCompileTime != Dynamic
&& SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL)
VectorOperatorEqualsUnroller
&& SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT)
ei_vector_operator_equals_unroller
<Derived, OtherDerived,
SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL ? SizeAtCompileTime : Dynamic>::run
SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT ? SizeAtCompileTime : Dynamic>::run
(*static_cast<Derived*>(this), *static_cast<const OtherDerived*>(&other));
else
for(int i = 0; i < size(); i++)
@ -123,11 +123,11 @@ Derived& MatrixBase<Derived>
assert(rows() == other.rows() && cols() == other.cols());
if(EIGEN_UNROLLED_LOOPS
&& SizeAtCompileTime != Dynamic
&& SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL)
&& SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT)
{
MatrixOperatorEqualsUnroller
ei_matrix_operator_equals_unroller
<Derived, OtherDerived,
SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL ? SizeAtCompileTime : Dynamic>::run
SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT ? SizeAtCompileTime : Dynamic>::run
(*static_cast<Derived*>(this), *static_cast<const OtherDerived*>(&other));
}
else

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

@ -26,18 +26,18 @@
#define EIGEN_PRODUCT_H
template<int Index, int Size, typename Lhs, typename Rhs>
struct ProductUnroller
struct ei_product_unroller
{
static void run(int row, int col, const Lhs& lhs, const Rhs& rhs,
typename Lhs::Scalar &res)
{
ProductUnroller<Index-1, Size, Lhs, Rhs>::run(row, col, lhs, rhs, res);
ei_product_unroller<Index-1, Size, Lhs, Rhs>::run(row, col, lhs, rhs, res);
res += lhs.coeff(row, Index) * rhs.coeff(Index, col);
}
};
template<int Size, typename Lhs, typename Rhs>
struct ProductUnroller<0, Size, Lhs, Rhs>
struct ei_product_unroller<0, Size, Lhs, Rhs>
{
static void run(int row, int col, const Lhs& lhs, const Rhs& rhs,
typename Lhs::Scalar &res)
@ -47,14 +47,14 @@ struct ProductUnroller<0, Size, Lhs, Rhs>
};
template<int Index, typename Lhs, typename Rhs>
struct ProductUnroller<Index, Dynamic, Lhs, Rhs>
struct ei_product_unroller<Index, Dynamic, Lhs, Rhs>
{
static void run(int, int, const Lhs&, const Rhs&, typename Lhs::Scalar&) {}
};
// prevent buggy user code from causing an infinite recursion
template<int Index, typename Lhs, typename Rhs>
struct ProductUnroller<Index, 0, Lhs, Rhs>
struct ei_product_unroller<Index, 0, Lhs, Rhs>
{
static void run(int, int, const Lhs&, const Rhs&, typename Lhs::Scalar&) {}
};
@ -84,12 +84,12 @@ struct ei_traits<Product<Lhs, Rhs> >
};
};
template<typename Lhs, typename Rhs> class Product : NoOperatorEquals,
template<typename Lhs, typename Rhs> class Product : ei_no_assignment_operator,
public MatrixBase<Product<Lhs, Rhs> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Product)
EIGEN_GENERIC_PUBLIC_INTERFACE(Product)
typedef typename Lhs::AsArg LhsRef;
typedef typename Rhs::AsArg RhsRef;
@ -111,9 +111,9 @@ template<typename Lhs, typename Rhs> class Product : NoOperatorEquals,
Scalar res;
if(EIGEN_UNROLLED_LOOPS
&& Lhs::ColsAtCompileTime != Dynamic
&& Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT)
ProductUnroller<Lhs::ColsAtCompileTime-1,
Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT ? Lhs::ColsAtCompileTime : Dynamic,
&& Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT)
ei_product_unroller<Lhs::ColsAtCompileTime-1,
Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT ? Lhs::ColsAtCompileTime : Dynamic,
LhsRef, RhsRef>
::run(row, col, m_lhs, m_rhs, res);
else

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

@ -44,12 +44,12 @@ struct ei_traits<Random<MatrixType> >
};
};
template<typename MatrixType> class Random : NoOperatorEquals,
template<typename MatrixType> class Random : ei_no_assignment_operator,
public MatrixBase<Random<MatrixType> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Random)
EIGEN_GENERIC_PUBLIC_INTERFACE(Random)
const Random& _asArg() const { return *this; }
int _rows() const { return m_rows.value(); }
@ -70,8 +70,8 @@ template<typename MatrixType> class Random : NoOperatorEquals,
}
protected:
const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
};
/** \returns a random matrix (not an expression, the matrix is immediately evaluated).

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

@ -25,16 +25,16 @@
#ifndef EIGEN_TRACE_H
#define EIGEN_TRACE_H
template<int Index, int Rows, typename Derived> struct TraceUnroller
template<int Index, int Rows, typename Derived> struct ei_trace_unroller
{
static void run(const Derived &mat, typename Derived::Scalar &trace)
{
TraceUnroller<Index-1, Rows, Derived>::run(mat, trace);
ei_trace_unroller<Index-1, Rows, Derived>::run(mat, trace);
trace += mat.coeff(Index, Index);
}
};
template<int Rows, typename Derived> struct TraceUnroller<0, Rows, Derived>
template<int Rows, typename Derived> struct ei_trace_unroller<0, Rows, Derived>
{
static void run(const Derived &mat, typename Derived::Scalar &trace)
{
@ -42,13 +42,13 @@ template<int Rows, typename Derived> struct TraceUnroller<0, Rows, Derived>
}
};
template<int Index, typename Derived> struct TraceUnroller<Index, Dynamic, Derived>
template<int Index, typename Derived> struct ei_trace_unroller<Index, Dynamic, Derived>
{
static void run(const Derived&, typename Derived::Scalar&) {}
};
// prevent buggy user code from causing an infinite recursion
template<int Index, typename Derived> struct TraceUnroller<Index, 0, Derived>
template<int Index, typename Derived> struct ei_trace_unroller<Index, 0, Derived>
{
static void run(const Derived&, typename Derived::Scalar&) {}
};
@ -64,9 +64,9 @@ MatrixBase<Derived>::trace() const
Scalar res;
if(EIGEN_UNROLLED_LOOPS
&& RowsAtCompileTime != Dynamic
&& RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT)
TraceUnroller<RowsAtCompileTime-1,
RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT ? RowsAtCompileTime : Dynamic, Derived>
&& RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT)
ei_trace_unroller<RowsAtCompileTime-1,
RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT ? RowsAtCompileTime : Dynamic, Derived>
::run(*static_cast<const Derived*>(this), res);
else
{

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

@ -54,7 +54,7 @@ template<typename MatrixType> class Transpose
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Transpose)
EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose)
typedef typename MatrixType::AsArg MatRef;
@ -108,9 +108,9 @@ MatrixBase<Derived>::transpose() const
* Example: \include MatrixBase_adjoint.cpp
* Output: \verbinclude MatrixBase_adjoint.out
*
* \sa transpose(), conjugate(), class Transpose, class ScalarConjugateOp */
* \sa transpose(), conjugate(), class Transpose, class ei_scalar_conjugate_op */
template<typename Derived>
const Transpose<CwiseUnaryOp<ScalarConjugateOp, Derived> >
const Transpose<CwiseUnaryOp<ei_scalar_conjugate_op, Derived> >
MatrixBase<Derived>::adjoint() const
{
return conjugate().transpose();

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

@ -31,18 +31,9 @@
#define EIGEN_UNROLLED_LOOPS (true)
#endif
/** Defines the maximal loop size (i.e., the matrix size NxM) to enable
* meta unrolling of operator=.
*/
#ifndef EIGEN_UNROLLING_LIMIT_OPEQUAL
#define EIGEN_UNROLLING_LIMIT_OPEQUAL 25
#endif
/** Defines the maximal loop size to enable meta unrolling
* of the matrix product, dot product and trace.
*/
#ifndef EIGEN_UNROLLING_LIMIT_PRODUCT
#define EIGEN_UNROLLING_LIMIT_PRODUCT 16
/** Defines the maximal loop size to enable meta unrolling of loops */
#ifndef EIGEN_UNROLLING_LIMIT
#define EIGEN_UNROLLING_LIMIT 16
#endif
#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
@ -105,20 +96,20 @@ EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, -=) \
EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, *=) \
EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, /=)
#define _EIGEN_BASIC_PUBLIC_INTERFACE(Derived, BaseClass) \
friend class MatrixBase<Derived>; \
#define _EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, BaseClass) \
typedef BaseClass Base; \
typedef typename ei_traits<Derived>::Scalar Scalar; \
enum { RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, \
ColsAtCompileTime = ei_traits<Derived>::ColsAtCompileTime, \
MaxRowsAtCompileTime = ei_traits<Derived>::MaxRowsAtCompileTime, \
MaxColsAtCompileTime = ei_traits<Derived>::MaxColsAtCompileTime }; \
using Base::RowsAtCompileTime; \
using Base::ColsAtCompileTime; \
using Base::MaxRowsAtCompileTime; \
using Base::MaxColsAtCompileTime; \
using Base::SizeAtCompileTime; \
using Base::MaxSizeAtCompileTime; \
using Base::IsVectorAtCompileTime;
#define EIGEN_BASIC_PUBLIC_INTERFACE(Derived) \
_EIGEN_BASIC_PUBLIC_INTERFACE(Derived, MatrixBase<Derived>)
#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
_EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, MatrixBase<Derived>) \
friend class MatrixBase<Derived>;
#define EIGEN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
@ -130,34 +121,34 @@ enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight };
// just a workaround because GCC seems to not really like empty structs
#ifdef __GNUG__
struct EiEmptyStruct{char _ei_dummy_;};
#define EIGEN_EMPTY_STRUCT : Eigen::EiEmptyStruct
struct ei_empty_struct{char _ei_dummy_;};
#define EIGEN_EMPTY_STRUCT : Eigen::ei_empty_struct
#else
#define EIGEN_EMPTY_STRUCT
#endif
//classes inheriting NoOperatorEquals don't generate a default operator=.
class NoOperatorEquals
//classes inheriting ei_no_assignment_operator don't generate a default operator=.
class ei_no_assignment_operator
{
private:
NoOperatorEquals& operator=(const NoOperatorEquals&);
ei_no_assignment_operator& operator=(const ei_no_assignment_operator&);
};
template<int Value> class IntAtRunTimeIfDynamic EIGEN_EMPTY_STRUCT
template<int Value> class ei_int_if_dynamic EIGEN_EMPTY_STRUCT
{
public:
IntAtRunTimeIfDynamic() {}
explicit IntAtRunTimeIfDynamic(int) {}
ei_int_if_dynamic() {}
explicit ei_int_if_dynamic(int) {}
static int value() { return Value; }
void setValue(int) {}
};
template<> class IntAtRunTimeIfDynamic<Dynamic>
template<> class ei_int_if_dynamic<Dynamic>
{
int m_value;
IntAtRunTimeIfDynamic() {}
ei_int_if_dynamic() {}
public:
explicit IntAtRunTimeIfDynamic(int value) : m_value(value) {}
explicit ei_int_if_dynamic(int value) : m_value(value) {}
int value() const { return m_value; }
void setValue(int value) { m_value = value; }
};

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

@ -44,12 +44,12 @@ struct ei_traits<Zero<MatrixType> >
};
};
template<typename MatrixType> class Zero : NoOperatorEquals,
template<typename MatrixType> class Zero : ei_no_assignment_operator,
public MatrixBase<Zero<MatrixType> >
{
public:
EIGEN_BASIC_PUBLIC_INTERFACE(Zero)
EIGEN_GENERIC_PUBLIC_INTERFACE(Zero)
private:
@ -73,8 +73,8 @@ template<typename MatrixType> class Zero : NoOperatorEquals,
}
protected:
const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
};
/** \returns an expression of a zero matrix.

2
bench/bench_unrolling
View File

@ -5,7 +5,7 @@
for ((i=1; i<16; ++i)); do
echo "Matrix size: $i x $i :"
$CXX -O3 -I.. -DNDEBUG benchmark.cpp -DMATSIZE=$i -DEIGEN_UNROLLING_LIMIT_OPEQUAL=1024 -DEIGEN_UNROLLING_LIMIT_PRODUCT=25 -o benchmark && time ./benchmark >/dev/null
$CXX -O3 -I.. -DNDEBUG benchmark.cpp -DMATSIZE=$i -DEIGEN_UNROLLING_LIMIT=1024 -DEIGEN_UNROLLING_LIMIT=25 -o benchmark && time ./benchmark >/dev/null
$CXX -O3 -I.. -DNDEBUG -finline-limit=10000 benchmark.cpp -DMATSIZE=$i -DEIGEN_DONT_USE_UNROLLED_LOOPS=1 -o benchmark && time ./benchmark >/dev/null
echo " "
done

6
doc/examples/class_Cast.cpp
View File

@ -4,14 +4,14 @@ using namespace std;
template<typename Derived>
const Eigen::CwiseUnaryOp<
Eigen::ScalarCastOp<
typename Eigen::NumTraits<typename Derived::Scalar>::FloatingPoint
Eigen::ei_scalar_cast_op<
typename Eigen::ei_traits<typename Derived::Scalar>::FloatingPoint
>, Derived
>
castToFloatingPoint(const MatrixBase<Derived>& m)
{
return m.template cast<
typename Eigen::NumTraits<
typename Eigen::ei_traits<
typename Derived::Scalar
>::FloatingPoint
>();

2
test/submatrices.cpp
View File

@ -28,7 +28,7 @@ namespace Eigen {
// check minor separately in order to avoid the possible creation of a zero-sized
// array. Comes from a compilation error with gcc-3.4 or gcc-4 with -ansi -pedantic.
// Another solution would be to declare the array like this: T m_data[Size==0?1:Size]; in MatrixStorage
// Another solution would be to declare the array like this: T m_data[Size==0?1:Size]; in ei_matrix_storage
// but this is probably not bad to raise such an error at compile time...
template<typename Scalar, int _Rows, int _Cols> struct CheckMinor
{