From 495eb7053ab7101f714718332399d51b10645b8b Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Sun, 6 Jan 2008 13:17:07 +0000 Subject: Patch by Gael Guennebaud, making Eigen compatible with the Intel compiler (icc). CCMAIL:eigen@lists.tuxfamily.org --- Eigen/src/Core/Block.h | 8 +++--- Eigen/src/Core/Coeffs.h | 16 +++++------ Eigen/src/Core/Column.h | 7 +++-- Eigen/src/Core/Conjugate.h | 8 +++--- Eigen/src/Core/DiagonalCoeffs.h | 8 +++--- Eigen/src/Core/DiagonalMatrix.h | 10 +++---- Eigen/src/Core/Difference.h | 8 +++--- Eigen/src/Core/Dot.h | 6 ++-- Eigen/src/Core/DynBlock.h | 8 +++--- Eigen/src/Core/Eval.h | 6 ++-- Eigen/src/Core/Fuzzy.h | 6 ++-- Eigen/src/Core/Identity.h | 4 +++ Eigen/src/Core/Map.h | 17 ++++++------ Eigen/src/Core/Matrix.h | 49 +++++++++++++++++---------------- Eigen/src/Core/MatrixBase.h | 61 +++++++++++++++++++++++------------------ Eigen/src/Core/MatrixRef.h | 8 +++--- Eigen/src/Core/Minor.h | 8 +++--- Eigen/src/Core/Ones.h | 19 +++++++------ Eigen/src/Core/OperatorEquals.h | 12 ++++---- Eigen/src/Core/Opposite.h | 8 +++--- Eigen/src/Core/Product.h | 6 ++-- Eigen/src/Core/Random.h | 19 +++++++------ Eigen/src/Core/Row.h | 8 +++--- Eigen/src/Core/ScalarMultiple.h | 8 +++--- Eigen/src/Core/Sum.h | 8 +++--- Eigen/src/Core/Trace.h | 4 +-- Eigen/src/Core/Transpose.h | 8 +++--- Eigen/src/Core/Zero.h | 18 ++++++------ 28 files changed, 187 insertions(+), 169 deletions(-) diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h index 19552308e..27ef2cb14 100644 --- a/Eigen/src/Core/Block.h +++ b/Eigen/src/Core/Block.h @@ -66,11 +66,11 @@ template class Block EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block) + static const TraversalOrder Order = MatrixType::Order; + static const int RowsAtCompileTime = BlockRows, + ColsAtCompileTime = BlockCols; + private: - static const TraversalOrder _Order = MatrixType::Order; - static const int _RowsAtCompileTime = BlockRows, - _ColsAtCompileTime = BlockCols; - const Block& _ref() const { return *this; } int _rows() const { return BlockRows; } int _cols() const { return BlockCols; } diff --git a/Eigen/src/Core/Coeffs.h b/Eigen/src/Core/Coeffs.h index 6c48a40c5..a902fc9ba 100644 --- a/Eigen/src/Core/Coeffs.h +++ b/Eigen/src/Core/Coeffs.h @@ -116,8 +116,8 @@ template Scalar MatrixBase ::coeff(int index) const { - eigen_internal_assert(IsVectorAtCompileTime); - if(RowsAtCompileTime == 1) + eigen_internal_assert(Traits::IsVectorAtCompileTime); + if(Traits::RowsAtCompileTime == 1) { eigen_internal_assert(index >= 0 && index < cols()); return coeff(0, index); @@ -140,8 +140,8 @@ template Scalar MatrixBase ::operator[](int index) const { - assert(IsVectorAtCompileTime); - if(RowsAtCompileTime == 1) + assert(Traits::IsVectorAtCompileTime); + if(Traits::RowsAtCompileTime == 1) { assert(index >= 0 && index < cols()); return coeff(0, index); @@ -171,8 +171,8 @@ template Scalar& MatrixBase ::coeffRef(int index) { - eigen_internal_assert(IsVectorAtCompileTime); - if(RowsAtCompileTime == 1) + eigen_internal_assert(Traits::IsVectorAtCompileTime); + if(Traits::RowsAtCompileTime == 1) { eigen_internal_assert(index >= 0 && index < cols()); return coeffRef(0, index); @@ -194,8 +194,8 @@ template Scalar& MatrixBase ::operator[](int index) { - assert(IsVectorAtCompileTime); - if(RowsAtCompileTime == 1) + assert(Traits::IsVectorAtCompileTime); + if(Traits::RowsAtCompileTime == 1) { assert(index >= 0 && index < cols()); return coeffRef(0, index); diff --git a/Eigen/src/Core/Column.h b/Eigen/src/Core/Column.h index 1ee63423b..f32eb94e1 100644 --- a/Eigen/src/Core/Column.h +++ b/Eigen/src/Core/Column.h @@ -62,10 +62,11 @@ template class Column EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Column) + static const TraversalOrder Order = ColumnMajor; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = 1; + private: - static const TraversalOrder _Order = ColumnMajor; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = 1; const Column& _ref() const { return *this; } int _rows() const { return m_matrix.rows(); } int _cols() const { return 1; } diff --git a/Eigen/src/Core/Conjugate.h b/Eigen/src/Core/Conjugate.h index 2a900a8e9..b5450ef91 100644 --- a/Eigen/src/Core/Conjugate.h +++ b/Eigen/src/Core/Conjugate.h @@ -48,11 +48,11 @@ template class Conjugate : NoOperatorEquals, Conjugate(const MatRef& matrix) : m_matrix(matrix) {} - private: - static const TraversalOrder _Order = MatrixType::Order; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; + static const TraversalOrder Order = MatrixType::Order; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: const Conjugate& _ref() const { return *this; } int _rows() const { return m_matrix.rows(); } int _cols() const { return m_matrix.cols(); } diff --git a/Eigen/src/Core/DiagonalCoeffs.h b/Eigen/src/Core/DiagonalCoeffs.h index 44904fbcd..0a570c9fc 100644 --- a/Eigen/src/Core/DiagonalCoeffs.h +++ b/Eigen/src/Core/DiagonalCoeffs.h @@ -50,11 +50,11 @@ template class DiagonalCoeffs EIGEN_INHERIT_ASSIGNMENT_OPERATORS(DiagonalCoeffs) + static const TraversalOrder Order = ColumnMajor; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = 1; + private: - static const TraversalOrder _Order = ColumnMajor; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = 1; - const DiagonalCoeffs& _ref() const { return *this; } int _rows() const { return std::min(m_matrix.rows(), m_matrix.cols()); } int _cols() const { return 1; } diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h index 67f10cfb7..99245b750 100644 --- a/Eigen/src/Core/DiagonalMatrix.h +++ b/Eigen/src/Core/DiagonalMatrix.h @@ -51,15 +51,15 @@ class DiagonalMatrix : NoOperatorEquals, DiagonalMatrix(const CoeffsVecRef& coeffs) : m_coeffs(coeffs) { - assert(CoeffsVectorType::IsVectorAtCompileTime + assert(CoeffsVectorType::Traits::IsVectorAtCompileTime && coeffs.size() > 0); } - private: - static const TraversalOrder _Order = Indifferent; - static const int _RowsAtCompileTime = CoeffsVectorType::SizeAtCompileTime, - _ColsAtCompileTime = CoeffsVectorType::SizeAtCompileTime; + static const TraversalOrder Order = Indifferent; + static const int RowsAtCompileTime = CoeffsVectorType::Traits::SizeAtCompileTime, + ColsAtCompileTime = CoeffsVectorType::Traits::SizeAtCompileTime; + private: const DiagonalMatrix& _ref() const { return *this; } int _rows() const { return m_coeffs.size(); } int _cols() const { return m_coeffs.size(); } diff --git a/Eigen/src/Core/Difference.h b/Eigen/src/Core/Difference.h index b249e4e98..8d2e731ee 100644 --- a/Eigen/src/Core/Difference.h +++ b/Eigen/src/Core/Difference.h @@ -41,11 +41,11 @@ template class Difference : NoOperatorEquals, assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); } + static const TraversalOrder Order = Lhs::Order; + static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, + ColsAtCompileTime = Rhs::ColsAtCompileTime; + private: - static const TraversalOrder _Order = Lhs::Order; - static const int _RowsAtCompileTime = Lhs::RowsAtCompileTime, - _ColsAtCompileTime = Rhs::ColsAtCompileTime; - const Difference& _ref() const { return *this; } int _rows() const { return m_lhs.rows(); } int _cols() const { return m_lhs.cols(); } diff --git a/Eigen/src/Core/Dot.h b/Eigen/src/Core/Dot.h index 322ff63a2..b22fbaac8 100644 --- a/Eigen/src/Core/Dot.h +++ b/Eigen/src/Core/Dot.h @@ -72,10 +72,10 @@ template template Scalar MatrixBase::dot(const OtherDerived& other) const { - assert(IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime && size() == other.size()); + assert(Traits::IsVectorAtCompileTime && OtherDerived::Traits::IsVectorAtCompileTime && size() == other.size()); Scalar res; - if(EIGEN_UNROLLED_LOOPS && SizeAtCompileTime != Dynamic && SizeAtCompileTime <= 16) - DotUnroller + if(EIGEN_UNROLLED_LOOPS && Traits::SizeAtCompileTime != Dynamic && Traits::SizeAtCompileTime <= 16) + DotUnroller ::run(*static_cast(this), other, res); else { diff --git a/Eigen/src/Core/DynBlock.h b/Eigen/src/Core/DynBlock.h index e47b09fb1..4f352293b 100644 --- a/Eigen/src/Core/DynBlock.h +++ b/Eigen/src/Core/DynBlock.h @@ -66,12 +66,12 @@ template class DynBlock EIGEN_INHERIT_ASSIGNMENT_OPERATORS(DynBlock) - private: - static const TraversalOrder _Order = MatrixType::Order; + static const TraversalOrder Order = MatrixType::Order; static const int - _RowsAtCompileTime = MatrixType::RowsAtCompileTime == 1 ? 1 : Dynamic, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime == 1 ? 1 : Dynamic; + RowsAtCompileTime = MatrixType::RowsAtCompileTime == 1 ? 1 : Dynamic, + ColsAtCompileTime = MatrixType::ColsAtCompileTime == 1 ? 1 : Dynamic; + private: const DynBlock& _ref() const { return *this; } int _rows() const { return m_blockRows; } int _cols() const { return m_blockCols; } diff --git a/Eigen/src/Core/Eval.h b/Eigen/src/Core/Eval.h index a4bf582f1..039b10b91 100644 --- a/Eigen/src/Core/Eval.h +++ b/Eigen/src/Core/Eval.h @@ -47,12 +47,12 @@ */ template class Eval : NoOperatorEquals, public Matrix< typename Expression::Scalar, - Expression::RowsAtCompileTime, - Expression::ColsAtCompileTime > + Expression::Traits::RowsAtCompileTime, + Expression::Traits::ColsAtCompileTime > { public: typedef typename Expression::Scalar Scalar; - typedef Matrix MatrixType; + typedef Matrix MatrixType; typedef Expression Base; friend class MatrixBase; diff --git a/Eigen/src/Core/Fuzzy.h b/Eigen/src/Core/Fuzzy.h index 6cf076cdc..3641157f7 100644 --- a/Eigen/src/Core/Fuzzy.h +++ b/Eigen/src/Core/Fuzzy.h @@ -34,7 +34,7 @@ bool MatrixBase::isApprox( ) const { assert(rows() == other.rows() && cols() == other.cols()); - if(IsVectorAtCompileTime) + if(Traits::IsVectorAtCompileTime) { return((*this - other).norm2() <= std::min(norm2(), other.norm2()) * prec * prec); } @@ -54,7 +54,7 @@ bool MatrixBase::isMuchSmallerThan( const typename NumTraits::Real& prec = precision() ) const { - if(IsVectorAtCompileTime) + if(Traits::IsVectorAtCompileTime) { return(norm2() <= abs2(other * prec)); } @@ -75,7 +75,7 @@ bool MatrixBase::isMuchSmallerThan( ) const { assert(rows() == other.rows() && cols() == other.cols()); - if(IsVectorAtCompileTime) + if(Traits::IsVectorAtCompileTime) { return(norm2() <= other.norm2() * prec * prec); } diff --git a/Eigen/src/Core/Identity.h b/Eigen/src/Core/Identity.h index 068493125..21e70be5c 100644 --- a/Eigen/src/Core/Identity.h +++ b/Eigen/src/Core/Identity.h @@ -38,6 +38,10 @@ template class Identity : NoOperatorEquals, assert(rows > 0 && _RowsAtCompileTime == _ColsAtCompileTime); } + static const TraversalOrder Order = Indifferent; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: static const TraversalOrder _Order = Indifferent; static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, diff --git a/Eigen/src/Core/Map.h b/Eigen/src/Core/Map.h index fa7a75a49..79a00b92b 100644 --- a/Eigen/src/Core/Map.h +++ b/Eigen/src/Core/Map.h @@ -46,19 +46,18 @@ template class Map typedef typename MatrixType::Scalar Scalar; friend class MatrixBase >; - private: - static const TraversalOrder _Order = MatrixType::Order; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; - + static const TraversalOrder Order = MatrixType::Order; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: const Map& _ref() const { return *this; } int _rows() const { return m_rows; } int _cols() const { return m_cols; } const Scalar& _coeff(int row, int col) const { - if(_Order == ColumnMajor) + if(Order == ColumnMajor) return m_data[row + col * m_rows]; else // RowMajor return m_data[col + row * m_cols]; @@ -66,7 +65,7 @@ template class Map Scalar& _coeffRef(int row, int col) { - if(_Order == ColumnMajor) + if(Order == ColumnMajor) return const_cast(m_data)[row + col * m_rows]; else // RowMajor return const_cast(m_data)[col + row * m_cols]; @@ -76,9 +75,9 @@ template class Map Map(const Scalar* data, int rows, int cols) : m_data(data), m_rows(rows), m_cols(cols) { assert(rows > 0 - && (_RowsAtCompileTime == Dynamic || _RowsAtCompileTime == rows) + && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols > 0 - && (_ColsAtCompileTime == Dynamic || _ColsAtCompileTime == cols)); + && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); } EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map) diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h index 8148e2ac6..4fa997269 100644 --- a/Eigen/src/Core/Matrix.h +++ b/Eigen/src/Core/Matrix.h @@ -91,15 +91,16 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, _Storage Scalar* data() { return Storage::m_data; } + static const TraversalOrder Order = _StorageOrder; + static const int RowsAtCompileTime = _Rows, ColsAtCompileTime = _Cols; + private: - static const TraversalOrder _Order = _StorageOrder; - static const int _RowsAtCompileTime = _Rows, _ColsAtCompileTime = _Cols; - + Ref _ref() const { return Ref(*this); } const Scalar& _coeff(int row, int col) const { - if(_Order == ColumnMajor) + if(Order == ColumnMajor) return (Storage::m_data)[row + col * Storage::_rows()]; else // RowMajor return (Storage::m_data)[col + row * Storage::_cols()]; @@ -107,7 +108,7 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, _Storage Scalar& _coeffRef(int row, int col) { - if(_Order == ColumnMajor) + if(Order == ColumnMajor) return (Storage::m_data)[row + col * Storage::_rows()]; else // RowMajor return (Storage::m_data)[col + row * Storage::_cols()]; @@ -125,12 +126,12 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, _Storage template Matrix& operator=(const MatrixBase& other) { - if(_RowsAtCompileTime == 1) + if(RowsAtCompileTime == 1) { assert(other.isVector()); resize(1, other.size()); } - else if(_ColsAtCompileTime == 1) + else if(ColsAtCompileTime == 1) { assert(other.isVector()); resize(other.size(), 1); @@ -165,7 +166,7 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, _Storage */ explicit Matrix() : Storage() { - assert(_RowsAtCompileTime > 0 && _ColsAtCompileTime > 0); + assert(RowsAtCompileTime > 0 && ColsAtCompileTime > 0); } /** Constructs a vector or row-vector with given dimension. \only_for_vectors @@ -177,10 +178,10 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, _Storage explicit Matrix(int dim) : Storage(dim) { assert(dim > 0); - assert((_RowsAtCompileTime == 1 - && (_ColsAtCompileTime == Dynamic || _ColsAtCompileTime == dim)) - || (_ColsAtCompileTime == 1 - && (_RowsAtCompileTime == Dynamic || _RowsAtCompileTime == dim))); + assert((RowsAtCompileTime == 1 + && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == dim)) + || (ColsAtCompileTime == 1 + && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == dim))); } /** This constructor has two very different behaviors, depending on the type of *this. @@ -195,39 +196,39 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, _Storage */ Matrix(int x, int y) : Storage(x, y) { - if((_RowsAtCompileTime == 1 && _ColsAtCompileTime == 2) - || (_RowsAtCompileTime == 2 && _ColsAtCompileTime == 1)) + if((RowsAtCompileTime == 1 && ColsAtCompileTime == 2) + || (RowsAtCompileTime == 2 && ColsAtCompileTime == 1)) { (Storage::m_data)[0] = x; (Storage::m_data)[1] = y; } else { - assert(x > 0 && (_RowsAtCompileTime == Dynamic || _RowsAtCompileTime == x) - && y > 0 && (_ColsAtCompileTime == Dynamic || _ColsAtCompileTime == y)); + assert(x > 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == x) + && y > 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == y)); } } /** constructs an initialized 2D vector with given coefficients */ Matrix(const float& x, const float& y) { - assert((_RowsAtCompileTime == 1 && _ColsAtCompileTime == 2) - || (_RowsAtCompileTime == 2 && _ColsAtCompileTime == 1)); + assert((RowsAtCompileTime == 1 && ColsAtCompileTime == 2) + || (RowsAtCompileTime == 2 && ColsAtCompileTime == 1)); (Storage::m_data)[0] = x; (Storage::m_data)[1] = y; } /** constructs an initialized 2D vector with given coefficients */ Matrix(const double& x, const double& y) { - assert((_RowsAtCompileTime == 1 && _ColsAtCompileTime == 2) - || (_RowsAtCompileTime == 2 && _ColsAtCompileTime == 1)); + assert((RowsAtCompileTime == 1 && ColsAtCompileTime == 2) + || (RowsAtCompileTime == 2 && ColsAtCompileTime == 1)); (Storage::m_data)[0] = x; (Storage::m_data)[1] = y; } /** constructs an initialized 3D vector with given coefficients */ Matrix(const Scalar& x, const Scalar& y, const Scalar& z) { - assert((_RowsAtCompileTime == 1 && _ColsAtCompileTime == 3) - || (_RowsAtCompileTime == 3 && _ColsAtCompileTime == 1)); + assert((RowsAtCompileTime == 1 && ColsAtCompileTime == 3) + || (RowsAtCompileTime == 3 && ColsAtCompileTime == 1)); (Storage::m_data)[0] = x; (Storage::m_data)[1] = y; (Storage::m_data)[2] = z; @@ -235,8 +236,8 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, _Storage /** constructs an initialized 4D vector with given coefficients */ Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w) { - assert((_RowsAtCompileTime == 1 && _ColsAtCompileTime == 4) - || (_RowsAtCompileTime == 4 && _ColsAtCompileTime == 1)); + assert((RowsAtCompileTime == 1 && ColsAtCompileTime == 4) + || (RowsAtCompileTime == 4 && ColsAtCompileTime == 1)); (Storage::m_data)[0] = x; (Storage::m_data)[1] = y; (Storage::m_data)[2] = z; diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h index 8f556388f..bfcea8cc5 100644 --- a/Eigen/src/Core/MatrixBase.h +++ b/Eigen/src/Core/MatrixBase.h @@ -26,6 +26,39 @@ #ifndef EIGEN_MATRIXBASE_H #define EIGEN_MATRIXBASE_H +#include "Util.h" + +template +struct DerivedTraits +{ + static const TraversalOrder Order = Derived::Order; + + /** The number of rows at compile-time. This is just a copy of the value provided + * by the \a Derived type. If a value is not known at compile-time, + * it is set to the \a Dynamic constant. + * \sa rows(), cols(), ColsAtCompileTime, SizeAtCompileTime */ + static const int RowsAtCompileTime = Derived::RowsAtCompileTime; + + /** The number of columns at compile-time. This is just a copy of the value provided + * by the \a Derived type. If a value is not known at compile-time, + * it is set to the \a Dynamic constant. + * \sa rows(), cols(), RowsAtCompileTime, SizeAtCompileTime */ + static const int ColsAtCompileTime = Derived::ColsAtCompileTime; + + /** This is equal to the number of coefficients, i.e. the number of + * rows times the number of columns, or to \a Dynamic if this is not + * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */ + static const int SizeAtCompileTime + = Derived::RowsAtCompileTime == Dynamic || Derived::ColsAtCompileTime == Dynamic + ? Dynamic : Derived::RowsAtCompileTime * Derived::ColsAtCompileTime; + + /** This is set to true if either the number of rows or the number of + * columns is known at compile-time to be equal to 1. Indeed, in that case, + * we are dealing with a column-vector (if there is only one column) or with + * a row-vector (if there is only one row). */ + static const bool IsVectorAtCompileTime = Derived::RowsAtCompileTime == 1 || Derived::ColsAtCompileTime == 1; +}; + /** \class MatrixBase * * \brief Base class for all matrices, vectors, and expressions @@ -57,31 +90,7 @@ template class MatrixBase { public: - static const TraversalOrder Order = Derived::_Order; - - /** The number of rows at compile-time. This is just a copy of the value provided - * by the \a Derived type. If a value is not known at compile-time, - * it is set to the \a Dynamic constant. - * \sa rows(), cols(), ColsAtCompileTime, SizeAtCompileTime */ - static const int RowsAtCompileTime = Derived::_RowsAtCompileTime; - - /** The number of columns at compile-time. This is just a copy of the value provided - * by the \a Derived type. If a value is not known at compile-time, - * it is set to the \a Dynamic constant. - * \sa rows(), cols(), RowsAtCompileTime, SizeAtCompileTime */ - static const int ColsAtCompileTime = Derived::_ColsAtCompileTime; - - /** This is equal to the number of coefficients, i.e. the number of - * rows times the number of columns, or to \a Dynamic if this is not - * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */ - static const int SizeAtCompileTime - = RowsAtCompileTime == Dynamic || ColsAtCompileTime == Dynamic - ? Dynamic : RowsAtCompileTime * ColsAtCompileTime; - /** This is set to true if either the number of rows or the number of - * columns is known at compile-time to be equal to 1. Indeed, in that case, - * we are dealing with a column-vector (if there is only one column) or with - * a row-vector (if there is only one row). */ - static const bool IsVectorAtCompileTime = RowsAtCompileTime == 1 || ColsAtCompileTime == 1; + typedef DerivedTraits Traits; /** This is the "reference type" used to pass objects of type MatrixBase as arguments * to functions. If this MatrixBase type represents an expression, then \a Ref @@ -170,7 +179,7 @@ template class MatrixBase static const Ones ones(int rows, int cols); static const Ones ones(int size); static const Ones ones(); - static const Identity identity(int rows = RowsAtCompileTime); + static const Identity identity(int rows = Derived::RowsAtCompileTime); bool isZero(const typename NumTraits::Real& prec) const; bool isOnes(const typename NumTraits::Real& prec) const; diff --git a/Eigen/src/Core/MatrixRef.h b/Eigen/src/Core/MatrixRef.h index 57ae4a492..1660a2b01 100644 --- a/Eigen/src/Core/MatrixRef.h +++ b/Eigen/src/Core/MatrixRef.h @@ -38,11 +38,11 @@ template class MatrixRef EIGEN_INHERIT_ASSIGNMENT_OPERATORS(MatrixRef) + static const TraversalOrder Order = MatrixType::Order; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: - static const TraversalOrder _Order = MatrixType::Order; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; - int _rows() const { return m_matrix.rows(); } int _cols() const { return m_matrix.cols(); } diff --git a/Eigen/src/Core/Minor.h b/Eigen/src/Core/Minor.h index 11d47d4ac..5de41f169 100644 --- a/Eigen/src/Core/Minor.h +++ b/Eigen/src/Core/Minor.h @@ -56,14 +56,14 @@ template class Minor EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Minor) - private: - static const TraversalOrder _Order = MatrixType::Order; + static const TraversalOrder Order = MatrixType::Order; static const int - _RowsAtCompileTime = (MatrixType::RowsAtCompileTime != Dynamic) ? + RowsAtCompileTime = (MatrixType::RowsAtCompileTime != Dynamic) ? MatrixType::RowsAtCompileTime - 1 : Dynamic, - _ColsAtCompileTime = (MatrixType::ColsAtCompileTime != Dynamic) ? + ColsAtCompileTime = (MatrixType::ColsAtCompileTime != Dynamic) ? MatrixType::ColsAtCompileTime - 1 : Dynamic; + private: const Minor& _ref() const { return *this; } int _rows() const { return m_matrix.rows() - 1; } int _cols() const { return m_matrix.cols() - 1; } diff --git a/Eigen/src/Core/Ones.h b/Eigen/src/Core/Ones.h index cea830dc8..ede1c1d4f 100644 --- a/Eigen/src/Core/Ones.h +++ b/Eigen/src/Core/Ones.h @@ -39,11 +39,12 @@ template class Ones : NoOperatorEquals, typedef typename MatrixType::Scalar Scalar; friend class MatrixBase >; - private: - static const TraversalOrder _Order = Indifferent; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; + static const TraversalOrder Order = Indifferent; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: + const Ones& _ref() const { return *this; } int _rows() const { return m_rows; } int _cols() const { return m_cols; } @@ -57,9 +58,9 @@ template class Ones : NoOperatorEquals, Ones(int rows, int cols) : m_rows(rows), m_cols(cols) { assert(rows > 0 - && (_RowsAtCompileTime == Dynamic || _RowsAtCompileTime == rows) + && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols > 0 - && (_ColsAtCompileTime == Dynamic || _ColsAtCompileTime == cols)); + && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); } protected: @@ -105,8 +106,8 @@ const Ones MatrixBase::ones(int rows, int cols) template const Ones MatrixBase::ones(int size) { - assert(IsVectorAtCompileTime); - if(RowsAtCompileTime == 1) return Ones(1, size); + assert(Traits::IsVectorAtCompileTime); + if(Traits::RowsAtCompileTime == 1) return Ones(1, size); else return Ones(size, 1); } @@ -123,7 +124,7 @@ const Ones MatrixBase::ones(int size) template const Ones MatrixBase::ones() { - return Ones(RowsAtCompileTime, ColsAtCompileTime); + return Ones(Traits::RowsAtCompileTime, Traits::ColsAtCompileTime); } template diff --git a/Eigen/src/Core/OperatorEquals.h b/Eigen/src/Core/OperatorEquals.h index e2cc5d559..eaadb2478 100644 --- a/Eigen/src/Core/OperatorEquals.h +++ b/Eigen/src/Core/OperatorEquals.h @@ -105,13 +105,13 @@ template Derived& MatrixBase ::operator=(const MatrixBase& other) { - if(IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime) + if(Traits::IsVectorAtCompileTime && OtherDerived::Traits::IsVectorAtCompileTime) // copying a vector expression into a vector { assert(size() == other.size()); - if(EIGEN_UNROLLED_LOOPS && SizeAtCompileTime != Dynamic && SizeAtCompileTime <= 25) + if(EIGEN_UNROLLED_LOOPS && Traits::SizeAtCompileTime != Dynamic && Traits::SizeAtCompileTime <= 25) VectorOperatorEqualsUnroller - ::run + ::run (*static_cast(this), *static_cast(&other)); else for(int i = 0; i < size(); i++) @@ -121,13 +121,13 @@ Derived& MatrixBase else // copying a matrix expression into a matrix { assert(rows() == other.rows() && cols() == other.cols()); - if(EIGEN_UNROLLED_LOOPS && SizeAtCompileTime != Dynamic && SizeAtCompileTime <= 25) + if(EIGEN_UNROLLED_LOOPS && Traits::SizeAtCompileTime != Dynamic && Traits::SizeAtCompileTime <= 25) MatrixOperatorEqualsUnroller - ::run + ::run (*static_cast(this), *static_cast(&other)); else { - if(Order == ColumnMajor) + if(Traits::Order == ColumnMajor) for(int j = 0; j < cols(); j++) for(int i = 0; i < rows(); i++) coeffRef(i, j) = other.coeff(i, j); diff --git a/Eigen/src/Core/Opposite.h b/Eigen/src/Core/Opposite.h index e0b6c1ac3..1b1139c9d 100644 --- a/Eigen/src/Core/Opposite.h +++ b/Eigen/src/Core/Opposite.h @@ -36,11 +36,11 @@ template class Opposite : NoOperatorEquals, Opposite(const MatRef& matrix) : m_matrix(matrix) {} - private: - static const TraversalOrder _Order = MatrixType::Order; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; + static const TraversalOrder Order = MatrixType::Order; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: const Opposite& _ref() const { return *this; } int _rows() const { return m_matrix.rows(); } int _cols() const { return m_matrix.cols(); } diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h index db261491e..3c790bd84 100644 --- a/Eigen/src/Core/Product.h +++ b/Eigen/src/Core/Product.h @@ -75,9 +75,11 @@ template class Product : NoOperatorEquals, assert(lhs.cols() == rhs.rows()); } + static const TraversalOrder Order = Lhs::Order; + static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, + ColsAtCompileTime = Rhs::ColsAtCompileTime; + private: - static const int _RowsAtCompileTime = Lhs::RowsAtCompileTime, - _ColsAtCompileTime = Rhs::ColsAtCompileTime; const Product& _ref() const { return *this; } int _rows() const { return m_lhs.rows(); } diff --git a/Eigen/src/Core/Random.h b/Eigen/src/Core/Random.h index 1b870af74..164c24e30 100644 --- a/Eigen/src/Core/Random.h +++ b/Eigen/src/Core/Random.h @@ -39,11 +39,12 @@ template class Random : NoOperatorEquals, typedef typename MatrixType::Scalar Scalar; friend class MatrixBase >; + static const TraversalOrder Order = Indifferent; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: - static const TraversalOrder _Order = Indifferent; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; - + const Random& _ref() const { return *this; } int _rows() const { return m_rows; } int _cols() const { return m_cols; } @@ -57,9 +58,9 @@ template class Random : NoOperatorEquals, Random(int rows, int cols) : m_rows(rows), m_cols(cols) { assert(rows > 0 - && (_RowsAtCompileTime == Dynamic || _RowsAtCompileTime == rows) + && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols > 0 - && (_ColsAtCompileTime == Dynamic || _ColsAtCompileTime == cols)); + && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); } protected: @@ -105,8 +106,8 @@ const Eval > MatrixBase::random(int rows, int c template const Eval > MatrixBase::random(int size) { - assert(IsVectorAtCompileTime); - if(RowsAtCompileTime == 1) return Random(1, size).eval(); + assert(Traits::IsVectorAtCompileTime); + if(Traits::RowsAtCompileTime == 1) return Random(1, size).eval(); else return Random(size, 1).eval(); } @@ -124,7 +125,7 @@ const Eval > MatrixBase::random(int size) template const Eval > MatrixBase::random() { - return Random(RowsAtCompileTime, ColsAtCompileTime).eval(); + return Random(Traits::RowsAtCompileTime, Traits::ColsAtCompileTime).eval(); } #endif // EIGEN_RANDOM_H diff --git a/Eigen/src/Core/Row.h b/Eigen/src/Core/Row.h index 40f53de4c..7ba3a13a0 100644 --- a/Eigen/src/Core/Row.h +++ b/Eigen/src/Core/Row.h @@ -68,11 +68,11 @@ template class Row EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Row) - private: - static const TraversalOrder _Order = RowMajor; - static const int _RowsAtCompileTime = 1, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; + static const TraversalOrder Order = RowMajor; + static const int RowsAtCompileTime = 1, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: const Row& _ref() const { return *this; } int _rows() const { return 1; } diff --git a/Eigen/src/Core/ScalarMultiple.h b/Eigen/src/Core/ScalarMultiple.h index 76a4477cc..c60ef5f4a 100644 --- a/Eigen/src/Core/ScalarMultiple.h +++ b/Eigen/src/Core/ScalarMultiple.h @@ -37,11 +37,11 @@ template class ScalarMultiple : NoOper ScalarMultiple(const MatRef& matrix, FactorType factor) : m_matrix(matrix), m_factor(factor) {} - private: - static const TraversalOrder _Order = MatrixType::Order; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; + static const TraversalOrder Order = MatrixType::Order; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: const ScalarMultiple& _ref() const { return *this; } int _rows() const { return m_matrix.rows(); } int _cols() const { return m_matrix.cols(); } diff --git a/Eigen/src/Core/Sum.h b/Eigen/src/Core/Sum.h index 453033673..a566077dd 100644 --- a/Eigen/src/Core/Sum.h +++ b/Eigen/src/Core/Sum.h @@ -41,11 +41,11 @@ template class Sum : NoOperatorEquals, assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); } - private: - static const TraversalOrder _Order = Lhs::Order; - static const int _RowsAtCompileTime = Lhs::RowsAtCompileTime, - _ColsAtCompileTime = Rhs::ColsAtCompileTime; + static const TraversalOrder Order = Lhs::Order; + static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, + ColsAtCompileTime = Rhs::ColsAtCompileTime; + private: const Sum& _ref() const { return *this; } int _rows() const { return m_lhs.rows(); } int _cols() const { return m_lhs.cols(); } diff --git a/Eigen/src/Core/Trace.h b/Eigen/src/Core/Trace.h index cfe7c7937..24a31a2f8 100644 --- a/Eigen/src/Core/Trace.h +++ b/Eigen/src/Core/Trace.h @@ -62,8 +62,8 @@ Scalar MatrixBase::trace() const { assert(rows() == cols()); Scalar res; - if(EIGEN_UNROLLED_LOOPS && RowsAtCompileTime != Dynamic && RowsAtCompileTime <= 16) - TraceUnroller + if(EIGEN_UNROLLED_LOOPS && Traits::RowsAtCompileTime != Dynamic && Traits::RowsAtCompileTime <= 16) + TraceUnroller ::run(*static_cast(this), res); else { diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h index dd0f8cc3e..b6a19c751 100644 --- a/Eigen/src/Core/Transpose.h +++ b/Eigen/src/Core/Transpose.h @@ -50,12 +50,12 @@ template class Transpose EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Transpose) - private: - static const TraversalOrder _Order = (MatrixType::Order == ColumnMajor) + static const TraversalOrder Order = (MatrixType::Order == ColumnMajor) ? RowMajor : ColumnMajor; - static const int _RowsAtCompileTime = MatrixType::ColsAtCompileTime, - _ColsAtCompileTime = MatrixType::RowsAtCompileTime; + static const int RowsAtCompileTime = MatrixType::ColsAtCompileTime, + ColsAtCompileTime = MatrixType::RowsAtCompileTime; + private: const Transpose& _ref() const { return *this; } int _rows() const { return m_matrix.cols(); } int _cols() const { return m_matrix.rows(); } diff --git a/Eigen/src/Core/Zero.h b/Eigen/src/Core/Zero.h index 56ada635a..5dd6b7e7d 100644 --- a/Eigen/src/Core/Zero.h +++ b/Eigen/src/Core/Zero.h @@ -39,11 +39,11 @@ template class Zero : NoOperatorEquals, typedef typename MatrixType::Scalar Scalar; friend class MatrixBase >; - private: - static const TraversalOrder _Order = Indifferent; - static const int _RowsAtCompileTime = MatrixType::RowsAtCompileTime, - _ColsAtCompileTime = MatrixType::ColsAtCompileTime; + static const TraversalOrder Order = Indifferent; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + private: const Zero& _ref() const { return *this; } int _rows() const { return m_rows; } int _cols() const { return m_cols; } @@ -57,9 +57,9 @@ template class Zero : NoOperatorEquals, Zero(int rows, int cols) : m_rows(rows), m_cols(cols) { assert(rows > 0 - && (_RowsAtCompileTime == Dynamic || _RowsAtCompileTime == rows) + && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows) && cols > 0 - && (_ColsAtCompileTime == Dynamic || _ColsAtCompileTime == cols)); + && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); } protected: @@ -105,8 +105,8 @@ const Zero MatrixBase::zero(int rows, int cols) template const Zero MatrixBase::zero(int size) { - assert(IsVectorAtCompileTime); - if(RowsAtCompileTime == 1) return Zero(1, size); + assert(Traits::IsVectorAtCompileTime); + if(Traits::RowsAtCompileTime == 1) return Zero(1, size); else return Zero(size, 1); } @@ -123,7 +123,7 @@ const Zero MatrixBase::zero(int size) template const Zero MatrixBase::zero() { - return Zero(RowsAtCompileTime, ColsAtCompileTime); + return Zero(Traits::RowsAtCompileTime, Traits::ColsAtCompileTime); } template -- cgit v1.2.3