diff options
author | Benoit Jacob <jacob.benoit.1@gmail.com> | 2008-01-15 13:55:47 +0000 |
---|---|---|
committer | Benoit Jacob <jacob.benoit.1@gmail.com> | 2008-01-15 13:55:47 +0000 |
commit | c67e717404258d3625a74c67f50be34939af6d95 (patch) | |
tree | 2eab0b2e520acb2ccbd88fa8242a2c9c9ea8b980 | |
parent | 9c9a42cc49f9c7f0e0d87c827734262cc5f5fbc3 (diff) |
alpha 3.1. in this commit:
- finally get the Eval stuff right. get back to having Eval as
a subclass of Matrix with limited functionality, and then,
add a typedef MatrixType to get the actual matrix type.
- add swap(), findBiggestCoeff()
- bugfix by Ramon in Transpose
- new demo: doc/echelon.cpp
32 files changed, 262 insertions, 94 deletions
diff --git a/Eigen/Core b/Eigen/Core index 12b55b0da..a897e4f45 100644 --- a/Eigen/Core +++ b/Eigen/Core @@ -4,8 +4,8 @@ namespace Eigen { -#include "src/Core/Util.h" #include "src/Core/ForwardDeclarations.h" +#include "src/Core/Util.h" #include "src/Core/NumTraits.h" #include "src/Core/MathFunctions.h" #include "src/Core/MatrixBase.h" @@ -38,5 +38,6 @@ namespace Eigen { #include "src/Core/Fuzzy.h" #include "src/Core/Map.h" #include "src/Core/IO.h" +#include "src/Core/Swap.h" } // namespace Eigen diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h index c09004832..6be263938 100644 --- a/Eigen/src/Core/Block.h +++ b/Eigen/src/Core/Block.h @@ -56,8 +56,9 @@ template<typename MatrixType> class Block public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Block<MatrixType> >; - + friend class MatrixBase<Scalar, Block>; + typedef MatrixBase<Scalar, Block> Base; + Block(const MatRef& matrix, int startRow, int startCol, int blockRows, int blockCols) diff --git a/Eigen/src/Core/Cast.h b/Eigen/src/Core/Cast.h index 433be3ad7..962bb862f 100644 --- a/Eigen/src/Core/Cast.h +++ b/Eigen/src/Core/Cast.h @@ -52,7 +52,8 @@ template<typename NewScalar, typename MatrixType> class Cast : NoOperatorEquals, public: typedef NewScalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Cast<Scalar, MatrixType> >; + friend class MatrixBase<Scalar, Cast>; + typedef MatrixBase<Scalar, Cast> Base; Cast(const MatRef& matrix) : m_matrix(matrix) {} diff --git a/Eigen/src/Core/Column.h b/Eigen/src/Core/Column.h index bb92c3b11..9945ff4c0 100644 --- a/Eigen/src/Core/Column.h +++ b/Eigen/src/Core/Column.h @@ -52,7 +52,8 @@ template<typename MatrixType> class Column public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Column<MatrixType> >; + friend class MatrixBase<Scalar, Column>; + typedef MatrixBase<Scalar, Column> Base; Column(const MatRef& matrix, int col) : m_matrix(matrix), m_col(col) diff --git a/Eigen/src/Core/Conjugate.h b/Eigen/src/Core/Conjugate.h index 16cebccb6..839a43bc7 100644 --- a/Eigen/src/Core/Conjugate.h +++ b/Eigen/src/Core/Conjugate.h @@ -44,7 +44,8 @@ template<typename MatrixType> class Conjugate : NoOperatorEquals, public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Conjugate<MatrixType> >; + friend class MatrixBase<Scalar, Conjugate>; + typedef MatrixBase<Scalar, Conjugate> Base; Conjugate(const MatRef& matrix) : m_matrix(matrix) {} diff --git a/Eigen/src/Core/DiagonalCoeffs.h b/Eigen/src/Core/DiagonalCoeffs.h index 80f402305..ea7043dc3 100644 --- a/Eigen/src/Core/DiagonalCoeffs.h +++ b/Eigen/src/Core/DiagonalCoeffs.h @@ -44,8 +44,9 @@ template<typename MatrixType> class DiagonalCoeffs public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, DiagonalCoeffs<MatrixType> >; - + friend class MatrixBase<Scalar, DiagonalCoeffs>; + typedef MatrixBase<Scalar, DiagonalCoeffs> Base; + DiagonalCoeffs(const MatRef& matrix) : m_matrix(matrix) {} EIGEN_INHERIT_ASSIGNMENT_OPERATORS(DiagonalCoeffs) diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h index 7c55db920..b8ce5d2d5 100644 --- a/Eigen/src/Core/DiagonalMatrix.h +++ b/Eigen/src/Core/DiagonalMatrix.h @@ -47,8 +47,9 @@ class DiagonalMatrix : NoOperatorEquals, public: typedef typename CoeffsVectorType::Scalar Scalar; typedef typename CoeffsVectorType::Ref CoeffsVecRef; - friend class MatrixBase<Scalar, DiagonalMatrix<CoeffsVectorType> >; - + friend class MatrixBase<Scalar, DiagonalMatrix>; + typedef MatrixBase<Scalar, DiagonalMatrix> Base; + DiagonalMatrix(const CoeffsVecRef& coeffs) : m_coeffs(coeffs) { assert(CoeffsVectorType::Traits::IsVectorAtCompileTime diff --git a/Eigen/src/Core/Difference.h b/Eigen/src/Core/Difference.h index 99cf5674f..645de9151 100644 --- a/Eigen/src/Core/Difference.h +++ b/Eigen/src/Core/Difference.h @@ -47,7 +47,8 @@ template<typename Lhs, typename Rhs> class Difference : NoOperatorEquals, typedef typename Lhs::Ref LhsRef; typedef typename Rhs::Ref RhsRef; friend class MatrixBase<Scalar, Difference>; - + typedef MatrixBase<Scalar, Difference> Base; + Difference(const LhsRef& lhs, const RhsRef& rhs) : m_lhs(lhs), m_rhs(rhs) { diff --git a/Eigen/src/Core/Eval.h b/Eigen/src/Core/Eval.h index f4ffca655..46f6ced73 100644 --- a/Eigen/src/Core/Eval.h +++ b/Eigen/src/Core/Eval.h @@ -45,53 +45,33 @@ * * \sa MatrixBase::eval() */ -template<typename ExpressionType> class Eval - : public MatrixBase<typename ExpressionType::Scalar, Eval<ExpressionType> > +template<typename ExpressionType> class Eval : NoOperatorEquals, + public Matrix< typename ExpressionType::Scalar, + ExpressionType::Traits::RowsAtCompileTime, + ExpressionType::Traits::ColsAtCompileTime, + EIGEN_DEFAULT_MATRIX_STORAGE_ORDER, + ExpressionType::Traits::MaxRowsAtCompileTime, + ExpressionType::Traits::MaxColsAtCompileTime> { public: typedef typename ExpressionType::Scalar Scalar; - friend class MatrixBase<Scalar, Eval>; - typedef MatrixBase<Scalar, Eval> Base; - friend class MatrixRef<Eval>; - typedef MatrixRef<Eval> Ref; - - private: - enum { - RowsAtCompileTime = ExpressionType::Traits::RowsAtCompileTime, - ColsAtCompileTime = ExpressionType::Traits::ColsAtCompileTime, - MaxRowsAtCompileTime = ExpressionType::Traits::MaxRowsAtCompileTime, - MaxColsAtCompileTime = ExpressionType::Traits::MaxColsAtCompileTime - }; - typedef Matrix<typename ExpressionType::Scalar, + + /** The actual matrix type to evaluate to. This type can be used independently + * of the rest of this class to get the actual matrix type to evaluate and store + * the value of an expression. + * + * Here is an example illustrating this: + * \include Eval_MatrixType.cpp + * Output: \verbinclude Eval_MatrixType.out + */ + typedef Matrix<Scalar, ExpressionType::Traits::RowsAtCompileTime, ExpressionType::Traits::ColsAtCompileTime, EIGEN_DEFAULT_MATRIX_STORAGE_ORDER, ExpressionType::Traits::MaxRowsAtCompileTime, ExpressionType::Traits::MaxColsAtCompileTime> MatrixType; - int _rows() const { return m_matrix.rows(); } - int _cols() const { return m_matrix.cols(); } - Ref _ref() const { return Ref(*this); } - - const Scalar& _coeff(int row, int col) const - { - return m_matrix._coeff(row, col); - } - - Scalar& _coeffRef(int row, int col) - { - return m_matrix._coeffRef(row, col); - } - - public: - template<typename Derived> - Eval(const MatrixBase<Scalar, Derived>& other) : m_matrix(other) {} - ~Eval() {} - - EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Eval) - - protected: - MatrixType m_matrix; + explicit Eval(const ExpressionType& expr) : MatrixType(expr) {} }; /** Evaluates *this, which can be any expression, and returns the obtained matrix. @@ -110,7 +90,7 @@ template<typename ExpressionType> class Eval template<typename Scalar, typename Derived> const Eval<Derived> MatrixBase<Scalar, Derived>::eval() const { - return Eval<Derived>(ref()); + return Eval<Derived>(*static_cast<const Derived*>(this)); } #endif // EIGEN_EVAL_H diff --git a/Eigen/src/Core/FixedBlock.h b/Eigen/src/Core/FixedBlock.h index 95639fcfe..2f5d3fa84 100644 --- a/Eigen/src/Core/FixedBlock.h +++ b/Eigen/src/Core/FixedBlock.h @@ -55,8 +55,9 @@ template<typename MatrixType, int BlockRows, int BlockCols> class FixedBlock public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, FixedBlock<MatrixType, BlockRows, BlockCols> >; - + friend class MatrixBase<Scalar, FixedBlock>; + typedef MatrixBase<Scalar, FixedBlock> Base; + FixedBlock(const MatRef& matrix, int startRow, int startCol) : m_matrix(matrix), m_startRow(startRow), m_startCol(startCol) { diff --git a/Eigen/src/Core/ForwardDeclarations.h b/Eigen/src/Core/ForwardDeclarations.h index 834a99f55..123899702 100644 --- a/Eigen/src/Core/ForwardDeclarations.h +++ b/Eigen/src/Core/ForwardDeclarations.h @@ -47,8 +47,8 @@ template<typename MatrixType> class Ones; template<typename CoeffsVectorType> class DiagonalMatrix; template<typename MatrixType> class DiagonalCoeffs; template<typename MatrixType> class Identity; -template<typename ExpressionType> class Eval; template<typename MatrixType> class Map; +template<typename Derived> class Eval; template<typename T> struct Reference { @@ -61,10 +61,4 @@ struct Reference<Matrix<_Scalar, _Rows, _Cols, _StorageOrder, _MaxRows, _MaxCols typedef MatrixRef<Matrix<_Scalar, _Rows, _Cols, _StorageOrder, _MaxRows, _MaxCols> > Type; }; -template<typename ExpressionType> -struct Reference<Eval<ExpressionType> > -{ - typedef MatrixRef<Eval<ExpressionType> > Type; -}; - #endif // EIGEN_FORWARDDECLARATIONS_H diff --git a/Eigen/src/Core/Identity.h b/Eigen/src/Core/Identity.h index f5b4edcfc..a74ad0247 100644 --- a/Eigen/src/Core/Identity.h +++ b/Eigen/src/Core/Identity.h @@ -37,8 +37,9 @@ template<typename MatrixType> class Identity : NoOperatorEquals, { public: typedef typename MatrixType::Scalar Scalar; - friend class MatrixBase<Scalar, Identity<MatrixType> >; - + friend class MatrixBase<Scalar, Identity>; + typedef MatrixBase<Scalar, Identity> Base; + Identity(int rows, int cols) : m_rows(rows), m_cols(cols) { assert(rows > 0 diff --git a/Eigen/src/Core/Map.h b/Eigen/src/Core/Map.h index 6b342491d..aa22037fb 100644 --- a/Eigen/src/Core/Map.h +++ b/Eigen/src/Core/Map.h @@ -44,7 +44,8 @@ template<typename MatrixType> class Map { public: typedef typename MatrixType::Scalar Scalar; - friend class MatrixBase<Scalar, Map<MatrixType> >; + friend class MatrixBase<Scalar, Map>; + typedef MatrixBase<Scalar, Map> Base; private: enum { diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h index 3dba1f5da..6a1d22fda 100644 --- a/Eigen/src/Core/Matrix.h +++ b/Eigen/src/Core/Matrix.h @@ -111,13 +111,11 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, typedef _Scalar Scalar; typedef MatrixRef<Matrix> Ref; friend class MatrixRef<Matrix>; - template<typename ExpressionType> friend class Eval; private: enum { RowsAtCompileTime = _Rows, ColsAtCompileTime = _Cols, - SizeAtCompileTime = _Rows == Dynamic || _Cols == Dynamic ? Dynamic : _Rows * _Cols, StorageOrder = _StorageOrder, MaxRowsAtCompileTime = _MaxRows, MaxColsAtCompileTime = _MaxCols, @@ -167,14 +165,9 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols, && cols > 0 && (MaxColsAtCompileTime == Dynamic || MaxColsAtCompileTime >= cols) && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)); - if(SizeAtCompileTime == Dynamic) - { - const int size = rows * cols; - if(size > m_rows.value() * m_cols.value()) - m_array.resize(size); - m_rows.setValue(rows); - m_cols.setValue(cols); - } + m_rows.setValue(rows); + m_cols.setValue(cols); + m_array.resize(rows * cols); } /** Copies the value of the expression \a other into *this. diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h index 193a86263..fce3a441d 100644 --- a/Eigen/src/Core/MatrixBase.h +++ b/Eigen/src/Core/MatrixBase.h @@ -304,6 +304,34 @@ template<typename Scalar, typename Derived> class MatrixBase Scalar& w(); const Eval<Derived> eval() const EIGEN_ALWAYS_INLINE; + + /** puts in *row and *col the location of the coefficient of *this + * which has the biggest absolute value. + */ + void findBiggestCoeff(int *row, int *col) const + { + RealScalar biggest = 0; + for(int j = 0; j < cols(); j++) + for(int i = 0; i < rows(); i++) + { + RealScalar x = abs(coeff(i,j)); + if(x > biggest) + { + biggest = x; + *row = i; + *col = j; + } + } + } + + /** swaps *this with the expression \a other. + * + * \note \a other is only marked const because I couln't find another way + * to get g++ 4.2 to accept that template parameter resolution. It gets const_cast'd + * of course. TODO: get rid of const here. + */ + template<typename OtherDerived> + void swap(const MatrixBase<Scalar, OtherDerived>& other); }; #endif // EIGEN_MATRIXBASE_H diff --git a/Eigen/src/Core/MatrixRef.h b/Eigen/src/Core/MatrixRef.h index ae5c6d1a7..5606ad352 100644 --- a/Eigen/src/Core/MatrixRef.h +++ b/Eigen/src/Core/MatrixRef.h @@ -32,6 +32,7 @@ template<typename MatrixType> class MatrixRef public: typedef typename MatrixType::Scalar Scalar; friend class MatrixBase<Scalar, MatrixRef>; + typedef MatrixBase<Scalar, MatrixRef> Base; MatrixRef(const MatrixType& matrix) : m_matrix(matrix) {} ~MatrixRef() {} diff --git a/Eigen/src/Core/Minor.h b/Eigen/src/Core/Minor.h index 1e50f039e..8a8e9910a 100644 --- a/Eigen/src/Core/Minor.h +++ b/Eigen/src/Core/Minor.h @@ -44,7 +44,8 @@ template<typename MatrixType> class Minor public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Minor<MatrixType> >; + friend class MatrixBase<Scalar, Minor>; + typedef MatrixBase<Scalar, Minor> Base; Minor(const MatRef& matrix, int row, int col) diff --git a/Eigen/src/Core/Ones.h b/Eigen/src/Core/Ones.h index 02011ec48..4e5a2e7ca 100644 --- a/Eigen/src/Core/Ones.h +++ b/Eigen/src/Core/Ones.h @@ -38,8 +38,9 @@ template<typename MatrixType> class Ones : NoOperatorEquals, { public: typedef typename MatrixType::Scalar Scalar; - friend class MatrixBase<Scalar, Ones<MatrixType> >; - + friend class MatrixBase<Scalar, Ones>; + typedef MatrixBase<Scalar, Ones> Base; + private: enum { RowsAtCompileTime = MatrixType::Traits::RowsAtCompileTime, diff --git a/Eigen/src/Core/Opposite.h b/Eigen/src/Core/Opposite.h index 6e38b5f6c..7be19cd22 100644 --- a/Eigen/src/Core/Opposite.h +++ b/Eigen/src/Core/Opposite.h @@ -44,8 +44,9 @@ template<typename MatrixType> class Opposite : NoOperatorEquals, public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Opposite<MatrixType> >; - + friend class MatrixBase<Scalar, Opposite>; + typedef MatrixBase<Scalar, Opposite> Base; + Opposite(const MatRef& matrix) : m_matrix(matrix) {} private: diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h index 0e3bd9b0c..69b1415a8 100644 --- a/Eigen/src/Core/Product.h +++ b/Eigen/src/Core/Product.h @@ -1,4 +1,4 @@ -// This file is part of Eigen, a lightweight C++ template library +// // This file is part of Eigen, a lightweight C++ template library // for linear algebra. Eigen itself is part of the KDE project. // // Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.fr> @@ -81,7 +81,8 @@ template<typename Lhs, typename Rhs> class Product : NoOperatorEquals, typedef typename Lhs::Ref LhsRef; typedef typename Rhs::Ref RhsRef; friend class MatrixBase<Scalar, Product>; - + typedef MatrixBase<Scalar, Product> Base; + Product(const LhsRef& lhs, const RhsRef& rhs) : m_lhs(lhs), m_rhs(rhs) { diff --git a/Eigen/src/Core/Random.h b/Eigen/src/Core/Random.h index 0b6892d2e..89febe4f3 100644 --- a/Eigen/src/Core/Random.h +++ b/Eigen/src/Core/Random.h @@ -38,7 +38,8 @@ template<typename MatrixType> class Random : NoOperatorEquals, { public: typedef typename MatrixType::Scalar Scalar; - friend class MatrixBase<Scalar, Random<MatrixType> >; + friend class MatrixBase<Scalar, Random>; + typedef MatrixBase<Scalar, Random> Base; private: enum { @@ -86,7 +87,8 @@ template<typename MatrixType> class Random : NoOperatorEquals, * \sa random(), random(int) */ template<typename Scalar, typename Derived> -const Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random(int rows, int cols) +const Eval<Random<Derived> > +MatrixBase<Scalar, Derived>::random(int rows, int cols) { return Random<Derived>(rows, cols).eval(); } @@ -108,7 +110,8 @@ const Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random(int rows, int c * \sa random(), random(int,int) */ template<typename Scalar, typename Derived> -const Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random(int size) +const Eval<Random<Derived> > +MatrixBase<Scalar, Derived>::random(int size) { assert(Traits::IsVectorAtCompileTime); if(Traits::RowsAtCompileTime == 1) return Random<Derived>(1, size).eval(); @@ -127,7 +130,8 @@ const Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random(int size) * \sa random(int), random(int,int) */ template<typename Scalar, typename Derived> -const Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random() +const Eval<Random<Derived> > +MatrixBase<Scalar, Derived>::random() { return Random<Derived>(Traits::RowsAtCompileTime, Traits::ColsAtCompileTime).eval(); } diff --git a/Eigen/src/Core/Row.h b/Eigen/src/Core/Row.h index 55def78f3..379442dea 100644 --- a/Eigen/src/Core/Row.h +++ b/Eigen/src/Core/Row.h @@ -52,7 +52,8 @@ template<typename MatrixType> class Row public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Row<MatrixType> >; + friend class MatrixBase<Scalar, Row>; + typedef MatrixBase<Scalar, Row> Base; Row(const MatRef& matrix, int row) : m_matrix(matrix), m_row(row) diff --git a/Eigen/src/Core/ScalarMultiple.h b/Eigen/src/Core/ScalarMultiple.h index 1df09eee2..b2b2ddaab 100644 --- a/Eigen/src/Core/ScalarMultiple.h +++ b/Eigen/src/Core/ScalarMultiple.h @@ -43,7 +43,8 @@ template<typename FactorType, typename MatrixType> class ScalarMultiple : NoOper public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, ScalarMultiple<FactorType, MatrixType> >; + friend class MatrixBase<Scalar, ScalarMultiple>; + typedef MatrixBase<Scalar, ScalarMultiple> Base; ScalarMultiple(const MatRef& matrix, FactorType factor) : m_matrix(matrix), m_factor(factor) {} diff --git a/Eigen/src/Core/Sum.h b/Eigen/src/Core/Sum.h index 325125956..53c30d018 100644 --- a/Eigen/src/Core/Sum.h +++ b/Eigen/src/Core/Sum.h @@ -47,6 +47,7 @@ template<typename Lhs, typename Rhs> class Sum : NoOperatorEquals, typedef typename Lhs::Ref LhsRef; typedef typename Rhs::Ref RhsRef; friend class MatrixBase<Scalar, Sum>; + typedef MatrixBase<Scalar, Sum> Base; Sum(const LhsRef& lhs, const RhsRef& rhs) : m_lhs(lhs), m_rhs(rhs) diff --git a/Eigen/src/Core/Swap.h b/Eigen/src/Core/Swap.h new file mode 100644 index 000000000..cc1b2092b --- /dev/null +++ b/Eigen/src/Core/Swap.h @@ -0,0 +1,64 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. Eigen itself is part of the KDE project. +// +// Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.fr> +// +// Eigen is free software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the Free Software +// Foundation; either version 2 or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +// details. +// +// You should have received a copy of the GNU General Public License along +// with Eigen; if not, write to the Free Software Foundation, Inc., 51 +// Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. This exception does not invalidate any other reasons why a work +// based on this file might be covered by the GNU General Public License. + +#ifndef EIGEN_SWAP_H +#define EIGEN_SWAP_H + +template<typename Scalar, typename Derived> +template<typename OtherDerived> +void MatrixBase<Scalar, Derived>::swap(const MatrixBase<Scalar, OtherDerived>& other) +{ + MatrixBase<Scalar, OtherDerived> *_other = const_cast<MatrixBase<Scalar, OtherDerived>*>(&other); + if(Traits::SizeAtCompileTime == Dynamic) + { + Scalar tmp; + if(Traits::IsVectorAtCompileTime) + { + assert(OtherDerived::Traits::IsVectorAtCompileTime && size() == _other->size()); + for(int i = 0; i < size(); i++) + { + tmp = coeff(i); + coeffRef(i) = _other->coeff(i); + _other->coeffRef(i) = tmp; + } + } + else + for(int j = 0; j < cols(); j++) + for(int i = 0; i < rows(); i++) + { + tmp = coeff(i, j); + coeffRef(i, j) = _other->coeff(i, j); + _other->coeffRef(i, j) = tmp; + } + } + else // SizeAtCompileTime != Dynamic + { + typename Eval<Derived>::MatrixType buf(*this); + *this = other; + *_other = buf; + } +} + +#endif // EIGEN_SWAP_H diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h index 87da4e39d..8dc7763fc 100644 --- a/Eigen/src/Core/Transpose.h +++ b/Eigen/src/Core/Transpose.h @@ -44,7 +44,8 @@ template<typename MatrixType> class Transpose public: typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Ref MatRef; - friend class MatrixBase<Scalar, Transpose<MatrixType> >; + friend class MatrixBase<Scalar, Transpose>; + typedef MatrixBase<Scalar, Transpose> Base; Transpose(const MatRef& matrix) : m_matrix(matrix) {} @@ -54,8 +55,8 @@ template<typename MatrixType> class Transpose enum { RowsAtCompileTime = MatrixType::Traits::ColsAtCompileTime, ColsAtCompileTime = MatrixType::Traits::RowsAtCompileTime, - MaxRowsAtCompileTime = MatrixType::Traits::MaxRowsAtCompileTime, - MaxColsAtCompileTime = MatrixType::Traits::MaxColsAtCompileTime + MaxRowsAtCompileTime = MatrixType::Traits::MaxColsAtCompileTime, + MaxColsAtCompileTime = MatrixType::Traits::MaxRowsAtCompileTime }; const Transpose& _ref() const { return *this; } diff --git a/Eigen/src/Core/Util.h b/Eigen/src/Core/Util.h index 8104201e6..11b06c55a 100644 --- a/Eigen/src/Core/Util.h +++ b/Eigen/src/Core/Util.h @@ -67,18 +67,18 @@ using Eigen::MatrixBase; template<typename OtherScalar, typename OtherDerived> \ Derived& operator Op(const MatrixBase<OtherScalar, OtherDerived>& other) \ { \ - return MatrixBase<Scalar, Derived>::operator Op(other); \ + return Base::operator Op(other); \ } \ Derived& operator Op(const Derived& other) \ { \ - return MatrixBase<Scalar, Derived>::operator Op(other); \ + return Base::operator Op(other); \ } #define EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \ template<typename Other> \ Derived& operator Op(const Other& scalar) \ { \ - return MatrixBase<Scalar, Derived>::operator Op(scalar); \ + return Base::operator Op(scalar); \ } #define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived) \ diff --git a/Eigen/src/Core/Zero.h b/Eigen/src/Core/Zero.h index c0fdcffe3..625804059 100644 --- a/Eigen/src/Core/Zero.h +++ b/Eigen/src/Core/Zero.h @@ -38,7 +38,8 @@ template<typename MatrixType> class Zero : NoOperatorEquals, { public: typedef typename MatrixType::Scalar Scalar; - friend class MatrixBase<Scalar, Zero<MatrixType> >; + friend class MatrixBase<Scalar, Zero>; + typedef MatrixBase<Scalar, Zero> Base; private: enum { diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in index 6462239e0..aae3eb5d5 100644 --- a/doc/Doxyfile.in +++ b/doc/Doxyfile.in @@ -5,7 +5,7 @@ #--------------------------------------------------------------------------- DOXYFILE_ENCODING = UTF-8 PROJECT_NAME = Eigen -PROJECT_NUMBER = 2.0-alpha3 +PROJECT_NUMBER = 2.0-alpha3.1 OUTPUT_DIRECTORY = ${CMAKE_BINARY_DIR}/doc CREATE_SUBDIRS = NO OUTPUT_LANGUAGE = English diff --git a/doc/Mainpage.dox b/doc/Mainpage.dox index 0ca176854..7a9efb9bb 100644 --- a/doc/Mainpage.dox +++ b/doc/Mainpage.dox @@ -73,7 +73,7 @@ If you want to stay informed of Eigen news and releases, please subscribe to our <a name="download"></a> <h2>Download</h2> -The source code of the latest release is here: <a href="http://download.tuxfamily.org/eigen/eigen-2.0-alpha3.tar.gz">eigen-2.0-alpha3.tar.gz</a><br/> +The source code of the latest release is here: <a href="http://download.tuxfamily.org/eigen/eigen-2.0-alpha3.1.tar.gz">eigen-2.0-alpha3.1.tar.gz</a><br/> Alternatively, you can checkout the development tree by anonymous svn, by doing: <pre>svn co svn://anonsvn.kde.org/home/kde/branches/work/eigen2</pre> diff --git a/doc/echelon.cpp b/doc/echelon.cpp new file mode 100644 index 000000000..ca0934983 --- /dev/null +++ b/doc/echelon.cpp @@ -0,0 +1,71 @@ +#include <Eigen/Core> + +USING_PART_OF_NAMESPACE_EIGEN + +namespace Eigen { + +template<typename Scalar, typename Derived> +void echelon(MatrixBase<Scalar, Derived>& m) +{ + const int N = std::min(m.rows(), m.cols()); + + for(int k = 0; k < N; k++) + { + int rowOfBiggest, colOfBiggest; + int cornerRows = m.rows()-k; + int cornerCols = m.cols()-k; + m.corner(BottomRight, cornerRows, cornerCols) + .findBiggestCoeff(&rowOfBiggest, &colOfBiggest); + m.row(k).swap(m.row(k+rowOfBiggest)); + m.col(k).swap(m.col(k+colOfBiggest)); + for(int r = k+1; r < m.rows(); r++) + m.row(r).end(cornerCols) -= m.row(k).end(cornerCols) * m(r,k) / m(k,k); + } +} + +template<typename Scalar, typename Derived> +void doSomeRankPreservingOperations(MatrixBase<Scalar, Derived>& m) +{ + for(int a = 0; a < 3*(m.rows()+m.cols()); a++) + { + double d = Eigen::random<double>(-1,1); + int i = Eigen::random<int>(0,m.rows()-1); // i is a random row number + int j; + do { + j = Eigen::random<int>(0,m.rows()-1); + } while (i==j); // j is another one (must be different) + m.row(i) += d * m.row(j); + + i = Eigen::random<int>(0,m.cols()-1); // i is a random column number + do { + j = Eigen::random<int>(0,m.cols()-1); + } while (i==j); // j is another one (must be different) + m.col(i) += d * m.col(j); + } +} + +} // namespace Eigen + +using namespace std; + +int main(int, char **) +{ + srand((unsigned int)time(0)); + const int Rows = 6, Cols = 4; + typedef Matrix<double, Rows, Cols> Mat; + const int N = Rows < Cols ? Rows : Cols; + + // start with a matrix m that's obviously of rank N-1 + Mat m = Mat::identity(Rows, Cols); // args just in case of dyn. size + m.row(0) = m.row(1) = m.row(0) + m.row(1); + + doSomeRankPreservingOperations(m); + + // now m is still a matrix of rank N-1 + cout << "Here's the matrix m:" << endl << m << endl; + + cout << "Now let's echelon m:" << endl; + echelon(m); + + cout << "Now m is:" << endl << m << endl; +} diff --git a/doc/snippets/Eval_MatrixType.cpp b/doc/snippets/Eval_MatrixType.cpp new file mode 100644 index 000000000..0af4c64e4 --- /dev/null +++ b/doc/snippets/Eval_MatrixType.cpp @@ -0,0 +1,13 @@ +typedef Matrix3i MyMatrixType; +MyMatrixType m = MyMatrixType::random(3, 3); +cout << "Here's the matrix m:" << endl << m << endl; +typedef Eigen::Eval<Eigen::Row<MyMatrixType> >::MatrixType MyRowType; +// now MyRowType is just the same typedef as RowVector3i +MyRowType r = m.row(0); +cout << "Here's r:" << endl << r << endl; +typedef Eigen::Eval<Eigen::Block<MyMatrixType> >::MatrixType MyBlockType; +MyBlockType c = m.corner(Eigen::TopRight, 2, 2); +// now MyBlockType is a a matrix type where the number of rows and columns +// are dynamic, but know at compile-time to be <= 2. Therefore no dynamic memory +// allocation occurs. +cout << "Here's c:" << endl << c << endl; |