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

-add Ones, DiagonalMatrix, DiagonalCoeffs

Browse Source 
-expand and improve unit-tests
-various renaming and improvements
This commit is contained in:
Benoit Jacob 2007-12-15 18:16:30 +00:00
parent fc7b2b5c20
commit 7c38475291
18 changed files with 405 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/Core.h
View File

@ -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

73
src/Core/DiagonalCoeffs.h Normal file
View File

@ -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

73
src/Core/DiagonalMatrix.h Normal file
View File

@ -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

3
src/Core/Identity.h
View File

@ -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:

24
src/Core/FromArray.h → src/Core/Map.h
View File

@ -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

12
src/Core/Matrix.h
View File

@ -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:

26
src/Core/MatrixBase.h
View File

@ -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(

3
src/Core/MatrixRef.h
View File

@ -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() {}

36
src/Core/MatrixStorage.h
View File

@ -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();

78
src/Core/Ones.h Normal file
View File

@ -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

14
src/Core/Random.h
View File

@ -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

5
src/Core/Util.h
View File

@ -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
{

14
src/Core/Zero.h
View File

@ -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

1
test/CMakeLists.txt
View File

@ -9,6 +9,7 @@ SET(test_SRCS
basicstuff.cpp
adjoint.cpp
submatrices.cpp
miscmatrices.cpp
)
QT4_AUTOMOC(${test_SRCS})

18
test/basicstuff.cpp
View File

@ -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;

2
test/main.h
View File

@ -116,7 +116,7 @@ class EigenTest : public QObject
void testBasicStuff();
void testAdjoint();
void testSubmatrices();
void testMiscMatrices();
protected:
int m_repeat;
};

68
test/miscmatrices.cpp Normal file
View File

@ -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

14
test/submatrices.cpp
View File

@ -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()