From 55e80e15990ce6bf589bdc3539c97c2a87830881 Mon Sep 17 00:00:00 2001 From: Benoit Jacob Date: Sat, 13 Oct 2007 14:31:27 +0000 Subject: split MatrixOps.h into 3 files; rename ScalarOps.h; remove useless #includes. --- src/Core.h | 5 + src/Core/Difference.h | 83 ++++++++++++++++ src/Core/Matrix.h | 11 --- src/Core/MatrixOps.h | 245 ---------------------------------------------- src/Core/Object.h | 2 +- src/Core/Product.h | 136 +++++++++++++++++++++++++ src/Core/ScalarMultiple.h | 113 +++++++++++++++++++++ src/Core/ScalarOps.h | 113 --------------------- src/Core/Sum.h | 84 ++++++++++++++++ src/Core/Util.h | 2 +- 10 files changed, 423 insertions(+), 371 deletions(-) create mode 100644 src/Core/Difference.h delete mode 100644 src/Core/MatrixOps.h create mode 100644 src/Core/Product.h create mode 100644 src/Core/ScalarMultiple.h delete mode 100644 src/Core/ScalarOps.h create mode 100644 src/Core/Sum.h diff --git a/src/Core.h b/src/Core.h index 2fd9423dd..715cedef5 100644 --- a/src/Core.h +++ b/src/Core.h @@ -12,6 +12,11 @@ namespace Eigen { #include "Core/MatrixRef.h" #include "Core/MatrixStorage.h" #include "Core/Matrix.h" +#include "Core/Eval.h" +#include "Core/ScalarMultiple.h" +#include "Core/Sum.h" +#include "Core/Difference.h" +#include "Core/Product.h" #include "Core/Row.h" #include "Core/Column.h" #include "Core/Block.h" diff --git a/src/Core/Difference.h b/src/Core/Difference.h new file mode 100644 index 000000000..182555c83 --- /dev/null +++ b/src/Core/Difference.h @@ -0,0 +1,83 @@ +// 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 EI_DIFFERENCE_H +#define EI_DIFFERENCE_H + +template class Difference + : public Object > +{ + public: + typedef typename Lhs::Scalar Scalar; + typedef typename Lhs::ConstRef LhsRef; + typedef typename Rhs::ConstRef RhsRef; + friend class Object; + + static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, + ColsAtCompileTime = Rhs::ColsAtCompileTime; + + Difference(const LhsRef& lhs, const RhsRef& rhs) + : m_lhs(lhs), m_rhs(rhs) + { + assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); + } + + Difference(const Difference& other) + : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {} + + EI_INHERIT_ASSIGNMENT_OPERATORS(Difference) + + private: + const Difference& _ref() const { return *this; } + const Difference& _constRef() const { return *this; } + int _rows() const { return m_lhs.rows(); } + int _cols() const { return m_lhs.cols(); } + + Scalar _read(int row, int col) const + { + return m_lhs.read(row, col) - m_rhs.read(row, col); + } + + protected: + const LhsRef m_lhs; + const RhsRef m_rhs; +}; + +template +Difference +operator-(const Object &mat1, const Object &mat2) +{ + return Difference(mat1.constRef(), mat2.constRef()); +} + +template +template +Derived & +Object::operator-=(const Object &other) +{ + return *this = *this - other; +} + +#endif // EI_DIFFERENCE_H diff --git a/src/Core/Matrix.h b/src/Core/Matrix.h index 5717905b1..aad999a04 100644 --- a/src/Core/Matrix.h +++ b/src/Core/Matrix.h @@ -26,12 +26,6 @@ #ifndef EI_MATRIX_H #define EI_MATRIX_H -#include "Util.h" -#include "Numeric.h" -#include "Object.h" -#include "MatrixRef.h" -#include "MatrixStorage.h" - template class Matrix : public Object<_Scalar, Matrix<_Scalar, _Rows, _Cols> >, public MatrixStorage<_Scalar, _Rows, _Cols> @@ -142,9 +136,4 @@ EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(ci) \ EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(cf) \ EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(cd) -#include "Eval.h" -#include "MatrixOps.h" -#include "ScalarOps.h" - - #endif // EI_MATRIX_H diff --git a/src/Core/MatrixOps.h b/src/Core/MatrixOps.h deleted file mode 100644 index 7cec76407..000000000 --- a/src/Core/MatrixOps.h +++ /dev/null @@ -1,245 +0,0 @@ -// 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 EI_MATRIXOPS_H -#define EI_MATRIXOPS_H - -template class Sum - : public Object > -{ - public: - typedef typename Lhs::Scalar Scalar; - typedef typename Lhs::ConstRef LhsRef; - typedef typename Rhs::ConstRef RhsRef; - friend class Object; - - static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, - ColsAtCompileTime = Rhs::ColsAtCompileTime; - - Sum(const LhsRef& lhs, const RhsRef& rhs) - : m_lhs(lhs), m_rhs(rhs) - { - assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); - } - - Sum(const Sum& other) - : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {} - - EI_INHERIT_ASSIGNMENT_OPERATORS(Sum) - - private: - - const Sum& _ref() const { return *this; } - const Sum& _constRef() const { return *this; } - int _rows() const { return m_lhs.rows(); } - int _cols() const { return m_lhs.cols(); } - - Scalar _read(int row, int col) const - { - return m_lhs.read(row, col) + m_rhs.read(row, col); - } - - protected: - const LhsRef m_lhs; - const RhsRef m_rhs; -}; - -template class Difference - : public Object > -{ - public: - typedef typename Lhs::Scalar Scalar; - typedef typename Lhs::ConstRef LhsRef; - typedef typename Rhs::ConstRef RhsRef; - friend class Object; - - static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, - ColsAtCompileTime = Rhs::ColsAtCompileTime; - - Difference(const LhsRef& lhs, const RhsRef& rhs) - : m_lhs(lhs), m_rhs(rhs) - { - assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); - } - - Difference(const Difference& other) - : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {} - - EI_INHERIT_ASSIGNMENT_OPERATORS(Difference) - - private: - const Difference& _ref() const { return *this; } - const Difference& _constRef() const { return *this; } - int _rows() const { return m_lhs.rows(); } - int _cols() const { return m_lhs.cols(); } - - Scalar _read(int row, int col) const - { - return m_lhs.read(row, col) - m_rhs.read(row, col); - } - - protected: - const LhsRef m_lhs; - const RhsRef m_rhs; -}; - -template -struct MatrixProductUnroller -{ - static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, - typename Lhs::Scalar &res) - { - MatrixProductUnroller::run(row, col, lhs, rhs, res); - res += lhs.read(row, Index) * rhs.read(Index, col); - } -}; - -template -struct MatrixProductUnroller<0, Size, Lhs, Rhs> -{ - static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, - typename Lhs::Scalar &res) - { - res = lhs.read(row, 0) * rhs.read(0, col); - } -}; - -template -struct MatrixProductUnroller -{ - static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, - typename Lhs::Scalar &res) - { - EI_UNUSED(row); - EI_UNUSED(col); - EI_UNUSED(lhs); - EI_UNUSED(rhs); - EI_UNUSED(res); - } -}; - -template class MatrixProduct - : public Object > -{ - public: - typedef typename Lhs::Scalar Scalar; - typedef typename Lhs::ConstRef LhsRef; - typedef typename Rhs::ConstRef RhsRef; - friend class Object; - - static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, - ColsAtCompileTime = Rhs::ColsAtCompileTime; - - MatrixProduct(const LhsRef& lhs, const RhsRef& rhs) - : m_lhs(lhs), m_rhs(rhs) - { - assert(lhs.cols() == rhs.rows()); - } - - MatrixProduct(const MatrixProduct& other) - : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {} - - EI_INHERIT_ASSIGNMENT_OPERATORS(MatrixProduct) - - private: - const MatrixProduct& _ref() const { return *this; } - const MatrixProduct& _constRef() const { return *this; } - int _rows() const { return m_lhs.rows(); } - int _cols() const { return m_rhs.cols(); } - - Scalar _read(int row, int col) const - { - Scalar res; - if(Lhs::ColsAtCompileTime != Dynamic && Lhs::ColsAtCompileTime <= 16) - MatrixProductUnroller - ::run(row, col, m_lhs, m_rhs, res); - else - { - res = m_lhs(row, 0) * m_rhs(0, col); - for(int i = 1; i < m_lhs.cols(); i++) - res += m_lhs(row, i) * m_rhs(i, col); - } - return res; - } - - protected: - const LhsRef m_lhs; - const RhsRef m_rhs; -}; - -template -Sum -operator+(const Object &mat1, const Object &mat2) -{ - return Sum(mat1.constRef(), mat2.constRef()); -} - -template -Difference -operator-(const Object &mat1, const Object &mat2) -{ - return Difference(mat1.constRef(), mat2.constRef()); -} - -template -template -MatrixProduct -Object::lazyProduct(const Object &other) const -{ - return MatrixProduct(constRef(), other.constRef()); -} - -template -Eval > -operator*(const Object &mat1, const Object &mat2) -{ - return mat1.lazyProduct(mat2).eval(); -} - -template -template -Derived & -Object::operator+=(const Object& other) -{ - return *this = *this + other; -} - -template -template -Derived & -Object::operator-=(const Object &other) -{ - return *this = *this - other; -} - -template -template -Derived & -Object::operator*=(const Object &other) -{ - return *this = *this * other; -} - -#endif // EI_MATRIXOPS_H diff --git a/src/Core/Object.h b/src/Core/Object.h index 90962c46c..777798299 100644 --- a/src/Core/Object.h +++ b/src/Core/Object.h @@ -116,7 +116,7 @@ template class Object ) const; template - MatrixProduct + Product lazyProduct(const Object& other) const EI_ALWAYS_INLINE; template diff --git a/src/Core/Product.h b/src/Core/Product.h new file mode 100644 index 000000000..29b11b74d --- /dev/null +++ b/src/Core/Product.h @@ -0,0 +1,136 @@ +// 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 EI_PRODUCT_H +#define EI_PRODUCT_H + +template +struct ProductUnroller +{ + static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, + typename Lhs::Scalar &res) + { + ProductUnroller::run(row, col, lhs, rhs, res); + res += lhs.read(row, Index) * rhs.read(Index, col); + } +}; + +template +struct ProductUnroller<0, Size, Lhs, Rhs> +{ + static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, + typename Lhs::Scalar &res) + { + res = lhs.read(row, 0) * rhs.read(0, col); + } +}; + +template +struct ProductUnroller +{ + static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, + typename Lhs::Scalar &res) + { + EI_UNUSED(row); + EI_UNUSED(col); + EI_UNUSED(lhs); + EI_UNUSED(rhs); + EI_UNUSED(res); + } +}; + +template class Product + : public Object > +{ + public: + typedef typename Lhs::Scalar Scalar; + typedef typename Lhs::ConstRef LhsRef; + typedef typename Rhs::ConstRef RhsRef; + friend class Object; + + static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, + ColsAtCompileTime = Rhs::ColsAtCompileTime; + + Product(const LhsRef& lhs, const RhsRef& rhs) + : m_lhs(lhs), m_rhs(rhs) + { + assert(lhs.cols() == rhs.rows()); + } + + Product(const Product& other) + : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {} + + EI_INHERIT_ASSIGNMENT_OPERATORS(Product) + + private: + const Product& _ref() const { return *this; } + const Product& _constRef() const { return *this; } + int _rows() const { return m_lhs.rows(); } + int _cols() const { return m_rhs.cols(); } + + Scalar _read(int row, int col) const + { + Scalar res; + if(Lhs::ColsAtCompileTime != Dynamic && Lhs::ColsAtCompileTime <= 16) + ProductUnroller + ::run(row, col, m_lhs, m_rhs, res); + else + { + res = m_lhs(row, 0) * m_rhs(0, col); + for(int i = 1; i < m_lhs.cols(); i++) + res += m_lhs(row, i) * m_rhs(i, col); + } + return res; + } + + protected: + const LhsRef m_lhs; + const RhsRef m_rhs; +}; + +template +template +Product +Object::lazyProduct(const Object &other) const +{ + return Product(constRef(), other.constRef()); +} + +template +Eval > +operator*(const Object &mat1, const Object &mat2) +{ + return mat1.lazyProduct(mat2).eval(); +} + +template +template +Derived & +Object::operator*=(const Object &other) +{ + return *this = *this * other; +} + +#endif // EI_PRODUCT_H diff --git a/src/Core/ScalarMultiple.h b/src/Core/ScalarMultiple.h new file mode 100644 index 000000000..8532411a6 --- /dev/null +++ b/src/Core/ScalarMultiple.h @@ -0,0 +1,113 @@ +// 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 EI_SCALARMULTIPLE_H +#define EI_SCALARMULTIPLE_H + +template class ScalarMultiple + : public Object > +{ + public: + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::ConstRef MatRef; + friend class Object >; + + static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, + ColsAtCompileTime = MatrixType::ColsAtCompileTime; + + ScalarMultiple(const MatRef& matrix, Scalar scalar) + : m_matrix(matrix), m_scalar(scalar) {} + + ScalarMultiple(const ScalarMultiple& other) + : m_matrix(other.m_matrix), m_scalar(other.m_scalar) {} + + EI_INHERIT_ASSIGNMENT_OPERATORS(ScalarMultiple) + + private: + const ScalarMultiple& _ref() const { return *this; } + const ScalarMultiple& _constRef() const { return *this; } + int _rows() const { return m_matrix.rows(); } + int _cols() const { return m_matrix.cols(); } + + Scalar _read(int row, int col) const + { + return m_matrix.read(row, col) * m_scalar; + } + + protected: + const MatRef m_matrix; + const Scalar m_scalar; +}; + +#define EI_MAKE_SCALAR_OPS(OtherScalar) \ +template \ +ScalarMultiple \ +operator*(const Object& matrix, \ + OtherScalar scalar) \ +{ \ + return ScalarMultiple(matrix.constRef(), scalar); \ +} \ + \ +template \ +ScalarMultiple \ +operator*(OtherScalar scalar, \ + const Object& matrix) \ +{ \ + return ScalarMultiple(matrix.constRef(), scalar); \ +} \ + \ +template \ +ScalarMultiple \ +operator/(const Object& matrix, \ + OtherScalar scalar) \ +{ \ + assert(NumTraits::HasFloatingPoint); \ + return matrix * (static_cast(1) / scalar); \ +} \ + \ +template \ +Derived & \ +Object::operator*=(const OtherScalar &other) \ +{ \ + return *this = *this * other; \ +} \ + \ +template \ +Derived & \ +Object::operator/=(const OtherScalar &other) \ +{ \ + return *this = *this / other; \ +} + +EI_MAKE_SCALAR_OPS(int) +EI_MAKE_SCALAR_OPS(float) +EI_MAKE_SCALAR_OPS(double) +EI_MAKE_SCALAR_OPS(std::complex) +EI_MAKE_SCALAR_OPS(std::complex) +EI_MAKE_SCALAR_OPS(std::complex) + +#undef EI_MAKE_SCALAR_OPS + +#endif // EI_SCALARMULTIPLE_H diff --git a/src/Core/ScalarOps.h b/src/Core/ScalarOps.h deleted file mode 100644 index 77c9b9342..000000000 --- a/src/Core/ScalarOps.h +++ /dev/null @@ -1,113 +0,0 @@ -// 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 EI_SCALAROPS_H -#define EI_SCALAROPS_H - -template class ScalarMultiple - : public Object > -{ - public: - typedef typename MatrixType::Scalar Scalar; - typedef typename MatrixType::ConstRef MatRef; - friend class Object >; - - static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime, - ColsAtCompileTime = MatrixType::ColsAtCompileTime; - - ScalarMultiple(const MatRef& matrix, Scalar scalar) - : m_matrix(matrix), m_scalar(scalar) {} - - ScalarMultiple(const ScalarMultiple& other) - : m_matrix(other.m_matrix), m_scalar(other.m_scalar) {} - - EI_INHERIT_ASSIGNMENT_OPERATORS(ScalarMultiple) - - private: - const ScalarMultiple& _ref() const { return *this; } - const ScalarMultiple& _constRef() const { return *this; } - int _rows() const { return m_matrix.rows(); } - int _cols() const { return m_matrix.cols(); } - - Scalar _read(int row, int col) const - { - return m_matrix.read(row, col) * m_scalar; - } - - protected: - const MatRef m_matrix; - const Scalar m_scalar; -}; - -#define EI_MAKE_SCALAR_OPS(OtherScalar) \ -template \ -ScalarMultiple \ -operator*(const Object& matrix, \ - OtherScalar scalar) \ -{ \ - return ScalarMultiple(matrix.constRef(), scalar); \ -} \ - \ -template \ -ScalarMultiple \ -operator*(OtherScalar scalar, \ - const Object& matrix) \ -{ \ - return ScalarMultiple(matrix.constRef(), scalar); \ -} \ - \ -template \ -ScalarMultiple \ -operator/(const Object& matrix, \ - OtherScalar scalar) \ -{ \ - assert(NumTraits::HasFloatingPoint); \ - return matrix * (static_cast(1) / scalar); \ -} \ - \ -template \ -Derived & \ -Object::operator*=(const OtherScalar &other) \ -{ \ - return *this = *this * other; \ -} \ - \ -template \ -Derived & \ -Object::operator/=(const OtherScalar &other) \ -{ \ - return *this = *this / other; \ -} - -EI_MAKE_SCALAR_OPS(int) -EI_MAKE_SCALAR_OPS(float) -EI_MAKE_SCALAR_OPS(double) -EI_MAKE_SCALAR_OPS(std::complex) -EI_MAKE_SCALAR_OPS(std::complex) -EI_MAKE_SCALAR_OPS(std::complex) - -#undef EI_MAKE_SCALAR_OPS - -#endif // EI_SCALAROPS_H diff --git a/src/Core/Sum.h b/src/Core/Sum.h new file mode 100644 index 000000000..2b3ec5807 --- /dev/null +++ b/src/Core/Sum.h @@ -0,0 +1,84 @@ +// 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 EI_SUM_H +#define EI_SUM_H + +template class Sum + : public Object > +{ + public: + typedef typename Lhs::Scalar Scalar; + typedef typename Lhs::ConstRef LhsRef; + typedef typename Rhs::ConstRef RhsRef; + friend class Object; + + static const int RowsAtCompileTime = Lhs::RowsAtCompileTime, + ColsAtCompileTime = Rhs::ColsAtCompileTime; + + Sum(const LhsRef& lhs, const RhsRef& rhs) + : m_lhs(lhs), m_rhs(rhs) + { + assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols()); + } + + Sum(const Sum& other) + : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {} + + EI_INHERIT_ASSIGNMENT_OPERATORS(Sum) + + private: + + const Sum& _ref() const { return *this; } + const Sum& _constRef() const { return *this; } + int _rows() const { return m_lhs.rows(); } + int _cols() const { return m_lhs.cols(); } + + Scalar _read(int row, int col) const + { + return m_lhs.read(row, col) + m_rhs.read(row, col); + } + + protected: + const LhsRef m_lhs; + const RhsRef m_rhs; +}; + +template +Sum +operator+(const Object &mat1, const Object &mat2) +{ + return Sum(mat1.constRef(), mat2.constRef()); +} + +template +template +Derived & +Object::operator+=(const Object& other) +{ + return *this = *this + other; +} + +#endif // EI_SUM_H diff --git a/src/Core/Util.h b/src/Core/Util.h index 431c008ed..8a9919ac6 100644 --- a/src/Core/Util.h +++ b/src/Core/Util.h @@ -52,7 +52,7 @@ template class Transpose; template class Conjugate; template class Sum; template class Difference; -template class MatrixProduct; +template class Product; template class ScalarMultiple; template class Random; template class Eval; -- cgit v1.2.3