mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-01-18 14:34:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

rename Object -> MatrixBase

Browse Source
This commit is contained in:
Benoit Jacob 2007-11-27 13:57:51 +00:00
parent 344623e872
commit 39f1776bde
28 changed files with 102 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/example.cpp
View File

@ -5,14 +5,14 @@ USING_EIGEN_DATA_TYPES
using namespace std;
template<typename Scalar, typename Derived>
void foo(const Eigen::Object<Scalar, Derived>& m)
void foo(const Eigen::MatrixBase<Scalar, Derived>& m)
{
cout << "Here's m:" << endl << m << endl;
}
template<typename Scalar, typename Derived>
Eigen::ScalarMultiple<Derived>
twice(const Eigen::Object<Scalar, Derived>& m)
twice(const Eigen::MatrixBase<Scalar, Derived>& m)
{
return 2 * m;
}

2
src/Core.h
View File

@ -6,7 +6,7 @@ namespace Eigen {
#include "Core/Util.h"
#include "Core/NumTraits.h"
#include "Core/Object.h"
#include "Core/MatrixBase.h"
#include "Core/CopyHelper.h"
#include "Core/MatrixRef.h"
#include "Core/MatrixStorage.h"

8
src/Core/Block.h
View File

@ -27,12 +27,12 @@
#define EIGEN_BLOCK_H
template<typename MatrixType> class Block
: public Object<typename MatrixType::Scalar, Block<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Block<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Block<MatrixType> >;
friend class MatrixBase<Scalar, Block<MatrixType> >;
static const int RowsAtCompileTime = Dynamic,
ColsAtCompileTime = Dynamic;
@ -75,9 +75,9 @@ template<typename MatrixType> class Block
template<typename Scalar, typename Derived>
Block<Derived>
Object<Scalar, Derived>::block(int startRow, int endRow, int startCol, int endCol) const
MatrixBase<Scalar, Derived>::block(int startRow, int endRow, int startCol, int endCol) const
{
return Block<Derived>(static_cast<Derived*>(const_cast<Object*>(this))->ref(),
return Block<Derived>(static_cast<Derived*>(const_cast<MatrixBase*>(this))->ref(),
startRow, endRow, startCol, endCol);
}

6
src/Core/Cast.h
View File

@ -27,12 +27,12 @@
#define EIGEN_CAST_H
template<typename NewScalar, typename MatrixType> class Cast
: public Object<NewScalar, Cast<NewScalar, MatrixType> >
: public MatrixBase<NewScalar, Cast<NewScalar, MatrixType> >
{
public:
typedef NewScalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Cast<Scalar, MatrixType> >;
friend class MatrixBase<Scalar, Cast<Scalar, MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -62,7 +62,7 @@ template<typename NewScalar, typename MatrixType> class Cast
template<typename Scalar, typename Derived>
template<typename NewScalar>
Cast<NewScalar, Derived>
Object<Scalar, Derived>::cast() const
MatrixBase<Scalar, Derived>::cast() const
{
return Cast<NewScalar, Derived>(static_cast<const Derived*>(this)->ref());
}

8
src/Core/Column.h
View File

@ -27,12 +27,12 @@
#define EIGEN_COLUMN_H
template<typename MatrixType> class Column
: public Object<typename MatrixType::Scalar, Column<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Column<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Column<MatrixType> >;
friend class MatrixBase<Scalar, Column<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = 1;
@ -74,9 +74,9 @@ template<typename MatrixType> class Column
template<typename Scalar, typename Derived>
Column<Derived>
Object<Scalar, Derived>::col(int i) const
MatrixBase<Scalar, Derived>::col(int i) const
{
return Column<Derived>(static_cast<Derived*>(const_cast<Object*>(this))->ref(), i);
return Column<Derived>(static_cast<Derived*>(const_cast<MatrixBase*>(this))->ref(), i);
}
#endif // EIGEN_COLUMN_H

6
src/Core/Conjugate.h
View File

@ -27,12 +27,12 @@
#define EIGEN_CONJUGATE_H
template<typename MatrixType> class Conjugate
: public Object<typename MatrixType::Scalar, Conjugate<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Conjugate<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Conjugate<MatrixType> >;
friend class MatrixBase<Scalar, Conjugate<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -61,7 +61,7 @@ template<typename MatrixType> class Conjugate
template<typename Scalar, typename Derived>
Conjugate<Derived>
Object<Scalar, Derived>::conjugate() const
MatrixBase<Scalar, Derived>::conjugate() const
{
return Conjugate<Derived>(static_cast<const Derived*>(this)->ref());
}

2
src/Core/CopyHelper.h
View File

@ -61,7 +61,7 @@ template<int Rows> struct CopyHelperUnroller<Dynamic, Rows>
template<typename Scalar, typename Derived>
template<typename OtherDerived>
void Object<Scalar, Derived>::_copy_helper(const Object<Scalar, OtherDerived>& other)
void MatrixBase<Scalar, Derived>::_copy_helper(const MatrixBase<Scalar, OtherDerived>& other)
{
if(SizeAtCompileTime != Dynamic && SizeAtCompileTime <= EIGEN_LOOP_UNROLLING_LIMIT)
CopyHelperUnroller<SizeAtCompileTime, RowsAtCompileTime>::run(*this, other);

8
src/Core/Difference.h
View File

@ -27,13 +27,13 @@
#define EIGEN_DIFFERENCE_H
template<typename Lhs, typename Rhs> class Difference
: public Object<typename Lhs::Scalar, Difference<Lhs, Rhs> >
: public MatrixBase<typename Lhs::Scalar, Difference<Lhs, Rhs> >
{
public:
typedef typename Lhs::Scalar Scalar;
typedef typename Lhs::Ref LhsRef;
typedef typename Rhs::Ref RhsRef;
friend class Object<Scalar, Difference>;
friend class MatrixBase<Scalar, Difference>;
static const int RowsAtCompileTime = Lhs::RowsAtCompileTime,
ColsAtCompileTime = Rhs::ColsAtCompileTime;
@ -67,7 +67,7 @@ template<typename Lhs, typename Rhs> class Difference
template<typename Scalar, typename Derived1, typename Derived2>
Difference<Derived1, Derived2>
operator-(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &mat2)
operator-(const MatrixBase<Scalar, Derived1> &mat1, const MatrixBase<Scalar, Derived2> &mat2)
{
return Difference<Derived1, Derived2>(mat1.ref(), mat2.ref());
}
@ -75,7 +75,7 @@ operator-(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &
template<typename Scalar, typename Derived>
template<typename OtherDerived>
Derived &
Object<Scalar, Derived>::operator-=(const Object<Scalar, OtherDerived> &other)
MatrixBase<Scalar, Derived>::operator-=(const MatrixBase<Scalar, OtherDerived> &other)
{
return *this = *this - other;
}

8
src/Core/Dot.h
View File

@ -58,7 +58,7 @@ struct DotUnroller<Index, Dynamic, Derived1, Derived2>
template<typename Scalar, typename Derived>
template<typename OtherDerived>
Scalar Object<Scalar, Derived>::dot(const OtherDerived& other) const
Scalar MatrixBase<Scalar, Derived>::dot(const OtherDerived& other) const
{
assert(IsVector && OtherDerived::IsVector && size() == other.size());
Scalar res;
@ -75,19 +75,19 @@ Scalar Object<Scalar, Derived>::dot(const OtherDerived& other) const
}
template<typename Scalar, typename Derived>
typename NumTraits<Scalar>::Real Object<Scalar, Derived>::norm2() const
typename NumTraits<Scalar>::Real MatrixBase<Scalar, Derived>::norm2() const
{
return NumTraits<Scalar>::real(dot(*this));
}
template<typename Scalar, typename Derived>
typename NumTraits<Scalar>::Real Object<Scalar, Derived>::norm() const
typename NumTraits<Scalar>::Real MatrixBase<Scalar, Derived>::norm() const
{
return std::sqrt(norm2());
}
template<typename Scalar, typename Derived>
ScalarMultiple<Derived> Object<Scalar, Derived>::normalized() const
ScalarMultiple<Derived> MatrixBase<Scalar, Derived>::normalized() const
{
return (*this) / norm();
}

4
src/Core/Eval.h
View File

@ -35,7 +35,7 @@ template<typename Expression> class Eval
typedef typename Expression::Scalar Scalar;
typedef Matrix<Scalar, Expression::RowsAtCompileTime, Expression::ColsAtCompileTime> MatrixType;
typedef Expression Base;
friend class Object<Scalar, Expression>;
friend class MatrixBase<Scalar, Expression>;
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Eval)
@ -43,7 +43,7 @@ template<typename Expression> class Eval
};
template<typename Scalar, typename Derived>
Eval<Derived> Object<Scalar, Derived>::eval() const
Eval<Derived> MatrixBase<Scalar, Derived>::eval() const
{
return Eval<Derived>(*static_cast<const Derived*>(this));
}

6
src/Core/FromArray.h
View File

@ -27,11 +27,11 @@
#define EIGEN_FROMARRAY_H
template<typename MatrixType> class FromArray
: public Object<typename MatrixType::Scalar, FromArray<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, FromArray<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
friend class Object<Scalar, FromArray<MatrixType> >;
friend class MatrixBase<Scalar, FromArray<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -65,7 +65,7 @@ template<typename MatrixType> class FromArray
};
template<typename Scalar, typename Derived>
FromArray<Derived> Object<Scalar, Derived>::fromArray(const Scalar* array, int rows, int cols)
FromArray<Derived> MatrixBase<Scalar, Derived>::fromArray(const Scalar* array, int rows, int cols)
{
return FromArray<Derived>(rows, cols, const_cast<Scalar*>(array));
}

8
src/Core/Fuzzy.h
View File

@ -28,7 +28,7 @@
template<typename Scalar, typename Derived>
template<typename OtherDerived>
bool Object<Scalar, Derived>::isApprox(
bool MatrixBase<Scalar, Derived>::isApprox(
const OtherDerived& other,
const typename NumTraits<Scalar>::Real& prec
) const
@ -49,7 +49,7 @@ bool Object<Scalar, Derived>::isApprox(
}
template<typename Scalar, typename Derived>
bool Object<Scalar, Derived>::isMuchSmallerThan(
bool MatrixBase<Scalar, Derived>::isMuchSmallerThan(
const Scalar& other,
const typename NumTraits<Scalar>::Real& prec
) const
@ -69,8 +69,8 @@ bool Object<Scalar, Derived>::isMuchSmallerThan(
template<typename Scalar, typename Derived>
template<typename OtherDerived>
bool Object<Scalar, Derived>::isMuchSmallerThan(
const Object<Scalar, OtherDerived>& other,
bool MatrixBase<Scalar, Derived>::isMuchSmallerThan(
const MatrixBase<Scalar, OtherDerived>& other,
const typename NumTraits<Scalar>::Real& prec
) const
{

6
src/Core/Identity.h
View File

@ -27,11 +27,11 @@
#define EIGEN_IDENTITY_H
template<typename MatrixType> class Identity
: public Object<typename MatrixType::Scalar, Identity<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Identity<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
friend class Object<Scalar, Identity<MatrixType> >;
friend class MatrixBase<Scalar, Identity<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -61,7 +61,7 @@ template<typename MatrixType> class Identity
};
template<typename Scalar, typename Derived>
Identity<Derived> Object<Scalar, Derived>::identity(int rows)
Identity<Derived> MatrixBase<Scalar, Derived>::identity(int rows)
{
return Identity<Derived>(rows);
}

10
src/Core/Matrix.h
View File

@ -27,12 +27,12 @@
#define EIGEN_MATRIX_H
template<typename _Scalar, int _Rows, int _Cols>
class Matrix : public Object<_Scalar, Matrix<_Scalar, _Rows, _Cols> >,
class Matrix : public MatrixBase<_Scalar, Matrix<_Scalar, _Rows, _Cols> >,
public MatrixStorage<_Scalar, _Rows, _Cols>
{
public:
friend class Object<_Scalar, Matrix>;
typedef Object<_Scalar, Matrix> Base;
friend class MatrixBase<_Scalar, Matrix>;
typedef MatrixBase<_Scalar, Matrix> Base;
typedef MatrixStorage<_Scalar, _Rows, _Cols> Storage;
typedef _Scalar Scalar;
typedef MatrixRef<Matrix> Ref;
@ -63,7 +63,7 @@ class Matrix : public Object<_Scalar, Matrix<_Scalar, _Rows, _Cols> >,
public:
template<typename OtherDerived>
Matrix& operator=(const Object<Scalar, OtherDerived>& other)
Matrix& operator=(const MatrixBase<Scalar, OtherDerived>& other)
{
resize(other.rows(), other.cols());
return Base::operator=(other);
@ -84,7 +84,7 @@ class Matrix : public Object<_Scalar, Matrix<_Scalar, _Rows, _Cols> >,
explicit Matrix(int dim) : Storage(dim) {}
explicit Matrix(int rows, int cols) : Storage(rows, cols) {}
template<typename OtherDerived>
Matrix(const Object<Scalar, OtherDerived>& other)
Matrix(const MatrixBase<Scalar, OtherDerived>& other)
: Storage(other.rows(), other.cols())
{
*this = other;

23
src/Core/Object.h → src/Core/MatrixBase.h
View File

@ -26,13 +26,13 @@
#ifndef EIGEN_OBJECT_H
#define EIGEN_OBJECT_H
template<typename Scalar, typename Derived> class Object
template<typename Scalar, typename Derived> class MatrixBase
{
static const int RowsAtCompileTime = Derived::RowsAtCompileTime,
ColsAtCompileTime = Derived::ColsAtCompileTime;
template<typename OtherDerived>
void _copy_helper(const Object<Scalar, OtherDerived>& other);
void _copy_helper(const MatrixBase<Scalar, OtherDerived>& other);
template<typename OtherDerived>
bool _isApprox_helper(
@ -45,9 +45,10 @@ template<typename Scalar, typename Derived> class Object
) const;
template<typename OtherDerived>
bool _isMuchSmallerThan_helper(
const Object<Scalar, OtherDerived>& other,
const MatrixBase<Scalar, OtherDerived>& other,
const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::precision()
) const;
public:
static const int SizeAtCompileTime
= RowsAtCompileTime == Dynamic || ColsAtCompileTime == Dynamic
@ -75,7 +76,7 @@ template<typename Scalar, typename Derived> class Object
}
template<typename OtherDerived>
Derived& operator=(const Object<Scalar, OtherDerived>& other)
Derived& operator=(const MatrixBase<Scalar, OtherDerived>& other)
{
assert(rows() == other.rows() && cols() == other.cols());
_copy_helper(other);
@ -84,7 +85,7 @@ template<typename Scalar, typename Derived> class Object
//special case of the above template operator=. Strangely, g++ 4.1 failed to use
//that template when OtherDerived == Derived
Derived& operator=(const Object& other)
Derived& operator=(const MatrixBase& other)
{
assert(rows() == other.rows() && cols() == other.cols());
_copy_helper(other);
@ -128,22 +129,22 @@ template<typename Scalar, typename Derived> class Object
) const;
template<typename OtherDerived>
bool isMuchSmallerThan(
const Object<Scalar, OtherDerived>& other,
const MatrixBase<Scalar, OtherDerived>& other,
const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::precision()
) const;
template<typename OtherDerived>
Product<Derived, OtherDerived>
lazyProduct(const Object<Scalar, OtherDerived>& other) const EIGEN_ALWAYS_INLINE;
lazyProduct(const MatrixBase<Scalar, OtherDerived>& other) const EIGEN_ALWAYS_INLINE;
Opposite<Derived> operator-() const;
template<typename OtherDerived>
Derived& operator+=(const Object<Scalar, OtherDerived>& other);
Derived& operator+=(const MatrixBase<Scalar, OtherDerived>& other);
template<typename OtherDerived>
Derived& operator-=(const Object<Scalar, OtherDerived>& other);
Derived& operator-=(const MatrixBase<Scalar, OtherDerived>& other);
template<typename OtherDerived>
Derived& operator*=(const Object<Scalar, OtherDerived>& other);
Derived& operator*=(const MatrixBase<Scalar, OtherDerived>& other);
Derived& operator*=(const int& other);
Derived& operator*=(const float& other);
@ -183,7 +184,7 @@ template<typename Scalar, typename Derived> class Object
template<typename Scalar, typename Derived>
std::ostream & operator <<
( std::ostream & s,
const Object<Scalar, Derived> & m )
const MatrixBase<Scalar, Derived> & m )
{
for( int i = 0; i < m.rows(); i++ )
{

4
src/Core/MatrixRef.h
View File

@ -27,11 +27,11 @@
#define EIGEN_MATRIXREF_H
template<typename MatrixType> class MatrixRef
: public Object<typename MatrixType::Scalar, MatrixRef<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, MatrixRef<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
friend class Object<Scalar, MatrixRef>;
friend class MatrixBase<Scalar, MatrixRef>;
MatrixRef(const MatrixType& matrix) : m_matrix(*const_cast<MatrixType*>(&matrix)) {}
MatrixRef(const MatrixRef& other) : m_matrix(other.m_matrix) {}

8
src/Core/Minor.h
View File

@ -27,12 +27,12 @@
#define EIGEN_MINOR_H
template<typename MatrixType> class Minor
: public Object<typename MatrixType::Scalar, Minor<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Minor<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Minor<MatrixType> >;
friend class MatrixBase<Scalar, Minor<MatrixType> >;
static const int
RowsAtCompileTime = (MatrixType::RowsAtCompileTime != Dynamic) ?
@ -75,9 +75,9 @@ template<typename MatrixType> class Minor
template<typename Scalar, typename Derived>
Minor<Derived>
Object<Scalar, Derived>::minor(int row, int col) const
MatrixBase<Scalar, Derived>::minor(int row, int col) const
{
return Minor<Derived>(static_cast<Derived*>(const_cast<Object*>(this))->ref(), row, col);
return Minor<Derived>(static_cast<Derived*>(const_cast<MatrixBase*>(this))->ref(), row, col);
}
#endif // EIGEN_MINOR_H

6
src/Core/Opposite.h
View File

@ -27,12 +27,12 @@
#define EIGEN_OPPOSITE_H
template<typename MatrixType> class Opposite
: public Object<typename MatrixType::Scalar, Opposite<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Opposite<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Opposite<MatrixType> >;
friend class MatrixBase<Scalar, Opposite<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -61,7 +61,7 @@ template<typename MatrixType> class Opposite
template<typename Scalar, typename Derived>
Opposite<Derived>
Object<Scalar, Derived>::operator-() const
MatrixBase<Scalar, Derived>::operator-() const
{
return Opposite<Derived>(static_cast<const Derived*>(this)->ref());
}

10
src/Core/Product.h
View File

@ -62,13 +62,13 @@ struct ProductUnroller<Index, Dynamic, Lhs, Rhs>
};
template<typename Lhs, typename Rhs> class Product
: public Object<typename Lhs::Scalar, Product<Lhs, Rhs> >
: public MatrixBase<typename Lhs::Scalar, Product<Lhs, Rhs> >
{
public:
typedef typename Lhs::Scalar Scalar;
typedef typename Lhs::Ref LhsRef;
typedef typename Rhs::Ref RhsRef;
friend class Object<Scalar, Product>;
friend class MatrixBase<Scalar, Product>;
static const int RowsAtCompileTime = Lhs::RowsAtCompileTime,
ColsAtCompileTime = Rhs::ColsAtCompileTime;
@ -113,14 +113,14 @@ template<typename Lhs, typename Rhs> class Product
template<typename Scalar, typename Derived>
template<typename OtherDerived>
Product<Derived, OtherDerived>
Object<Scalar, Derived>::lazyProduct(const Object<Scalar, OtherDerived> &other) const
MatrixBase<Scalar, Derived>::lazyProduct(const MatrixBase<Scalar, OtherDerived> &other) const
{
return Product<Derived, OtherDerived>(ref(), other.ref());
}
template<typename Scalar, typename Derived1, typename Derived2>
Eval<Product<Derived1, Derived2> >
operator*(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &mat2)
operator*(const MatrixBase<Scalar, Derived1> &mat1, const MatrixBase<Scalar, Derived2> &mat2)
{
return mat1.lazyProduct(mat2).eval();
}
@ -128,7 +128,7 @@ operator*(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &
template<typename Scalar, typename Derived>
template<typename OtherDerived>
Derived &
Object<Scalar, Derived>::operator*=(const Object<Scalar, OtherDerived> &other)
MatrixBase<Scalar, Derived>::operator*=(const MatrixBase<Scalar, OtherDerived> &other)
{
return *this = *this * other;
}

6
src/Core/Random.h
View File

@ -27,11 +27,11 @@
#define EIGEN_RANDOM_H
template<typename MatrixType> class Random
: public Object<typename MatrixType::Scalar, Random<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Random<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
friend class Object<Scalar, Random<MatrixType> >;
friend class MatrixBase<Scalar, Random<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -61,7 +61,7 @@ template<typename MatrixType> class Random
};
template<typename Scalar, typename Derived>
Eval<Random<Derived> > Object<Scalar, Derived>::random(int rows, int cols)
Eval<Random<Derived> > MatrixBase<Scalar, Derived>::random(int rows, int cols)
{
return Random<Derived>(rows, cols).eval();
}

12
src/Core/Row.h
View File

@ -27,12 +27,12 @@
#define EIGEN_ROW_H
template<typename MatrixType> class Row
: public Object<typename MatrixType::Scalar, Row<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Row<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Row<MatrixType> >;
friend class MatrixBase<Scalar, Row<MatrixType> >;
static const int RowsAtCompileTime = 1,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -47,9 +47,9 @@ template<typename MatrixType> class Row
: m_matrix(other.m_matrix), m_row(other.m_row) {}
template<typename OtherDerived>
Row& operator=(const Object<Scalar, OtherDerived>& other)
Row& operator=(const MatrixBase<Scalar, OtherDerived>& other)
{
return Object<Scalar, Row<MatrixType> >::operator=(other);
return MatrixBase<Scalar, Row<MatrixType> >::operator=(other);
}
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Row)
@ -79,9 +79,9 @@ template<typename MatrixType> class Row
template<typename Scalar, typename Derived>
Row<Derived>
Object<Scalar, Derived>::row(int i) const
MatrixBase<Scalar, Derived>::row(int i) const
{
return Row<Derived>(static_cast<Derived*>(const_cast<Object*>(this))->ref(), i);
return Row<Derived>(static_cast<Derived*>(const_cast<MatrixBase*>(this))->ref(), i);
}
#endif // EIGEN_ROW_H

14
src/Core/ScalarMultiple.h
View File

@ -27,12 +27,12 @@
#define EIGEN_SCALARMULTIPLE_H
template<typename MatrixType> class ScalarMultiple
: public Object<typename MatrixType::Scalar, ScalarMultiple<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, ScalarMultiple<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<typename MatrixType::Scalar, ScalarMultiple<MatrixType> >;
friend class MatrixBase<typename MatrixType::Scalar, ScalarMultiple<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -64,7 +64,7 @@ template<typename MatrixType> class ScalarMultiple
#define EIGEN_MAKE_SCALAR_OPS(OtherScalar) \
template<typename Scalar, typename Derived> \
ScalarMultiple<Derived> \
operator*(const Object<Scalar, Derived>& matrix, \
operator*(const MatrixBase<Scalar, Derived>& matrix, \
OtherScalar scalar) \
{ \
return ScalarMultiple<Derived>(matrix.ref(), scalar); \
@ -73,14 +73,14 @@ operator*(const Object<Scalar, Derived>& matrix, \
template<typename Scalar, typename Derived> \
ScalarMultiple<Derived> \
operator*(OtherScalar scalar, \
const Object<Scalar, Derived>& matrix) \
const MatrixBase<Scalar, Derived>& matrix) \
{ \
return ScalarMultiple<Derived>(matrix.ref(), scalar); \
} \
\
template<typename Scalar, typename Derived> \
ScalarMultiple<Derived> \
operator/(const Object<Scalar, Derived>& matrix, \
operator/(const MatrixBase<Scalar, Derived>& matrix, \
OtherScalar scalar) \
{ \
assert(NumTraits<Scalar>::HasFloatingPoint); \
@ -89,14 +89,14 @@ operator/(const Object<Scalar, Derived>& matrix, \
\
template<typename Scalar, typename Derived> \
Derived & \
Object<Scalar, Derived>::operator*=(const OtherScalar &other) \
MatrixBase<Scalar, Derived>::operator*=(const OtherScalar &other) \
{ \
return *this = *this * other; \
} \
\
template<typename Scalar, typename Derived> \
Derived & \
Object<Scalar, Derived>::operator/=(const OtherScalar &other) \
MatrixBase<Scalar, Derived>::operator/=(const OtherScalar &other) \
{ \
return *this = *this / other; \
}

8
src/Core/Sum.h
View File

@ -27,13 +27,13 @@
#define EIGEN_SUM_H
template<typename Lhs, typename Rhs> class Sum
: public Object<typename Lhs::Scalar, Sum<Lhs, Rhs> >
: public MatrixBase<typename Lhs::Scalar, Sum<Lhs, Rhs> >
{
public:
typedef typename Lhs::Scalar Scalar;
typedef typename Lhs::Ref LhsRef;
typedef typename Rhs::Ref RhsRef;
friend class Object<Scalar, Sum>;
friend class MatrixBase<Scalar, Sum>;
static const int RowsAtCompileTime = Lhs::RowsAtCompileTime,
ColsAtCompileTime = Rhs::ColsAtCompileTime;
@ -67,7 +67,7 @@ template<typename Lhs, typename Rhs> class Sum
template<typename Scalar, typename Derived1, typename Derived2>
Sum<Derived1, Derived2>
operator+(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &mat2)
operator+(const MatrixBase<Scalar, Derived1> &mat1, const MatrixBase<Scalar, Derived2> &mat2)
{
return Sum<Derived1, Derived2>(mat1.ref(), mat2.ref());
}
@ -75,7 +75,7 @@ operator+(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &
template<typename Scalar, typename Derived>
template<typename OtherDerived>
Derived &
Object<Scalar, Derived>::operator+=(const Object<Scalar, OtherDerived>& other)
MatrixBase<Scalar, Derived>::operator+=(const MatrixBase<Scalar, OtherDerived>& other)
{
return *this = *this + other;
}

2
src/Core/Trace.h
View File

@ -53,7 +53,7 @@ template<int Index, typename Derived> struct TraceUnroller<Index, Dynamic, Deriv
};
template<typename Scalar, typename Derived>
Scalar Object<Scalar, Derived>::trace() const
Scalar MatrixBase<Scalar, Derived>::trace() const
{
assert(rows() == cols());
Scalar res;

8
src/Core/Transpose.h
View File

@ -27,12 +27,12 @@
#define EIGEN_TRANSPOSE_H
template<typename MatrixType> class Transpose
: public Object<typename MatrixType::Scalar, Transpose<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Transpose<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Ref MatRef;
friend class Object<Scalar, Transpose<MatrixType> >;
friend class MatrixBase<Scalar, Transpose<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::ColsAtCompileTime,
ColsAtCompileTime = MatrixType::RowsAtCompileTime;
@ -65,9 +65,9 @@ template<typename MatrixType> class Transpose
template<typename Scalar, typename Derived>
Transpose<Derived>
Object<Scalar, Derived>::transpose() const
MatrixBase<Scalar, Derived>::transpose() const
{
return Transpose<Derived>(static_cast<Derived*>(const_cast<Object*>(this))->ref());
return Transpose<Derived>(static_cast<Derived*>(const_cast<MatrixBase*>(this))->ref());
}
#endif // EIGEN_TRANSPOSE_H

8
src/Core/Util.h
View File

@ -88,20 +88,20 @@ const int Dynamic = -1;
#define EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \
template<typename OtherScalar, typename OtherDerived> \
Derived& operator Op(const Object<OtherScalar, OtherDerived>& other) \
Derived& operator Op(const MatrixBase<OtherScalar, OtherDerived>& other) \
{ \
return Object<Scalar, Derived>::operator Op(other); \
return MatrixBase<Scalar, Derived>::operator Op(other); \
} \
Derived& operator Op(const Derived& other) \
{ \
return Object<Scalar, Derived>::operator Op(other); \
return MatrixBase<Scalar, Derived>::operator Op(other); \
}
#define EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \
template<typename Other> \
Derived& operator Op(const Other& scalar) \
{ \
return Object<Scalar, Derived>::operator Op(scalar); \
return MatrixBase<Scalar, Derived>::operator Op(scalar); \
}
#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived) \

6
src/Core/Zero.h
View File

@ -27,11 +27,11 @@
#define EIGEN_ZERO_H
template<typename MatrixType> class Zero
: public Object<typename MatrixType::Scalar, Zero<MatrixType> >
: public MatrixBase<typename MatrixType::Scalar, Zero<MatrixType> >
{
public:
typedef typename MatrixType::Scalar Scalar;
friend class Object<Scalar, Zero<MatrixType> >;
friend class MatrixBase<Scalar, Zero<MatrixType> >;
static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime;
@ -61,7 +61,7 @@ template<typename MatrixType> class Zero
};
template<typename Scalar, typename Derived>
Zero<Derived> Object<Scalar, Derived>::zero(int rows, int cols)
Zero<Derived> MatrixBase<Scalar, Derived>::zero(int rows, int cols)
{
return Zero<Derived>(rows, cols);
}

2
test/basicstuff.cpp
View File

@ -33,7 +33,7 @@ template<typename MatrixType> void basicStuff(const MatrixType& m)
Opposite.h Product.h ScalarMultiple.h FromArray.h
2) Implicitly (the core stuff):
Object.h Matrix.h MatrixStorage.h CopyHelper.h MatrixRef.h
MatrixBase.h Matrix.h MatrixStorage.h CopyHelper.h MatrixRef.h
NumTraits.h Util.h
*/