diff options
author | Benoit Jacob <jacob.benoit.1@gmail.com> | 2007-12-15 18:16:30 +0000 |
---|---|---|
committer | Benoit Jacob <jacob.benoit.1@gmail.com> | 2007-12-15 18:16:30 +0000 |
commit | 7c384752918640c6073afe32dce9808fa6c4f3a6 (patch) | |
tree | 5413a5f5c6ea5169e49bfc7de563e535f969e1df | |
parent | fc7b2b5c2091c4a165587ceea4c8228b0feabab8 (diff) |
-add Ones, DiagonalMatrix, DiagonalCoeffs
-expand and improve unit-tests
-various renaming and improvements
-rw-r--r-- | src/Core.h | 5 | ||||
-rw-r--r-- | src/Core/DiagonalCoeffs.h | 73 | ||||
-rw-r--r-- | src/Core/DiagonalMatrix.h | 73 | ||||
-rw-r--r-- | src/Core/Identity.h | 3 | ||||
-rw-r--r-- | src/Core/Map.h (renamed from src/Core/FromArray.h) | 24 | ||||
-rw-r--r-- | src/Core/Matrix.h | 12 | ||||
-rw-r--r-- | src/Core/MatrixBase.h | 26 | ||||
-rw-r--r-- | src/Core/MatrixRef.h | 3 | ||||
-rw-r--r-- | src/Core/MatrixStorage.h | 36 | ||||
-rw-r--r-- | src/Core/Ones.h | 78 | ||||
-rw-r--r-- | src/Core/Random.h | 14 | ||||
-rw-r--r-- | src/Core/Util.h | 5 | ||||
-rw-r--r-- | src/Core/Zero.h | 14 | ||||
-rw-r--r-- | test/CMakeLists.txt | 1 | ||||
-rw-r--r-- | test/basicstuff.cpp | 18 | ||||
-rw-r--r-- | test/main.h | 2 | ||||
-rw-r--r-- | test/miscmatrices.cpp | 68 | ||||
-rw-r--r-- | test/submatrices.cpp | 14 |
18 files changed, 405 insertions, 64 deletions
diff --git a/src/Core.h b/src/Core.h index 068b46bce..5a14c5bdf 100644 --- a/src/Core.h +++ b/src/Core.h @@ -30,8 +30,11 @@ namespace Eigen { #include "Core/Dot.h" #include "Core/Random.h" #include "Core/Zero.h" +#include "Core/Ones.h" +#include "Core/DiagonalMatrix.h" +#include "Core/DiagonalCoeffs.h" #include "Core/Identity.h" #include "Core/Fuzzy.h" -#include "Core/FromArray.h" +#include "Core/Map.h" } // namespace Eigen diff --git a/src/Core/DiagonalCoeffs.h b/src/Core/DiagonalCoeffs.h new file mode 100644 index 000000000..a54db4938 --- /dev/null +++ b/src/Core/DiagonalCoeffs.h @@ -0,0 +1,73 @@ +// 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-2007 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_DIAGONALCOEFFS_H +#define EIGEN_DIAGONALCOEFFS_H + +template<typename MatrixType> class DiagonalCoeffs + : public MatrixBase<typename MatrixType::Scalar, DiagonalCoeffs<MatrixType> > +{ + public: + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::Ref MatRef; + friend class MatrixBase<Scalar, DiagonalCoeffs<MatrixType> >; + + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = 1; + + DiagonalCoeffs(const MatRef& matrix) : m_matrix(matrix) {} + + DiagonalCoeffs(const DiagonalCoeffs& other) : m_matrix(other.m_matrix) {} + + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(DiagonalCoeffs) + + private: + const DiagonalCoeffs& _ref() const { return *this; } + int _rows() const { return std::min(m_matrix.rows(), m_matrix.cols()); } + int _cols() const { return 1; } + + Scalar& _write(int row, int) + { + return m_matrix.write(row, row); + } + + Scalar _read(int row, int) const + { + return m_matrix.read(row, row); + } + + protected: + MatRef m_matrix; +}; + +template<typename Scalar, typename Derived> +DiagonalCoeffs<Derived> +MatrixBase<Scalar, Derived>::diagonal() const +{ + return DiagonalCoeffs<Derived> + (static_cast<Derived*>(const_cast<MatrixBase*>(this))->ref()); +} + +#endif // EIGEN_DIAGONALCOEFFS_H diff --git a/src/Core/DiagonalMatrix.h b/src/Core/DiagonalMatrix.h new file mode 100644 index 000000000..41152bd59 --- /dev/null +++ b/src/Core/DiagonalMatrix.h @@ -0,0 +1,73 @@ +// 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-2007 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_DIAGONALMATRIX_H +#define EIGEN_DIAGONALMATRIX_H + +template<typename MatrixType, typename CoeffsVectorType> +class DiagonalMatrix : NoDefaultOperatorEquals, + public MatrixBase<typename MatrixType::Scalar, + DiagonalMatrix<MatrixType, CoeffsVectorType> > +{ + public: + typedef typename MatrixType::Scalar Scalar; + typedef typename CoeffsVectorType::Ref CoeffsVecRef; + friend class MatrixBase<Scalar, DiagonalMatrix<MatrixType, CoeffsVectorType> >; + + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + + DiagonalMatrix(const CoeffsVecRef& coeffs) : m_coeffs(coeffs) + { + assert(CoeffsVectorType::IsVector + && RowsAtCompileTime == ColsAtCompileTime + && RowsAtCompileTime == CoeffsVectorType::SizeAtCompileTime + && coeffs.size() > 0); + } + + private: + DiagonalMatrix& _ref() { return *this; } + const DiagonalMatrix& _ref() const { return *this; } + int _rows() const { return m_coeffs.size(); } + int _cols() const { return m_coeffs.size(); } + + Scalar _read(int row, int col) const + { + return row == col ? m_coeffs.read(row) : static_cast<Scalar>(0); + } + + protected: + CoeffsVecRef m_coeffs; +}; + +template<typename Scalar, typename Derived> +template<typename OtherDerived> +const DiagonalMatrix<Derived, OtherDerived> +MatrixBase<Scalar, Derived>::diagonal(const OtherDerived& coeffs) +{ + return DiagonalMatrix<Derived, OtherDerived>(coeffs); +} + +#endif // EIGEN_DIAGONALMATRIX_H diff --git a/src/Core/Identity.h b/src/Core/Identity.h index 067626f22..37000a45a 100644 --- a/src/Core/Identity.h +++ b/src/Core/Identity.h @@ -38,8 +38,7 @@ template<typename MatrixType> class Identity : NoDefaultOperatorEquals, Identity(int rows) : m_rows(rows) { - assert(rows > 0); - assert(RowsAtCompileTime == ColsAtCompileTime); + assert(rows > 0 && RowsAtCompileTime == ColsAtCompileTime); } private: diff --git a/src/Core/FromArray.h b/src/Core/Map.h index 681d3e7ed..5b012aed9 100644 --- a/src/Core/FromArray.h +++ b/src/Core/Map.h @@ -26,48 +26,48 @@ #ifndef EIGEN_FROMARRAY_H #define EIGEN_FROMARRAY_H -template<typename MatrixType> class FromArray - : public MatrixBase<typename MatrixType::Scalar, FromArray<MatrixType> > +template<typename MatrixType> class Map + : public MatrixBase<typename MatrixType::Scalar, Map<MatrixType> > { public: typedef typename MatrixType::Scalar Scalar; - friend class MatrixBase<Scalar, FromArray<MatrixType> >; + friend class MatrixBase<Scalar, Map<MatrixType> >; static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime; - FromArray(int rows, int cols, Scalar* array) : m_rows(rows), m_cols(cols), m_array(array) + Map(int rows, int cols, Scalar* array) : m_rows(rows), m_cols(cols), m_data(array) { assert(rows > 0 && cols > 0); } - EIGEN_INHERIT_ASSIGNMENT_OPERATORS(FromArray) + EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Map) private: - FromArray& _ref() { return *this; } - const FromArray& _ref() const { return *this; } + Map& _ref() { return *this; } + const Map& _ref() const { return *this; } int _rows() const { return m_rows; } int _cols() const { return m_cols; } const Scalar& _read(int row, int col) const { - return m_array[row + col * m_rows]; + return m_data[row + col * m_rows]; } Scalar& _write(int row, int col) { - return m_array[row + col * m_rows]; + return m_data[row + col * m_rows]; } protected: int m_rows, m_cols; - Scalar* m_array; + Scalar* m_data; }; template<typename Scalar, typename Derived> -FromArray<Derived> MatrixBase<Scalar, Derived>::fromArray(const Scalar* array, int rows, int cols) +Map<Derived> MatrixBase<Scalar, Derived>::map(const Scalar* array, int rows, int cols) { - return FromArray<Derived>(rows, cols, const_cast<Scalar*>(array)); + return Map<Derived>(rows, cols, const_cast<Scalar*>(array)); } #endif // EIGEN_FROMARRAY_H diff --git a/src/Core/Matrix.h b/src/Core/Matrix.h index 566c6bbd7..a06cfe335 100644 --- a/src/Core/Matrix.h +++ b/src/Core/Matrix.h @@ -40,23 +40,23 @@ class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols> >, static const int RowsAtCompileTime = _Rows, ColsAtCompileTime = _Cols; - const Scalar* array() const - { return Storage::m_array; } + const Scalar* data() const + { return Storage::m_data; } - Scalar* array() - { return Storage::m_array; } + Scalar* data() + { return Storage::m_data; } private: Ref _ref() const { return Ref(*this); } const Scalar& _read(int row, int col) const { - return array()[row + col * Storage::_rows()]; + return data()[row + col * Storage::_rows()]; } Scalar& _write(int row, int col) { - return array()[row + col * Storage::_rows()]; + return data()[row + col * Storage::_rows()]; } public: diff --git a/src/Core/MatrixBase.h b/src/Core/MatrixBase.h index 12be45420..e53cbad45 100644 --- a/src/Core/MatrixBase.h +++ b/src/Core/MatrixBase.h @@ -80,14 +80,24 @@ template<typename Scalar, typename Derived> class MatrixBase RealScalar norm() const; ScalarMultiple<Derived> normalized() const; - static Eval<Random<Derived> > - random(int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); - static const Zero<Derived> - zero(int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); - static const Identity<Derived> - identity(int rows = RowsAtCompileTime); - static FromArray<Derived> - fromArray(const Scalar* array, int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); + static Eval<Random<Derived> > random(int rows, int cols); + static Eval<Random<Derived> > random(int size); + static Eval<Random<Derived> > random(); + static const Zero<Derived> zero(int rows, int cols); + static const Zero<Derived> zero(int size); + static const Zero<Derived> zero(); + static const Ones<Derived> ones(int rows, int cols); + static const Ones<Derived> ones(int size); + static const Ones<Derived> ones(); + static const Identity<Derived> identity(int rows = RowsAtCompileTime); + + template<typename OtherDerived> + static const DiagonalMatrix<Derived, OtherDerived> + diagonal(const OtherDerived& coeffs); + DiagonalCoeffs<Derived> diagonal() const; + + static Map<Derived> + map(const Scalar* array, int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); template<typename OtherDerived> bool isApprox( diff --git a/src/Core/MatrixRef.h b/src/Core/MatrixRef.h index 1298162a7..e79c32a08 100644 --- a/src/Core/MatrixRef.h +++ b/src/Core/MatrixRef.h @@ -33,6 +33,9 @@ template<typename MatrixType> class MatrixRef typedef typename MatrixType::Scalar Scalar; friend class MatrixBase<Scalar, MatrixRef>; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + MatrixRef(const MatrixType& matrix) : m_matrix(*const_cast<MatrixType*>(&matrix)) {} MatrixRef(const MatrixRef& other) : m_matrix(other.m_matrix) {} ~MatrixRef() {} diff --git a/src/Core/MatrixStorage.h b/src/Core/MatrixStorage.h index 314183a2a..1e4b0a21f 100644 --- a/src/Core/MatrixStorage.h +++ b/src/Core/MatrixStorage.h @@ -32,7 +32,7 @@ template<typename Scalar, class MatrixStorage { protected: - Scalar m_array[RowsAtCompileTime * ColsAtCompileTime]; + Scalar m_data[RowsAtCompileTime * ColsAtCompileTime]; void resize(int rows, int cols) { @@ -62,7 +62,7 @@ class MatrixStorage<Scalar, Dynamic, ColsAtCompileTime> { protected: int m_rows; - Scalar* m_array; + Scalar* m_data; void resize(int rows, int cols) { @@ -70,8 +70,8 @@ class MatrixStorage<Scalar, Dynamic, ColsAtCompileTime> assert(rows > 0 && cols == ColsAtCompileTime); if(rows > m_rows) { - delete[] m_array; - m_array = new Scalar[rows * ColsAtCompileTime]; + delete[] m_data; + m_data = new Scalar[rows * ColsAtCompileTime]; } m_rows = rows; } @@ -85,16 +85,16 @@ class MatrixStorage<Scalar, Dynamic, ColsAtCompileTime> public: MatrixStorage(int dim) : m_rows(dim) { - m_array = new Scalar[m_rows * ColsAtCompileTime]; + m_data = new Scalar[m_rows * ColsAtCompileTime]; } MatrixStorage(int rows, int) : m_rows(rows) { - m_array = new Scalar[m_rows * ColsAtCompileTime]; + m_data = new Scalar[m_rows * ColsAtCompileTime]; } ~MatrixStorage() - { delete[] m_array; } + { delete[] m_data; } private: MatrixStorage(); @@ -105,7 +105,7 @@ class MatrixStorage<Scalar, RowsAtCompileTime, Dynamic> { protected: int m_cols; - Scalar* m_array; + Scalar* m_data; void resize(int rows, int cols) { @@ -113,8 +113,8 @@ class MatrixStorage<Scalar, RowsAtCompileTime, Dynamic> assert(rows == RowsAtCompileTime && cols > 0); if(cols > m_cols) { - delete[] m_array; - m_array = new Scalar[cols * RowsAtCompileTime]; + delete[] m_data; + m_data = new Scalar[cols * RowsAtCompileTime]; } m_cols = cols; } @@ -128,16 +128,16 @@ class MatrixStorage<Scalar, RowsAtCompileTime, Dynamic> public: MatrixStorage(int dim) : m_cols(dim) { - m_array = new Scalar[m_cols * RowsAtCompileTime]; + m_data = new Scalar[m_cols * RowsAtCompileTime]; } MatrixStorage(int, int cols) : m_cols(cols) { - m_array = new Scalar[m_cols * RowsAtCompileTime]; + m_data = new Scalar[m_cols * RowsAtCompileTime]; } ~MatrixStorage() - { delete[] m_array; } + { delete[] m_data; } private: MatrixStorage(); @@ -148,15 +148,15 @@ class MatrixStorage<Scalar, Dynamic, Dynamic> { protected: int m_rows, m_cols; - Scalar* m_array; + Scalar* m_data; void resize(int rows, int cols) { assert(rows > 0 && cols > 0); if(rows * cols > m_rows * m_cols) { - delete[] m_array; - m_array = new Scalar[rows * cols]; + delete[] m_data; + m_data = new Scalar[rows * cols]; } m_rows = rows; m_cols = cols; @@ -172,11 +172,11 @@ class MatrixStorage<Scalar, Dynamic, Dynamic> MatrixStorage(int rows, int cols) : m_rows(rows), m_cols(cols) { - m_array = new Scalar[m_rows * m_cols]; + m_data = new Scalar[m_rows * m_cols]; } ~MatrixStorage() - { delete[] m_array; } + { delete[] m_data; } private: MatrixStorage(); diff --git a/src/Core/Ones.h b/src/Core/Ones.h new file mode 100644 index 000000000..de6a1d6b0 --- /dev/null +++ b/src/Core/Ones.h @@ -0,0 +1,78 @@ +// 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-2007 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_ONES_H +#define EIGEN_ONES_H + +template<typename MatrixType> class Ones : NoDefaultOperatorEquals, + public MatrixBase<typename MatrixType::Scalar, Ones<MatrixType> > +{ + public: + typedef typename MatrixType::Scalar Scalar; + friend class MatrixBase<Scalar, Ones<MatrixType> >; + + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + + Ones(int rows, int cols) : m_rows(rows), m_cols(cols) + { + assert(rows > 0 && cols > 0); + } + + private: + const Ones& _ref() const { return *this; } + int _rows() const { return m_rows; } + int _cols() const { return m_cols; } + + Scalar _read(int, int) const + { + return static_cast<Scalar>(1); + } + + protected: + int m_rows, m_cols; +}; + +template<typename Scalar, typename Derived> +const Ones<Derived> MatrixBase<Scalar, Derived>::ones(int rows, int cols) +{ + return Ones<Derived>(rows, cols); +} + +template<typename Scalar, typename Derived> +const Ones<Derived> MatrixBase<Scalar, Derived>::ones(int size) +{ + assert(IsVector); + if(RowsAtCompileTime == 1) return Ones<Derived>(1, size); + else return Ones<Derived>(size, 1); +} + +template<typename Scalar, typename Derived> +const Ones<Derived> MatrixBase<Scalar, Derived>::ones() +{ + return Ones<Derived>(RowsAtCompileTime, ColsAtCompileTime); +} + +#endif // EIGEN_ONES_H diff --git a/src/Core/Random.h b/src/Core/Random.h index 02b6ff9cc..c51ba08a8 100644 --- a/src/Core/Random.h +++ b/src/Core/Random.h @@ -61,4 +61,18 @@ Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random(int rows, int cols) return Random<Derived>(rows, cols).eval(); } +template<typename Scalar, typename Derived> +Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random(int size) +{ + assert(IsVector); + if(RowsAtCompileTime == 1) return Random<Derived>(1, size).eval(); + else return Random<Derived>(size, 1).eval(); +} + +template<typename Scalar, typename Derived> +Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random() +{ + return Random<Derived>(RowsAtCompileTime, ColsAtCompileTime).eval(); +} + #endif // EIGEN_RANDOM_H diff --git a/src/Core/Util.h b/src/Core/Util.h index a9c08d833..c4729ab07 100644 --- a/src/Core/Util.h +++ b/src/Core/Util.h @@ -101,9 +101,12 @@ template<typename Lhs, typename Rhs> class Product; template<typename MatrixType> class ScalarMultiple; template<typename MatrixType> class Random; template<typename MatrixType> class Zero; +template<typename MatrixType> class Ones; +template<typename MatrixType, typename CoeffsVectorType> class DiagonalMatrix; +template<typename MatrixType> class DiagonalCoeffs; template<typename MatrixType> class Identity; template<typename ExpressionType> class Eval; -template<typename MatrixType> class FromArray; +template<typename MatrixType> class Map; template<typename T> struct ForwardDecl { diff --git a/src/Core/Zero.h b/src/Core/Zero.h index 9342a66c8..53703c4f5 100644 --- a/src/Core/Zero.h +++ b/src/Core/Zero.h @@ -61,4 +61,18 @@ const Zero<Derived> MatrixBase<Scalar, Derived>::zero(int rows, int cols) return Zero<Derived>(rows, cols); } +template<typename Scalar, typename Derived> +const Zero<Derived> MatrixBase<Scalar, Derived>::zero(int size) +{ + assert(IsVector); + if(RowsAtCompileTime == 1) return Zero<Derived>(1, size); + else return Zero<Derived>(size, 1); +} + +template<typename Scalar, typename Derived> +const Zero<Derived> MatrixBase<Scalar, Derived>::zero() +{ + return Zero<Derived>(RowsAtCompileTime, ColsAtCompileTime); +} + #endif // EIGEN_ZERO_H diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 42aae4012..c58b085c7 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -9,6 +9,7 @@ SET(test_SRCS basicstuff.cpp adjoint.cpp submatrices.cpp + miscmatrices.cpp ) QT4_AUTOMOC(${test_SRCS}) diff --git a/test/basicstuff.cpp b/test/basicstuff.cpp index dceeee564..85793e254 100644 --- a/test/basicstuff.cpp +++ b/test/basicstuff.cpp @@ -32,7 +32,7 @@ template<typename MatrixType> void basicStuff(const MatrixType& m) /* this test covers the following files: 1) Explicitly (see comments below): Random.h Zero.h Identity.h Fuzzy.h Sum.h Difference.h - Opposite.h Product.h ScalarMultiple.h FromArray.h + Opposite.h Product.h ScalarMultiple.h Map.h 2) Implicitly (the core stuff): MatrixBase.h Matrix.h MatrixStorage.h CopyHelper.h MatrixRef.h @@ -84,7 +84,7 @@ template<typename MatrixType> void basicStuff(const MatrixType& m) // hence has no _write() method, the corresponding MatrixBase method (here zero()) // should return a const-qualified object so that it is the const-qualified // operator() that gets called, which in turn calls _read(). - VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::zero()(r,c), static_cast<Scalar>(1)); + VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::zero(rows,cols)(r,c), static_cast<Scalar>(1)); // test the linear structure, i.e. the following files: // Sum.h Difference.h Opposite.h ScalarMultiple.h @@ -145,16 +145,16 @@ template<typename MatrixType> void basicStuff(const MatrixType& m) VERIFY_IS_APPROX(m1, identity*m1); VERIFY_IS_APPROX(v1, identity*v1); // again, test operator() to check const-qualification - VERIFY_IS_APPROX(MatrixType::identity()(r,c), static_cast<Scalar>(r==c)); + VERIFY_IS_APPROX(MatrixType::identity(std::max(rows,cols))(r,c), static_cast<Scalar>(r==c)); - // test FromArray.h + // test Map.h Scalar* array1 = new Scalar[rows]; Scalar* array2 = new Scalar[rows]; - Matrix<Scalar, Dynamic, 1>::fromArray(array1, rows) = Matrix<Scalar, Dynamic, 1>::random(rows); - Matrix<Scalar, Dynamic, 1>::fromArray(array2, rows) - = Matrix<Scalar, Dynamic, 1>::fromArray(array1, rows); - Matrix<Scalar, Dynamic, 1> ma1 = Matrix<Scalar, Dynamic, 1>::fromArray(array1, rows); - Matrix<Scalar, Dynamic, 1> ma2 = Matrix<Scalar, Dynamic, 1>::fromArray(array2, rows); + Matrix<Scalar, Dynamic, 1>::map(array1, rows) = Matrix<Scalar, Dynamic, 1>::random(rows); + Matrix<Scalar, Dynamic, 1>::map(array2, rows) + = Matrix<Scalar, Dynamic, 1>::map(array1, rows); + Matrix<Scalar, Dynamic, 1> ma1 = Matrix<Scalar, Dynamic, 1>::map(array1, rows); + Matrix<Scalar, Dynamic, 1> ma2 = Matrix<Scalar, Dynamic, 1>::map(array2, rows); VERIFY_IS_APPROX(ma1, ma2); delete[] array1; delete[] array2; diff --git a/test/main.h b/test/main.h index 837074f0a..cb387e08e 100644 --- a/test/main.h +++ b/test/main.h @@ -116,7 +116,7 @@ class EigenTest : public QObject void testBasicStuff(); void testAdjoint(); void testSubmatrices(); - + void testMiscMatrices(); protected: int m_repeat; }; diff --git a/test/miscmatrices.cpp b/test/miscmatrices.cpp new file mode 100644 index 000000000..052d5ec91 --- /dev/null +++ b/test/miscmatrices.cpp @@ -0,0 +1,68 @@ +// 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-2007 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. + +#include "main.h" + +namespace Eigen { + +template<typename MatrixType> void miscMatrices(const MatrixType& m) +{ + /* this test covers the following files: + DiagonalMatrix.h Ones.h + */ + + typedef typename MatrixType::Scalar Scalar; + typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType; + typedef Matrix<Scalar, 1, MatrixType::ColsAtCompileTime> RowVectorType; + int rows = m.rows(); + int cols = m.cols(); + + int r = random<int>(0, rows-1), r2 = random<int>(0, rows-1), c = random<int>(0, cols-1); + VERIFY_IS_APPROX(MatrixType::ones(rows,cols)(r,c), static_cast<Scalar>(1)); + MatrixType m1 = MatrixType::ones(rows,cols); + VERIFY_IS_APPROX(m1(r,c), static_cast<Scalar>(1)); + VectorType v1 = VectorType::random(rows); + v1[0]; + Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> + square = MatrixType::diagonal(v1); + if(r==r2) VERIFY_IS_APPROX(square(r,r2), v1[r]); + else VERIFY_IS_MUCH_SMALLER_THAN(square(r,r2), static_cast<Scalar>(1)); + square = MatrixType::zero(rows, rows); + square.diagonal() = VectorType::ones(rows); + VERIFY_IS_APPROX(square, MatrixType::identity(rows)); +} + +void EigenTest::testMiscMatrices() +{ + for(int i = 0; i < m_repeat; i++) { + miscMatrices(Matrix<float, 1, 1>()); + miscMatrices(Matrix4d()); + miscMatrices(MatrixXcf(3, 3)); + miscMatrices(MatrixXi(8, 12)); + miscMatrices(MatrixXcd(20, 20)); + } +} + +} // namespace Eigen diff --git a/test/submatrices.cpp b/test/submatrices.cpp index 33d135646..29c83f742 100644 --- a/test/submatrices.cpp +++ b/test/submatrices.cpp @@ -30,9 +30,9 @@ namespace Eigen { template<typename MatrixType> void submatrices(const MatrixType& m) { /* this test covers the following files: - Transpose.h Conjugate.h Dot.h + Row.h Column.h Block.h DynBlock.h Minor.h DiagonalCoeffs.h */ - + typedef typename MatrixType::Scalar Scalar; typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType; typedef Matrix<Scalar, 1, MatrixType::ColsAtCompileTime> RowVectorType; @@ -54,10 +54,6 @@ template<typename MatrixType> void submatrices(const MatrixType& m) Scalar s1 = random<Scalar>(); - /* this test covers the following files: - Row.h Column.h Block.h DynBlock.h Minor.h - */ - int r1 = random<int>(0,rows-1); int r2 = random<int>(r1,rows-1); int c1 = random<int>(0,cols-1); @@ -91,6 +87,12 @@ template<typename MatrixType> void submatrices(const MatrixType& m) //check operator(), both constant and non-constant, on minor() m1.minor(r1,c1)(0,0) = m1.minor(0,0)(0,0); } + + //check diagonal() + VERIFY_IS_APPROX(m1.diagonal(), m1.transpose().diagonal()); + m2.diagonal() = 2 * m1.diagonal(); + m2.diagonal()[0] *= 3; + VERIFY_IS_APPROX(m2.diagonal()[0], static_cast<Scalar>(6) * m1.diagonal()[0]); } void EigenTest::testSubmatrices() |