From 7c384752918640c6073afe32dce9808fa6c4f3a6 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Sat, 15 Dec 2007 18:16:30 +0000 Subject: [PATCH] -add Ones, DiagonalMatrix, DiagonalCoeffs -expand and improve unit-tests -various renaming and improvements --- src/Core.h | 5 ++- src/Core/DiagonalCoeffs.h | 73 ++++++++++++++++++++++++++++++ src/Core/DiagonalMatrix.h | 73 ++++++++++++++++++++++++++++++ src/Core/Identity.h | 3 +- src/Core/{FromArray.h => Map.h} | 24 +++++----- src/Core/Matrix.h | 12 ++--- src/Core/MatrixBase.h | 26 +++++++---- src/Core/MatrixRef.h | 3 ++ src/Core/MatrixStorage.h | 36 +++++++-------- src/Core/Ones.h | 78 +++++++++++++++++++++++++++++++++ src/Core/Random.h | 14 ++++++ src/Core/Util.h | 5 ++- src/Core/Zero.h | 14 ++++++ test/CMakeLists.txt | 1 + test/basicstuff.cpp | 18 ++++---- test/main.h | 2 +- test/miscmatrices.cpp | 68 ++++++++++++++++++++++++++++ test/submatrices.cpp | 14 +++--- 18 files changed, 405 insertions(+), 64 deletions(-) create mode 100644 src/Core/DiagonalCoeffs.h create mode 100644 src/Core/DiagonalMatrix.h rename src/Core/{FromArray.h => Map.h} (74%) create mode 100644 src/Core/Ones.h create mode 100644 test/miscmatrices.cpp 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 +// +// 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 class DiagonalCoeffs + : public MatrixBase > +{ + public: + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::Ref MatRef; + friend class MatrixBase >; + + 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 +DiagonalCoeffs +MatrixBase::diagonal() const +{ + return DiagonalCoeffs + (static_cast(const_cast(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 +// +// 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 +class DiagonalMatrix : NoDefaultOperatorEquals, + public MatrixBase > +{ + public: + typedef typename MatrixType::Scalar Scalar; + typedef typename CoeffsVectorType::Ref CoeffsVecRef; + friend class MatrixBase >; + + 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(0); + } + + protected: + CoeffsVecRef m_coeffs; +}; + +template +template +const DiagonalMatrix +MatrixBase::diagonal(const OtherDerived& coeffs) +{ + return DiagonalMatrix(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 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 similarity index 74% rename from src/Core/FromArray.h rename to 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 class FromArray - : public MatrixBase > +template class Map + : public MatrixBase > { public: typedef typename MatrixType::Scalar Scalar; - friend class MatrixBase >; + friend class MatrixBase >; 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 -FromArray MatrixBase::fromArray(const Scalar* array, int rows, int cols) +Map MatrixBase::map(const Scalar* array, int rows, int cols) { - return FromArray(rows, cols, const_cast(array)); + return Map(rows, cols, const_cast(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 class MatrixBase RealScalar norm() const; ScalarMultiple normalized() const; - static Eval > - random(int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); - static const Zero - zero(int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); - static const Identity - identity(int rows = RowsAtCompileTime); - static FromArray - fromArray(const Scalar* array, int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); + static Eval > random(int rows, int cols); + static Eval > random(int size); + static Eval > random(); + static const Zero zero(int rows, int cols); + static const Zero zero(int size); + static const Zero zero(); + 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); + + template + static const DiagonalMatrix + diagonal(const OtherDerived& coeffs); + DiagonalCoeffs diagonal() const; + + static Map + map(const Scalar* array, int rows = RowsAtCompileTime, int cols = ColsAtCompileTime); template 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 class MatrixRef typedef typename MatrixType::Scalar Scalar; friend class MatrixBase; + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + MatrixRef(const MatrixType& matrix) : m_matrix(*const_cast(&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 { protected: int m_rows; - Scalar* m_array; + Scalar* m_data; void resize(int rows, int cols) { @@ -70,8 +70,8 @@ class MatrixStorage 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 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 { protected: int m_cols; - Scalar* m_array; + Scalar* m_data; void resize(int rows, int cols) { @@ -113,8 +113,8 @@ class MatrixStorage 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 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 { 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 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 +// +// 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 class Ones : NoDefaultOperatorEquals, + public MatrixBase > +{ + public: + typedef typename MatrixType::Scalar Scalar; + friend class MatrixBase >; + + 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(1); + } + + protected: + int m_rows, m_cols; +}; + +template +const Ones MatrixBase::ones(int rows, int cols) +{ + return Ones(rows, cols); +} + +template +const Ones MatrixBase::ones(int size) +{ + assert(IsVector); + if(RowsAtCompileTime == 1) return Ones(1, size); + else return Ones(size, 1); +} + +template +const Ones MatrixBase::ones() +{ + return Ones(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 > MatrixBase::random(int rows, int cols) return Random(rows, cols).eval(); } +template +Eval > MatrixBase::random(int size) +{ + assert(IsVector); + if(RowsAtCompileTime == 1) return Random(1, size).eval(); + else return Random(size, 1).eval(); +} + +template +Eval > MatrixBase::random() +{ + return Random(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 class Product; template class ScalarMultiple; template class Random; template class Zero; +template class Ones; +template class DiagonalMatrix; +template class DiagonalCoeffs; template class Identity; template class Eval; -template class FromArray; +template class Map; template 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 MatrixBase::zero(int rows, int cols) return Zero(rows, cols); } +template +const Zero MatrixBase::zero(int size) +{ + assert(IsVector); + if(RowsAtCompileTime == 1) return Zero(1, size); + else return Zero(size, 1); +} + +template +const Zero MatrixBase::zero() +{ + return Zero(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 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 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(1)); + VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::zero(rows,cols)(r,c), static_cast(1)); // test the linear structure, i.e. the following files: // Sum.h Difference.h Opposite.h ScalarMultiple.h @@ -145,16 +145,16 @@ template 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(r==c)); + VERIFY_IS_APPROX(MatrixType::identity(std::max(rows,cols))(r,c), static_cast(r==c)); - // test FromArray.h + // test Map.h Scalar* array1 = new Scalar[rows]; Scalar* array2 = new Scalar[rows]; - Matrix::fromArray(array1, rows) = Matrix::random(rows); - Matrix::fromArray(array2, rows) - = Matrix::fromArray(array1, rows); - Matrix ma1 = Matrix::fromArray(array1, rows); - Matrix ma2 = Matrix::fromArray(array2, rows); + Matrix::map(array1, rows) = Matrix::random(rows); + Matrix::map(array2, rows) + = Matrix::map(array1, rows); + Matrix ma1 = Matrix::map(array1, rows); + Matrix ma2 = Matrix::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 +// +// 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 void miscMatrices(const MatrixType& m) +{ + /* this test covers the following files: + DiagonalMatrix.h Ones.h + */ + + typedef typename MatrixType::Scalar Scalar; + typedef Matrix VectorType; + typedef Matrix RowVectorType; + int rows = m.rows(); + int cols = m.cols(); + + int r = random(0, rows-1), r2 = random(0, rows-1), c = random(0, cols-1); + VERIFY_IS_APPROX(MatrixType::ones(rows,cols)(r,c), static_cast(1)); + MatrixType m1 = MatrixType::ones(rows,cols); + VERIFY_IS_APPROX(m1(r,c), static_cast(1)); + VectorType v1 = VectorType::random(rows); + v1[0]; + Matrix + 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(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()); + 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 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 VectorType; typedef Matrix RowVectorType; @@ -54,10 +54,6 @@ template void submatrices(const MatrixType& m) Scalar s1 = random(); - /* this test covers the following files: - Row.h Column.h Block.h DynBlock.h Minor.h - */ - int r1 = random(0,rows-1); int r2 = random(r1,rows-1); int c1 = random(0,cols-1); @@ -91,6 +87,12 @@ template 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(6) * m1.diagonal()[0]); } void EigenTest::testSubmatrices()