diff --git a/Eigen/src/Array/Array.h b/Eigen/src/Array/Array.h new file mode 100644 index 000000000..ff3dfe7e4 --- /dev/null +++ b/Eigen/src/Array/Array.h @@ -0,0 +1,549 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2009 Gael Guennebaud +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, 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 of +// the License, 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 Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . + +#ifndef EIGEN_ARRAYBASE_H +#define EIGEN_ARRAYBASE_H + +/** \ingroup Array_Module + * + * \class ArrayBase + * + * \brief Base class for all 1D and 2D array, and related expressions + * + * An array is similar to a dense vector or matrix. While matrices are mathematical + * objects with well defined linear algebra operators, an array is just a collection + * of scalar values arranged in a one or two dimensionnal fashion. The main consequence, + * is that all operations applied to an array are performed coefficient wise. Furthermore, + * arays support scalar math functions of the c++ standard library, and convenient + * constructors allowing to easily write generic code working for both scalar values + * and arrays. + * + * This class is the base that is inherited by all array expression types. + * + * \param Derived is the derived type, e.g. an array type, or an expression, etc. + * + * \sa class ArrayBase + */ +template class ArrayBase +#ifndef EIGEN_PARSED_BY_DOXYGEN + : public ei_special_scalar_op_base::Scalar, + typename NumTraits::Scalar>::Real> +#endif // not EIGEN_PARSED_BY_DOXYGEN +{ + public: +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** The base class for a given storage type. */ + typedef ArrayBase StorageBaseType; + /** Construct the base class type for the derived class OtherDerived */ + template struct MakeBase { typedef ArrayBase Type; }; + + using ei_special_scalar_op_base::Scalar, + typename NumTraits::Scalar>::Real>::operator*; + + class InnerIterator; + + typedef typename ei_traits::Scalar Scalar; + typedef typename ei_packet_traits::type PacketScalar; +#endif // not EIGEN_PARSED_BY_DOXYGEN + + // FIXME A lot of this stuff could be moved to AnyArrayBase, I guess + + enum { + + RowsAtCompileTime = ei_traits::RowsAtCompileTime, + /**< The number of rows at compile-time. This is just a copy of the value provided + * by the \a Derived type. If a value is not known at compile-time, + * it is set to the \a Dynamic constant. + * \sa ArrayBase::rows(), ArrayBase::cols(), ColsAtCompileTime, SizeAtCompileTime */ + + ColsAtCompileTime = ei_traits::ColsAtCompileTime, + /**< The number of columns at compile-time. This is just a copy of the value provided + * by the \a Derived type. If a value is not known at compile-time, + * it is set to the \a Dynamic constant. + * \sa ArrayBase::rows(), ArrayBase::cols(), RowsAtCompileTime, SizeAtCompileTime */ + + + SizeAtCompileTime = (ei_size_at_compile_time::RowsAtCompileTime, + ei_traits::ColsAtCompileTime>::ret), + /**< This is equal to the number of coefficients, i.e. the number of + * rows times the number of columns, or to \a Dynamic if this is not + * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */ + + MaxRowsAtCompileTime = ei_traits::MaxRowsAtCompileTime, + /**< This value is equal to the maximum possible number of rows that this expression + * might have. If this expression might have an arbitrarily high number of rows, + * this value is set to \a Dynamic. + * + * This value is useful to know when evaluating an expression, in order to determine + * whether it is possible to avoid doing a dynamic memory allocation. + * + * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime + */ + + MaxColsAtCompileTime = ei_traits::MaxColsAtCompileTime, + /**< This value is equal to the maximum possible number of columns that this expression + * might have. If this expression might have an arbitrarily high number of columns, + * this value is set to \a Dynamic. + * + * This value is useful to know when evaluating an expression, in order to determine + * whether it is possible to avoid doing a dynamic memory allocation. + * + * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime + */ + + MaxSizeAtCompileTime = (ei_size_at_compile_time::MaxRowsAtCompileTime, + ei_traits::MaxColsAtCompileTime>::ret), + /**< This value is equal to the maximum possible number of coefficients that this expression + * might have. If this expression might have an arbitrarily high number of coefficients, + * this value is set to \a Dynamic. + * + * This value is useful to know when evaluating an expression, in order to determine + * whether it is possible to avoid doing a dynamic memory allocation. + * + * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime + */ + + IsVectorAtCompileTime = ei_traits::RowsAtCompileTime == 1 + || ei_traits::ColsAtCompileTime == 1, + /**< This is set to true if either the number of rows or the number of + * columns is known at compile-time to be equal to 1. Indeed, in that case, + * we are dealing with a column-vector (if there is only one column) or with + * a row-vector (if there is only one row). */ + + Flags = ei_traits::Flags, + /**< This stores expression \ref flags flags which may or may not be inherited by new expressions + * constructed from this one. See the \ref flags "list of flags". + */ + + CoeffReadCost = ei_traits::CoeffReadCost, + /**< This is a rough measure of how expensive it is to read one coefficient from + * this expression. + */ + +#ifndef EIGEN_PARSED_BY_DOXYGEN + _HasDirectAccess = (int(Flags)&DirectAccessBit) ? 1 : 0 // workaround sunCC +#endif + }; + +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** This is the "real scalar" type; if the \a Scalar type is already real numbers + * (e.g. int, float or double) then \a RealScalar is just the same as \a Scalar. If + * \a Scalar is \a std::complex then RealScalar is \a T. + * + * \sa class NumTraits + */ + typedef typename NumTraits::Real RealScalar; + + /** type of the equivalent square matrix */ + typedef Matrix SquareMatrixType; +#endif // not EIGEN_PARSED_BY_DOXYGEN + + /** \returns the number of rows. \sa cols(), RowsAtCompileTime */ + inline int rows() const { return derived().rows(); } + /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/ + inline int cols() const { return derived().cols(); } + /** \returns the number of coefficients, which is rows()*cols(). + * \sa rows(), cols(), SizeAtCompileTime. */ + inline int size() const { return rows() * cols(); } + /** \returns the number of nonzero coefficients which is in practice the number + * of stored coefficients. */ + inline int nonZeros() const { return size(); } + /** \returns true if either the number of rows or the number of columns is equal to 1. + * In other words, this function returns + * \code rows()==1 || cols()==1 \endcode + * \sa rows(), cols(), IsVectorAtCompileTime. */ + inline bool isVector() const { return rows()==1 || cols()==1; } + /** \returns the size of the storage major dimension, + * i.e., the number of columns for a columns major matrix, and the number of rows otherwise */ + int outerSize() const { return (int(Flags)&RowMajorBit) ? this->rows() : this->cols(); } + /** \returns the size of the inner dimension according to the storage order, + * i.e., the number of rows for a columns major matrix, and the number of cols otherwise */ + int innerSize() const { return (int(Flags)&RowMajorBit) ? this->cols() : this->rows(); } + + /** Only plain matrices, not expressions may be resized; therefore the only useful resize method is + * Matrix::resize(). The present method only asserts that the new size equals the old size, and does + * nothing else. + */ + void resize(int size) + { + ei_assert(size == this->size() + && "ArrayBase::resize() does not actually allow to resize."); + } + /** Only plain matrices, not expressions may be resized; therefore the only useful resize method is + * Matrix::resize(). The present method only asserts that the new size equals the old size, and does + * nothing else. + */ + void resize(int rows, int cols) + { + ei_assert(rows == this->rows() && cols == this->cols() + && "ArrayBase::resize() does not actually allow to resize."); + } + +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** \internal the plain matrix type corresponding to this expression. Note that is not necessarily + * exactly the return type of eval(): in the case of plain matrices, the return type of eval() is a const + * reference to a matrix, not a matrix! It is however guaranteed that the return type of eval() is either + * PlainMatrixType or const PlainMatrixType&. + */ + typedef typename ei_plain_matrix_type::type PlainMatrixType; + /** \internal the column-major plain matrix type corresponding to this expression. Note that is not necessarily + * exactly the return type of eval(): in the case of plain matrices, the return type of eval() is a const + * reference to a matrix, not a matrix! + * The only difference from PlainMatrixType is that PlainMatrixType_ColMajor is guaranteed to be column-major. + */ + typedef typename ei_plain_matrix_type::type PlainMatrixType_ColMajor; + + /** \internal the return type of coeff() + */ + typedef typename ei_meta_if<_HasDirectAccess, const Scalar&, Scalar>::ret CoeffReturnType; + + /** \internal Represents a matrix with all coefficients equal to one another*/ + typedef CwiseNullaryOp,Derived> ConstantReturnType; + /** \internal expression tyepe of a column */ + typedef Block::RowsAtCompileTime, 1> ColXpr; + /** \internal expression tyepe of a column */ + typedef Block::ColsAtCompileTime> RowXpr; +#endif // not EIGEN_PARSED_BY_DOXYGEN + + #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase + #include "../Core/CommonCwiseUnaryOps.h" + #include "ArrayCwiseUnaryOps.h" + #include "../Core/CommonCwiseBinaryOps.h" + #include "ArrayCwiseBinaryOps.h" + #undef EIGEN_CURRENT_STORAGE_BASE_CLASS + + /** Copies \a other into *this. \returns a reference to *this. */ + template + Derived& operator=(const ArrayBase& other); + + /** Special case of the template operator=, in order to prevent the compiler + * from generating a default operator= (issue hit with g++ 4.1) + */ + Derived& operator=(const ArrayBase& other); + + template + Derived& operator=(const AnyArrayBase &other); + + template + Derived& operator+=(const AnyArrayBase &other); + + template + Derived& operator-=(const AnyArrayBase &other); + + template + Derived& operator=(const ReturnByValue& func); + +#ifndef EIGEN_PARSED_BY_DOXYGEN + /** Copies \a other into *this without evaluating other. \returns a reference to *this. */ + template + Derived& lazyAssign(const ArrayBase& other); +#endif // not EIGEN_PARSED_BY_DOXYGEN + + CommaInitializer operator<< (const Scalar& s); + + template + CommaInitializer operator<< (const ArrayBase& other); + + const CoeffReturnType coeff(int row, int col) const; + const CoeffReturnType operator()(int row, int col) const; + + Scalar& coeffRef(int row, int col); + Scalar& operator()(int row, int col); + + const CoeffReturnType coeff(int index) const; + const CoeffReturnType operator[](int index) const; + const CoeffReturnType operator()(int index) const; + + Scalar& coeffRef(int index); + Scalar& operator[](int index); + Scalar& operator()(int index); + +#ifndef EIGEN_PARSED_BY_DOXYGEN + template + void copyCoeff(int row, int col, const ArrayBase& other); + template + void copyCoeff(int index, const ArrayBase& other); + template + void copyPacket(int row, int col, const ArrayBase& other); + template + void copyPacket(int index, const ArrayBase& other); +#endif // not EIGEN_PARSED_BY_DOXYGEN + + template + PacketScalar packet(int row, int col) const; + template + void writePacket(int row, int col, const PacketScalar& x); + + template + PacketScalar packet(int index) const; + template + void writePacket(int index, const PacketScalar& x); + + template + Derived& operator+=(const ArrayBase& other); + template + Derived& operator-=(const ArrayBase& other); + + template + Derived& operator*=(const ArrayBase& other); + + Eigen::Transpose transpose(); + const Eigen::Transpose transpose() const; + void transposeInPlace(); + + #ifndef EIGEN_NO_DEBUG + template + Derived& lazyAssign(const Transpose& other); + template + Derived& lazyAssign(const CwiseBinaryOp,Transpose,DerivedB>& other); + template + Derived& lazyAssign(const CwiseBinaryOp,DerivedA,Transpose >& other); + + template + Derived& lazyAssign(const CwiseUnaryOp, NestByValue > >& other); + template + Derived& lazyAssign(const CwiseBinaryOp,CwiseUnaryOp, NestByValue > >,DerivedB>& other); + template + Derived& lazyAssign(const CwiseBinaryOp,DerivedA,CwiseUnaryOp, NestByValue > > >& other); + #endif + + RowXpr row(int i); + const RowXpr row(int i) const; + + ColXpr col(int i); + const ColXpr col(int i) const; + + Minor minor(int row, int col); + const Minor minor(int row, int col) const; + + typename BlockReturnType::Type block(int startRow, int startCol, int blockRows, int blockCols); + const typename BlockReturnType::Type + block(int startRow, int startCol, int blockRows, int blockCols) const; + + VectorBlock segment(int start, int size); + const VectorBlock segment(int start, int size) const; + + VectorBlock start(int size); + const VectorBlock start(int size) const; + + VectorBlock end(int size); + const VectorBlock end(int size) const; + + typename BlockReturnType::Type corner(CornerType type, int cRows, int cCols); + const typename BlockReturnType::Type corner(CornerType type, int cRows, int cCols) const; + + template + typename BlockReturnType::Type block(int startRow, int startCol); + template + const typename BlockReturnType::Type block(int startRow, int startCol) const; + + template + typename BlockReturnType::Type corner(CornerType type); + template + const typename BlockReturnType::Type corner(CornerType type) const; + + template VectorBlock start(void); + template const VectorBlock start() const; + + template VectorBlock end(); + template const VectorBlock end() const; + + template VectorBlock segment(int start); + template const VectorBlock segment(int start) const; + + static const ConstantReturnType + Constant(int rows, int cols, const Scalar& value); + static const ConstantReturnType + Constant(int size, const Scalar& value); + static const ConstantReturnType + Constant(const Scalar& value); + + template + static const CwiseNullaryOp + NullaryExpr(int rows, int cols, const CustomNullaryOp& func); + template + static const CwiseNullaryOp + NullaryExpr(int size, const CustomNullaryOp& func); + template + static const CwiseNullaryOp + NullaryExpr(const CustomNullaryOp& func); + + static const ConstantReturnType Zero(int rows, int cols); + static const ConstantReturnType Zero(int size); + static const ConstantReturnType Zero(); + static const ConstantReturnType Ones(int rows, int cols); + static const ConstantReturnType Ones(int size); + static const ConstantReturnType Ones(); + + void fill(const Scalar& value); + Derived& setConstant(const Scalar& value); + Derived& setZero(); + Derived& setOnes(); + Derived& setRandom(); + + + template + bool isApprox(const ArrayBase& other, + RealScalar prec = precision()) const; + bool isMuchSmallerThan(const RealScalar& other, + RealScalar prec = precision()) const; + template + bool isMuchSmallerThan(const ArrayBase& other, + RealScalar prec = precision()) const; + + bool isApproxToConstant(const Scalar& value, RealScalar prec = precision()) const; + bool isConstant(const Scalar& value, RealScalar prec = precision()) const; + bool isZero(RealScalar prec = precision()) const; + bool isOnes(RealScalar prec = precision()) const; + bool isIdentity(RealScalar prec = precision()) const; + bool isDiagonal(RealScalar prec = precision()) const; + + bool isUpperTriangular(RealScalar prec = precision()) const; + bool isLowerTriangular(RealScalar prec = precision()) const; + + template + bool isOrthogonal(const ArrayBase& other, + RealScalar prec = precision()) const; + bool isUnitary(RealScalar prec = precision()) const; + + template + inline bool operator==(const ArrayBase& other) const + { return cwiseEqual(other).all(); } + + template + inline bool operator!=(const ArrayBase& other) const + { return cwiseNotEqual(other).all(); } + + + /** \returns the matrix or vector obtained by evaluating this expression. + * + * Notice that in the case of a plain matrix or vector (not an expression) this function just returns + * a const reference, in order to avoid a useless copy. + */ + EIGEN_STRONG_INLINE const typename ei_eval::type eval() const + { return typename ei_eval::type(derived()); } + + template + void swap(ArrayBase EIGEN_REF_TO_TEMPORARY other); + + NoAlias noalias(); + + /** \returns number of elements to skip to pass from one row (resp. column) to another + * for a row-major (resp. column-major) matrix. + * Combined with coeffRef() and the \ref flags flags, it allows a direct access to the data + * of the underlying matrix. + */ + inline int stride(void) const { return derived().stride(); } + + inline const NestByValue nestByValue() const; + + Scalar sum() const; + Scalar mean() const; + Scalar trace() const; + + Scalar prod() const; + + typename ei_traits::Scalar minCoeff() const; + typename ei_traits::Scalar maxCoeff() const; + + typename ei_traits::Scalar minCoeff(int* row, int* col) const; + typename ei_traits::Scalar maxCoeff(int* row, int* col) const; + + typename ei_traits::Scalar minCoeff(int* index) const; + typename ei_traits::Scalar maxCoeff(int* index) const; + + template + typename ei_result_of::Scalar)>::type + redux(const BinaryOp& func) const; + + template + void visit(Visitor& func) const; + +#ifndef EIGEN_PARSED_BY_DOXYGEN + using AnyArrayBase::derived; + inline Derived& const_cast_derived() const + { return *static_cast(const_cast(this)); } +#endif // not EIGEN_PARSED_BY_DOXYGEN + + inline const WithFormat format(const IOFormat& fmt) const; + + bool all(void) const; + bool any(void) const; + int count() const; + + const VectorwiseOp rowwise() const; + VectorwiseOp rowwise(); + const VectorwiseOp colwise() const; + VectorwiseOp colwise(); + + static const CwiseNullaryOp,Derived> Random(int rows, int cols); + static const CwiseNullaryOp,Derived> Random(int size); + static const CwiseNullaryOp,Derived> Random(); + + template + const Select + select(const ArrayBase& thenMatrix, + const ArrayBase& elseMatrix) const; + + template + inline const Select > + select(const ArrayBase& thenMatrix, typename ThenDerived::Scalar elseScalar) const; + + template + inline const Select, ElseDerived > + select(typename ElseDerived::Scalar thenScalar, const ArrayBase& elseMatrix) const; + + template + const Replicate replicate() const; + const Replicate replicate(int rowFacor,int colFactor) const; + + Eigen::Reverse reverse(); + const Eigen::Reverse reverse() const; + void reverseInPlace(); + + #ifdef EIGEN_MATRIXBASE_PLUGIN + #include EIGEN_MATRIXBASE_PLUGIN + #endif + + protected: + /** Default constructor. Do nothing. */ + ArrayBase() + { + /* Just checks for self-consistency of the flags. + * Only do it when debugging Eigen, as this borders on paranoiac and could slow compilation down + */ +#ifdef EIGEN_INTERNAL_DEBUGGING + EIGEN_STATIC_ASSERT(ei_are_flags_consistent::ret, + INVALID_MATRIXBASE_TEMPLATE_PARAMETERS) +#endif + } + + private: + explicit ArrayBase(int); + ArrayBase(int,int); + template explicit ArrayBase(const ArrayBase&); +}; + +#endif // EIGEN_ARRAYBASE_H diff --git a/Eigen/src/CMakeLists.txt b/Eigen/src/CMakeLists.txt index 4c3ee6cb8..0d3604f06 100644 --- a/Eigen/src/CMakeLists.txt +++ b/Eigen/src/CMakeLists.txt @@ -10,4 +10,5 @@ ADD_SUBDIRECTORY(Sparse) ADD_SUBDIRECTORY(Jacobi) ADD_SUBDIRECTORY(Householder) ADD_SUBDIRECTORY(Eigenvalues) -ADD_SUBDIRECTORY(misc) \ No newline at end of file +ADD_SUBDIRECTORY(misc) +ADD_SUBDIRECTORY(plugins) diff --git a/Eigen/src/Core/CwiseBinaryOp.h b/Eigen/src/Core/CwiseBinaryOp.h index 401d57ee5..0b45261ae 100644 --- a/Eigen/src/Core/CwiseBinaryOp.h +++ b/Eigen/src/Core/CwiseBinaryOp.h @@ -1,7 +1,7 @@ // This file is part of Eigen, a lightweight C++ template library // for linear algebra. // -// Copyright (C) 2008 Gael Guennebaud +// Copyright (C) 2008-2009 Gael Guennebaud // Copyright (C) 2006-2008 Benoit Jacob // // Eigen is free software; you can redistribute it and/or @@ -135,7 +135,7 @@ class CwiseBinaryOp : ei_no_assignment_operator, template class CwiseBinaryOpImpl - : public MatrixBase > + : public Lhs::template MakeBase< CwiseBinaryOp >::Type { public: diff --git a/Eigen/src/Core/CwiseUnaryOp.h b/Eigen/src/Core/CwiseUnaryOp.h index 55f965b4e..abece413b 100644 --- a/Eigen/src/Core/CwiseUnaryOp.h +++ b/Eigen/src/Core/CwiseUnaryOp.h @@ -92,9 +92,12 @@ class CwiseUnaryOp : ei_no_assignment_operator, const UnaryOp m_functor; }; +// This is the generic implementation for dense storage. +// It can be used for any matrix types implementing the dense concept. template -class CwiseUnaryOpImpl : public MatrixBase > -{ +class CwiseUnaryOpImpl + : public MatrixType::template MakeBase< CwiseUnaryOp >::Type + { const typename ei_cleantype::type& matrix() const { return derived().nestedExpression(); } typename ei_cleantype::type& matrix() diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h index 8bfda6595..08d404f87 100644 --- a/Eigen/src/Core/MatrixBase.h +++ b/Eigen/src/Core/MatrixBase.h @@ -61,6 +61,8 @@ template class MatrixBase #ifndef EIGEN_PARSED_BY_DOXYGEN /** The base class for a given storage type. */ typedef MatrixBase StorageBaseType; + /** Construct the base class type for the derived class OtherDerived */ + template struct MakeBase { typedef MatrixBase Type; }; using ei_special_scalar_op_base::Scalar, typename NumTraits::Scalar>::Real>::operator*; @@ -246,8 +248,10 @@ template class MatrixBase #endif // not EIGEN_PARSED_BY_DOXYGEN #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase - #include "CwiseUnaryOps.h" - #include "CwiseBinaryOps.h" + #include "../plugins/CommonCwiseUnaryOps.h" + #include "../plugins/MatrixCwiseUnaryOps.h" + #include "../plugins/CommonCwiseBinaryOps.h" + #include "../plugins/MatrixCwiseBinaryOps.h" #undef EIGEN_CURRENT_STORAGE_BASE_CLASS /** Copies \a other into *this. \returns a reference to *this. */ diff --git a/Eigen/src/plugins/CommonCwiseBinaryOps.h b/Eigen/src/plugins/CommonCwiseBinaryOps.h new file mode 100644 index 000000000..42e308868 --- /dev/null +++ b/Eigen/src/plugins/CommonCwiseBinaryOps.h @@ -0,0 +1,73 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, 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 of +// the License, 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 Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . + +// This file is a base class plugin containing common coefficient wise functions. + +/** \returns an expression of the difference of \c *this and \a other + * + * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-(). + * + * \sa class CwiseBinaryOp, MatrixBase::operator-=() + */ +template +EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, + Derived, OtherDerived> +operator-(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const +{ + return CwiseBinaryOp, + Derived, OtherDerived>(derived(), other.derived()); +} + +/** \returns an expression of the sum of \c *this and \a other + * + * \note If you want to add a given scalar to all coefficients, see Cwise::operator+(). + * + * \sa class CwiseBinaryOp, MatrixBase::operator+=() + */ +template +EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, Derived, OtherDerived> +operator+(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const +{ + return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); +} + +/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other + * + * The template parameter \a CustomBinaryOp is the type of the functor + * of the custom operator (see class CwiseBinaryOp for an example) + * + * Here is an example illustrating the use of custom functors: + * \include class_CwiseBinaryOp.cpp + * Output: \verbinclude class_CwiseBinaryOp.out + * + * \sa class CwiseBinaryOp, MatrixBase::operator+, MatrixBase::operator-, MatrixBase::cwiseProduct + */ +template +EIGEN_STRONG_INLINE const CwiseBinaryOp +binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other, const CustomBinaryOp& func = CustomBinaryOp()) const +{ + return CwiseBinaryOp(derived(), other.derived(), func); +} + diff --git a/Eigen/src/Core/CwiseUnaryOps.h b/Eigen/src/plugins/CommonCwiseUnaryOps.h similarity index 75% rename from Eigen/src/Core/CwiseUnaryOps.h rename to Eigen/src/plugins/CommonCwiseUnaryOps.h index a7acd0036..4d3943367 100644 --- a/Eigen/src/Core/CwiseUnaryOps.h +++ b/Eigen/src/plugins/CommonCwiseUnaryOps.h @@ -1,3 +1,29 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, 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 of +// the License, 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 Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . + +// This file is a base class plugin containing common coefficient wise functions. #ifndef EIGEN_PARSED_BY_DOXYGEN @@ -163,59 +189,3 @@ real() { return derived(); } * \sa real() */ EIGEN_STRONG_INLINE NonConstImagReturnType imag() { return derived(); } - -/** \returns an expression of the coefficient-wise absolute value of \c *this - * - * Example: \include MatrixBase_cwiseAbs.cpp - * Output: \verbinclude MatrixBase_cwiseAbs.out - * - * \sa cwiseAbs2() - */ -EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> -cwiseAbs() const { return derived(); } - -/** \returns an expression of the coefficient-wise squared absolute value of \c *this - * - * Example: \include MatrixBase_cwiseAbs2.cpp - * Output: \verbinclude MatrixBase_cwiseAbs2.out - * - * \sa cwiseAbs() - */ -EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> -cwiseAbs2() const { return derived(); } - -/** \returns an expression of the coefficient-wise square root of *this. - * - * Example: \include MatrixBase_cwiseSqrt.cpp - * Output: \verbinclude MatrixBase_cwiseSqrt.out - * - * \sa cwisePow(), cwiseSquare() - */ -inline const CwiseUnaryOp,Derived> -cwiseSqrt() const { return derived(); } - -/** \returns an expression of the coefficient-wise inverse of *this. - * - * Example: \include MatrixBase_cwiseInverse.cpp - * Output: \verbinclude MatrixBase_cwiseInverse.out - * - * \sa cwiseProduct() - */ -inline const CwiseUnaryOp,Derived> -cwiseInverse() const { return derived(); } - -/** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s - * - * \warning this performs an exact comparison, which is generally a bad idea with floating-point types. - * In order to check for equality between two vectors or matrices with floating-point coefficients, it is - * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and - * MatrixBase::isMuchSmallerThan(). - * - * \sa cwiseEqual(const MatrixBase &) const - */ -inline const CwiseUnaryOp >,Derived> -cwiseEqual(Scalar s) const -{ - return CwiseUnaryOp >,Derived> - (derived(), std::bind1st(std::equal_to(), s)); -} diff --git a/Eigen/src/Core/CwiseBinaryOps.h b/Eigen/src/plugins/MatrixCwiseBinaryOps.h similarity index 66% rename from Eigen/src/Core/CwiseBinaryOps.h rename to Eigen/src/plugins/MatrixCwiseBinaryOps.h index 0b7fa2d8b..74b7a5610 100644 --- a/Eigen/src/Core/CwiseBinaryOps.h +++ b/Eigen/src/plugins/MatrixCwiseBinaryOps.h @@ -1,48 +1,29 @@ -/** \returns an expression of the difference of \c *this and \a other - * - * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-(). - * - * \sa class CwiseBinaryOp, MatrixBase::operator-=() - */ -template -EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, - Derived, OtherDerived> -operator-(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const -{ - return CwiseBinaryOp, - Derived, OtherDerived>(derived(), other.derived()); -} +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, 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 of +// the License, 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 Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . -/** \returns an expression of the sum of \c *this and \a other - * - * \note If you want to add a given scalar to all coefficients, see Cwise::operator+(). - * - * \sa class CwiseBinaryOp, MatrixBase::operator+=() - */ -template -EIGEN_STRONG_INLINE const CwiseBinaryOp::Scalar>, Derived, OtherDerived> -operator+(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other) const -{ - return CwiseBinaryOp, Derived, OtherDerived>(derived(), other.derived()); -} - -/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other - * - * The template parameter \a CustomBinaryOp is the type of the functor - * of the custom operator (see class CwiseBinaryOp for an example) - * - * Here is an example illustrating the use of custom functors: - * \include class_CwiseBinaryOp.cpp - * Output: \verbinclude class_CwiseBinaryOp.out - * - * \sa class CwiseBinaryOp, MatrixBase::operator+, MatrixBase::operator-, MatrixBase::cwiseProduct - */ -template -EIGEN_STRONG_INLINE const CwiseBinaryOp -binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other, const CustomBinaryOp& func = CustomBinaryOp()) const -{ - return CwiseBinaryOp(derived(), other.derived(), func); -} +// This file is a base class plugin containing matrix specifics coefficient wise functions. /** \returns an expression of the Schur product (coefficient wise product) of *this and \a other * diff --git a/Eigen/src/plugins/MatrixCwiseUnaryOps.h b/Eigen/src/plugins/MatrixCwiseUnaryOps.h new file mode 100644 index 000000000..d75e229fb --- /dev/null +++ b/Eigen/src/plugins/MatrixCwiseUnaryOps.h @@ -0,0 +1,82 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2008-2009 Gael Guennebaud +// Copyright (C) 2006-2008 Benoit Jacob +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, 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 of +// the License, 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 Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . + +// This file is a base class plugin containing matrix specifics coefficient wise functions. + +/** \returns an expression of the coefficient-wise absolute value of \c *this + * + * Example: \include MatrixBase_cwiseAbs.cpp + * Output: \verbinclude MatrixBase_cwiseAbs.out + * + * \sa cwiseAbs2() + */ +EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> +cwiseAbs() const { return derived(); } + +/** \returns an expression of the coefficient-wise squared absolute value of \c *this + * + * Example: \include MatrixBase_cwiseAbs2.cpp + * Output: \verbinclude MatrixBase_cwiseAbs2.out + * + * \sa cwiseAbs() + */ +EIGEN_STRONG_INLINE const CwiseUnaryOp,Derived> +cwiseAbs2() const { return derived(); } + +/** \returns an expression of the coefficient-wise square root of *this. + * + * Example: \include MatrixBase_cwiseSqrt.cpp + * Output: \verbinclude MatrixBase_cwiseSqrt.out + * + * \sa cwisePow(), cwiseSquare() + */ +inline const CwiseUnaryOp,Derived> +cwiseSqrt() const { return derived(); } + +/** \returns an expression of the coefficient-wise inverse of *this. + * + * Example: \include MatrixBase_cwiseInverse.cpp + * Output: \verbinclude MatrixBase_cwiseInverse.out + * + * \sa cwiseProduct() + */ +inline const CwiseUnaryOp,Derived> +cwiseInverse() const { return derived(); } + +/** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s + * + * \warning this performs an exact comparison, which is generally a bad idea with floating-point types. + * In order to check for equality between two vectors or matrices with floating-point coefficients, it is + * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and + * MatrixBase::isMuchSmallerThan(). + * + * \sa cwiseEqual(const MatrixBase &) const + */ +inline const CwiseUnaryOp >,Derived> +cwiseEqual(Scalar s) const +{ + return CwiseUnaryOp >,Derived> + (derived(), std::bind1st(std::equal_to(), s)); +}