GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-07-22 04:44:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

add a DenseBase class for MAtrixBase and ArrayBase and more code factorisation

Browse Source
This commit is contained in:
Gael Guennebaud 2009-12-04 23:17:14 +01:00
parent 80ebeae48d
commit 8e05f9cfa1
47 changed files with 1578 additions and 944 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Eigen/Array
View File

@ -36,6 +36,9 @@ namespace Eigen {
#include "src/Array/Norms.h" #include "src/Array/Norms.h"
#include "src/Array/Replicate.h" #include "src/Array/Replicate.h"
#include "src/Array/Reverse.h" #include "src/Array/Reverse.h"
#include "src/Array/ArrayBase.h"
#include "src/Array/ArrayWrapper.h"
#include "src/Array/Array.h"
} // namespace Eigen } // namespace Eigen

1
Eigen/Core
View File

@ -152,6 +152,7 @@ struct Dense {};
#endif #endif
#include "src/Core/Functors.h" #include "src/Core/Functors.h"
#include "src/Core/DenseBase.h"
#include "src/Core/MatrixBase.h" #include "src/Core/MatrixBase.h"
#include "src/Core/AnyMatrixBase.h" #include "src/Core/AnyMatrixBase.h"
#include "src/Core/Coeffs.h" #include "src/Core/Coeffs.h"

526
Eigen/src/Array/Array.h
View File

@ -22,528 +22,8 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#ifndef EIGEN_ARRAYBASE_H #ifndef EIGEN_ARRAY_H
#define EIGEN_ARRAYBASE_H #define EIGEN_ARRAY_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<typename Derived> class ArrayBase
#ifndef EIGEN_PARSED_BY_DOXYGEN
: public ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar,
typename NumTraits<typename ei_traits<Derived>::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 <typename OtherDerived> struct MakeBase { typedef ArrayBase<OtherDerived> Type; };
using ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar, #endif // EIGEN_ARRAY_H
typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>::operator*;
class InnerIterator;
typedef typename ei_traits<Derived>::Scalar Scalar;
typedef typename ei_packet_traits<Scalar>::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<Derived>::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<Derived>::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<ei_traits<Derived>::RowsAtCompileTime,
ei_traits<Derived>::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<Derived>::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<Derived>::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<ei_traits<Derived>::MaxRowsAtCompileTime,
ei_traits<Derived>::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<Derived>::RowsAtCompileTime == 1
|| ei_traits<Derived>::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<Derived>::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<Derived>::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<T> then RealScalar is \a T.
*
* \sa class NumTraits
*/
typedef typename NumTraits<Scalar>::Real RealScalar;
/** type of the equivalent square matrix */
typedef Matrix<Scalar,EIGEN_ENUM_MAX(RowsAtCompileTime,ColsAtCompileTime),
EIGEN_ENUM_MAX(RowsAtCompileTime,ColsAtCompileTime)> 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<Derived>::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<Derived>::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<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType;
/** \internal expression tyepe of a column */
typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1> ColXpr;
/** \internal expression tyepe of a column */
typedef Block<Derived, 1, ei_traits<Derived>::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<typename OtherDerived>
Derived& operator=(const ArrayBase<OtherDerived>& 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<typename OtherDerived>
Derived& operator=(const AnyArrayBase<OtherDerived> &other);
template<typename OtherDerived>
Derived& operator+=(const AnyArrayBase<OtherDerived> &other);
template<typename OtherDerived>
Derived& operator-=(const AnyArrayBase<OtherDerived> &other);
template<typename OtherDerived>
Derived& operator=(const ReturnByValue<OtherDerived>& func);
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** Copies \a other into *this without evaluating other. \returns a reference to *this. */
template<typename OtherDerived>
Derived& lazyAssign(const ArrayBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN
CommaInitializer<Derived> operator<< (const Scalar& s);
template<typename OtherDerived>
CommaInitializer<Derived> operator<< (const ArrayBase<OtherDerived>& 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<typename OtherDerived>
void copyCoeff(int row, int col, const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
void copyCoeff(int index, const ArrayBase<OtherDerived>& other);
template<typename OtherDerived, int StoreMode, int LoadMode>
void copyPacket(int row, int col, const ArrayBase<OtherDerived>& other);
template<typename OtherDerived, int StoreMode, int LoadMode>
void copyPacket(int index, const ArrayBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN
template<int LoadMode>
PacketScalar packet(int row, int col) const;
template<int StoreMode>
void writePacket(int row, int col, const PacketScalar& x);
template<int LoadMode>
PacketScalar packet(int index) const;
template<int StoreMode>
void writePacket(int index, const PacketScalar& x);
template<typename OtherDerived>
Derived& operator+=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
Derived& operator-=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
Derived& operator*=(const ArrayBase<OtherDerived>& other);
Eigen::Transpose<Derived> transpose();
const Eigen::Transpose<Derived> transpose() const;
void transposeInPlace();
#ifndef EIGEN_NO_DEBUG
template<typename OtherDerived>
Derived& lazyAssign(const Transpose<OtherDerived>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,Transpose<DerivedA>,DerivedB>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> >& other);
template<typename OtherDerived>
Derived& lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > >& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > >& other);
#endif
RowXpr row(int i);
const RowXpr row(int i) const;
ColXpr col(int i);
const ColXpr col(int i) const;
Minor<Derived> minor(int row, int col);
const Minor<Derived> minor(int row, int col) const;
typename BlockReturnType<Derived>::Type block(int startRow, int startCol, int blockRows, int blockCols);
const typename BlockReturnType<Derived>::Type
block(int startRow, int startCol, int blockRows, int blockCols) const;
VectorBlock<Derived> segment(int start, int size);
const VectorBlock<Derived> segment(int start, int size) const;
VectorBlock<Derived> start(int size);
const VectorBlock<Derived> start(int size) const;
VectorBlock<Derived> end(int size);
const VectorBlock<Derived> end(int size) const;
typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols);
const typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols) const;
template<int BlockRows, int BlockCols>
typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol);
template<int BlockRows, int BlockCols>
const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol) const;
template<int CRows, int CCols>
typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type);
template<int CRows, int CCols>
const typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type) const;
template<int Size> VectorBlock<Derived,Size> start(void);
template<int Size> const VectorBlock<Derived,Size> start() const;
template<int Size> VectorBlock<Derived,Size> end();
template<int Size> const VectorBlock<Derived,Size> end() const;
template<int Size> VectorBlock<Derived,Size> segment(int start);
template<int Size> const VectorBlock<Derived,Size> 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<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
NullaryExpr(int rows, int cols, const CustomNullaryOp& func);
template<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
NullaryExpr(int size, const CustomNullaryOp& func);
template<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
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<typename OtherDerived>
bool isApprox(const ArrayBase<OtherDerived>& other,
RealScalar prec = precision<Scalar>()) const;
bool isMuchSmallerThan(const RealScalar& other,
RealScalar prec = precision<Scalar>()) const;
template<typename OtherDerived>
bool isMuchSmallerThan(const ArrayBase<OtherDerived>& other,
RealScalar prec = precision<Scalar>()) const;
bool isApproxToConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
bool isConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
bool isZero(RealScalar prec = precision<Scalar>()) const;
bool isOnes(RealScalar prec = precision<Scalar>()) const;
bool isIdentity(RealScalar prec = precision<Scalar>()) const;
bool isDiagonal(RealScalar prec = precision<Scalar>()) const;
bool isUpperTriangular(RealScalar prec = precision<Scalar>()) const;
bool isLowerTriangular(RealScalar prec = precision<Scalar>()) const;
template<typename OtherDerived>
bool isOrthogonal(const ArrayBase<OtherDerived>& other,
RealScalar prec = precision<Scalar>()) const;
bool isUnitary(RealScalar prec = precision<Scalar>()) const;
template<typename OtherDerived>
inline bool operator==(const ArrayBase<OtherDerived>& other) const
{ return cwiseEqual(other).all(); }
template<typename OtherDerived>
inline bool operator!=(const ArrayBase<OtherDerived>& 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<Derived>::type eval() const
{ return typename ei_eval<Derived>::type(derived()); }
template<typename OtherDerived>
void swap(ArrayBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other);
NoAlias<Derived,Eigen::ArrayBase > 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<Derived> nestByValue() const;
Scalar sum() const;
Scalar mean() const;
Scalar trace() const;
Scalar prod() const;
typename ei_traits<Derived>::Scalar minCoeff() const;
typename ei_traits<Derived>::Scalar maxCoeff() const;
typename ei_traits<Derived>::Scalar minCoeff(int* row, int* col) const;
typename ei_traits<Derived>::Scalar maxCoeff(int* row, int* col) const;
typename ei_traits<Derived>::Scalar minCoeff(int* index) const;
typename ei_traits<Derived>::Scalar maxCoeff(int* index) const;
template<typename BinaryOp>
typename ei_result_of<BinaryOp(typename ei_traits<Derived>::Scalar)>::type
redux(const BinaryOp& func) const;
template<typename Visitor>
void visit(Visitor& func) const;
#ifndef EIGEN_PARSED_BY_DOXYGEN
using AnyArrayBase<Derived>::derived;
inline Derived& const_cast_derived() const
{ return *static_cast<Derived*>(const_cast<ArrayBase*>(this)); }
#endif // not EIGEN_PARSED_BY_DOXYGEN
inline const WithFormat<Derived> format(const IOFormat& fmt) const;
bool all(void) const;
bool any(void) const;
int count() const;
const VectorwiseOp<Derived,Horizontal> rowwise() const;
VectorwiseOp<Derived,Horizontal> rowwise();
const VectorwiseOp<Derived,Vertical> colwise() const;
VectorwiseOp<Derived,Vertical> colwise();
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int rows, int cols);
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int size);
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random();
template<typename ThenDerived,typename ElseDerived>
const Select<Derived,ThenDerived,ElseDerived>
select(const ArrayBase<ThenDerived>& thenMatrix,
const ArrayBase<ElseDerived>& elseMatrix) const;
template<typename ThenDerived>
inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
select(const ArrayBase<ThenDerived>& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
template<typename ElseDerived>
inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
select(typename ElseDerived::Scalar thenScalar, const ArrayBase<ElseDerived>& elseMatrix) const;
template<int RowFactor, int ColFactor>
const Replicate<Derived,RowFactor,ColFactor> replicate() const;
const Replicate<Derived,Dynamic,Dynamic> replicate(int rowFacor,int colFactor) const;
Eigen::Reverse<Derived, BothDirections> reverse();
const Eigen::Reverse<Derived, BothDirections> 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<Flags>::ret,
INVALID_MATRIXBASE_TEMPLATE_PARAMETERS)
#endif
}
private:
explicit ArrayBase(int);
ArrayBase(int,int);
template<typename OtherDerived> explicit ArrayBase(const ArrayBase<OtherDerived>&);
};
#endif // EIGEN_ARRAYBASE_H

233
Eigen/src/Array/ArrayBase.h Normal file
View File

@ -0,0 +1,233 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
//
// 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 <http://www.gnu.org/licenses/>.
#ifndef EIGEN_ARRAYBASE_H
#define EIGEN_ARRAYBASE_H
template<typename ExpressionType> class MatrixWrapper;
/** \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<typename Derived> class ArrayBase
: public DenseBase<Derived>
{
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 <typename OtherDerived> struct MakeBase { typedef ArrayBase<OtherDerived> Type; };
using ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar,
typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>::operator*;
class InnerIterator;
typedef typename ei_traits<Derived>::Scalar Scalar;
typedef typename ei_packet_traits<Scalar>::type PacketScalar;
typedef DenseBase<Derived> Base;
using Base::RowsAtCompileTime;
using Base::ColsAtCompileTime;
using Base::SizeAtCompileTime;
using Base::MaxRowsAtCompileTime;
using Base::MaxColsAtCompileTime;
using Base::MaxSizeAtCompileTime;
using Base::IsVectorAtCompileTime;
using Base::Flags;
using Base::CoeffReadCost;
using Base::_HasDirectAccess;
using Base::rows;
using Base::cols;
using Base::size;
using Base::coeff;
using Base::coeffRef;
// using Base::;
// using Base::;
typedef typename Base::RealScalar RealScalar;
typedef typename Base::CoeffReturnType CoeffReturnType;
// typedef typename Base::ColXpr ColXpr;
// typedef typename Base::RowXpr RowXpr;
// typedef typename Base::;
#endif // not EIGEN_PARSED_BY_DOXYGEN
#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<Derived>::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<Derived>::type PlainMatrixType_ColMajor;
/** \internal Represents a matrix with all coefficients equal to one another*/
typedef CwiseNullaryOp<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType;
#endif // not EIGEN_PARSED_BY_DOXYGEN
#ifndef EIGEN_PARSED_BY_DOXYGEN
using AnyMatrixBase<Derived>::derived;
inline Derived& const_cast_derived() const
{ return *static_cast<Derived*>(const_cast<ArrayBase*>(this)); }
#endif // not EIGEN_PARSED_BY_DOXYGEN
#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::ArrayBase
# include "../plugins/CommonCwiseUnaryOps.h"
# include "../plugins/MatrixCwiseUnaryOps.h"
# include "../plugins/ArrayCwiseUnaryOps.h"
# include "../plugins/CommonCwiseBinaryOps.h"
# include "../plugins/ArrayCwiseBinaryOps.h"
#undef EIGEN_CURRENT_STORAGE_BASE_CLASS
/** Copies \a other into *this. \returns a reference to *this. */
// template<typename OtherDerived>
// Derived& operator=(const ArrayBase<OtherDerived>& 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)
{
return ei_assign_selector<Derived,Derived>::run(derived(), other.derived());
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** Copies \a other into *this without evaluating other. \returns a reference to *this. */
// template<typename OtherDerived>
// Derived& lazyAssign(const ArrayBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN
template<typename OtherDerived>
Derived& operator+=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
Derived& operator-=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
Derived& operator*=(const ArrayBase<OtherDerived>& other);
template<typename OtherDerived>
inline bool operator==(const ArrayBase<OtherDerived>& other) const
{ return cwiseEqual(other).all(); }
template<typename OtherDerived>
inline bool operator!=(const ArrayBase<OtherDerived>& 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<Derived>::type eval() const
// { return typename ei_eval<Derived>::type(derived()); }
// template<typename OtherDerived>
// void swap(ArrayBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other);
// const VectorwiseOp<Derived,Horizontal> rowwise() const;
// VectorwiseOp<Derived,Horizontal> rowwise();
// const VectorwiseOp<Derived,Vertical> colwise() const;
// VectorwiseOp<Derived,Vertical> colwise();
// template<typename ThenDerived,typename ElseDerived>
// const Select<Derived,ThenDerived,ElseDerived>
// select(const ArrayBase<ThenDerived>& thenMatrix,
// const ArrayBase<ElseDerived>& elseMatrix) const;
// template<typename ThenDerived>
// inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
// select(const ArrayBase<ThenDerived>& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
// template<typename ElseDerived>
// inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
// select(typename ElseDerived::Scalar thenScalar, const ArrayBase<ElseDerived>& elseMatrix) const;
// template<int RowFactor, int ColFactor>
// const Replicate<Derived,RowFactor,ColFactor> replicate() const;
// const Replicate<Derived,Dynamic,Dynamic> replicate(int rowFacor,int colFactor) const;
// Eigen::Reverse<Derived, BothDirections> reverse();
// const Eigen::Reverse<Derived, BothDirections> reverse() const;
// void reverseInPlace();
#ifdef EIGEN_ARRAYBASE_PLUGIN
#include EIGEN_ARRAYBASE_PLUGIN
#endif
public:
MatrixWrapper<Derived> asMatrix() { return derived(); }
const MatrixWrapper<Derived> asMatrix() const { return derived(); }
template<typename Dest>
inline void evalTo(Dest& dst) const { dst = asMatrix(); }
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<Flags>::ret,
INVALID_MATRIXBASE_TEMPLATE_PARAMETERS)
#endif
}
private:
explicit ArrayBase(int);
ArrayBase(int,int);
template<typename OtherDerived> explicit ArrayBase(const ArrayBase<OtherDerived>&);
};
#endif // EIGEN_ARRAYBASE_H

161
Eigen/src/Array/ArrayWrapper.h Normal file
View File

@ -0,0 +1,161 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
//
// 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 <http://www.gnu.org/licenses/>.
#ifndef EIGEN_ARRAYWRAPPER_H
#define EIGEN_ARRAYWRAPPER_H
template<typename ExpressionType>
struct ei_traits<ArrayWrapper<ExpressionType> >
: public ei_traits<ExpressionType>
{};
template<typename ExpressionType>
class ArrayWrapper : public ArrayBase<ArrayWrapper<ExpressionType> >
{
public:
EIGEN_GENERIC_PUBLIC_INTERFACE(ArrayWrapper)
inline ArrayWrapper(const ExpressionType& matrix) : m_expression(matrix) {}
inline int rows() const { return m_expression.rows(); }
inline int cols() const { return m_expression.cols(); }
inline int stride() const { return m_expression.stride(); }
inline const CoeffReturnType coeff(int row, int col) const
{
return m_expression.coeff(row, col);
}
inline Scalar& coeffRef(int row, int col)
{
return m_expression.const_cast_derived().coeffRef(row, col);
}
inline const CoeffReturnType coeff(int index) const
{
return m_expression.coeff(index);
}
inline Scalar& coeffRef(int index)
{
return m_expression.const_cast_derived().coeffRef(index);
}
template<int LoadMode>
inline const PacketScalar packet(int row, int col) const
{
return m_expression.template packet<LoadMode>(row, col);
}
template<int LoadMode>
inline void writePacket(int row, int col, const PacketScalar& x)
{
m_expression.const_cast_derived().template writePacket<LoadMode>(row, col, x);
}
template<int LoadMode>
inline const PacketScalar packet(int index) const
{
return m_expression.template packet<LoadMode>(index);
}
template<int LoadMode>
inline void writePacket(int index, const PacketScalar& x)
{
m_expression.const_cast_derived().template writePacket<LoadMode>(index, x);
}
template<typename Dest>
inline void evalTo(Dest& dst) const { dst = m_expression; }
protected:
const ExpressionType& m_expression;
};
template<typename ExpressionType>
struct ei_traits<MatrixWrapper<ExpressionType> >
: public ei_traits<ExpressionType>
{};
template<typename ExpressionType>
class MatrixWrapper : public MatrixBase<MatrixWrapper<ExpressionType> >
{
public:
EIGEN_GENERIC_PUBLIC_INTERFACE(MatrixWrapper)
inline MatrixWrapper(const ExpressionType& matrix) : m_expression(matrix) {}
inline int rows() const { return m_expression.rows(); }
inline int cols() const { return m_expression.cols(); }
inline int stride() const { return m_expression.stride(); }
inline const CoeffReturnType coeff(int row, int col) const
{
return m_expression.coeff(row, col);
}
inline Scalar& coeffRef(int row, int col)
{
return m_expression.const_cast_derived().coeffRef(row, col);
}
inline const CoeffReturnType coeff(int index) const
{
return m_expression.coeff(index);
}
inline Scalar& coeffRef(int index)
{
return m_expression.const_cast_derived().coeffRef(index);
}
template<int LoadMode>
inline const PacketScalar packet(int row, int col) const
{
return m_expression.template packet<LoadMode>(row, col);
}
template<int LoadMode>
inline void writePacket(int row, int col, const PacketScalar& x)
{
m_expression.const_cast_derived().template writePacket<LoadMode>(row, col, x);
}
template<int LoadMode>
inline const PacketScalar packet(int index) const
{
return m_expression.template packet<LoadMode>(index);
}
template<int LoadMode>
inline void writePacket(int index, const PacketScalar& x)
{
m_expression.const_cast_derived().template writePacket<LoadMode>(index, x);
}
protected:
const ExpressionType& m_expression;
};
#endif // EIGEN_ARRAYWRAPPER_H

14
Eigen/src/Array/BooleanRedux.h
View File

@ -84,10 +84,10 @@ struct ei_any_unroller<Derived, Dynamic>
* Example: \include MatrixBase_all.cpp * Example: \include MatrixBase_all.cpp
* Output: \verbinclude MatrixBase_all.out * Output: \verbinclude MatrixBase_all.out
* *
* \sa MatrixBase::any(), Cwise::operator<() * \sa any(), Cwise::operator<()
*/ */
template<typename Derived> template<typename Derived>
inline bool MatrixBase<Derived>::all() const inline bool DenseBase<Derived>::all() const
{ {
const bool unroll = SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost) const bool unroll = SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost)
<= EIGEN_UNROLLING_LIMIT; <= EIGEN_UNROLLING_LIMIT;
@ -108,10 +108,10 @@ inline bool MatrixBase<Derived>::all() const
* *
* \returns true if at least one coefficient is true * \returns true if at least one coefficient is true
* *
* \sa MatrixBase::all() * \sa all()
*/ */
template<typename Derived> template<typename Derived>
inline bool MatrixBase<Derived>::any() const inline bool DenseBase<Derived>::any() const
{ {
const bool unroll = SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost) const bool unroll = SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost)
<= EIGEN_UNROLLING_LIMIT; <= EIGEN_UNROLLING_LIMIT;
@ -132,12 +132,12 @@ inline bool MatrixBase<Derived>::any() const
* *
* \returns the number of coefficients which evaluate to true * \returns the number of coefficients which evaluate to true
* *
* \sa MatrixBase::all(), MatrixBase::any() * \sa all(), any()
*/ */
template<typename Derived> template<typename Derived>
inline int MatrixBase<Derived>::count() const inline int DenseBase<Derived>::count() const
{ {
return this->cast<bool>().cast<int>().sum(); return derived().template cast<bool>().template cast<int>().sum();
} }
#endif // EIGEN_ALLANDANY_H #endif // EIGEN_ALLANDANY_H

8
Eigen/src/Array/Random.h
View File

@ -55,7 +55,7 @@ struct ei_functor_traits<ei_scalar_random_op<Scalar> >
*/ */
template<typename Derived> template<typename Derived>
inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived> inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived>
MatrixBase<Derived>::Random(int rows, int cols) DenseBase<Derived>::Random(int rows, int cols)
{ {
return NullaryExpr(rows, cols, ei_scalar_random_op<Scalar>()); return NullaryExpr(rows, cols, ei_scalar_random_op<Scalar>());
} }
@ -84,7 +84,7 @@ MatrixBase<Derived>::Random(int rows, int cols)
*/ */
template<typename Derived> template<typename Derived>
inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived> inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived>
MatrixBase<Derived>::Random(int size) DenseBase<Derived>::Random(int size)
{ {
return NullaryExpr(size, ei_scalar_random_op<Scalar>()); return NullaryExpr(size, ei_scalar_random_op<Scalar>());
} }
@ -107,7 +107,7 @@ MatrixBase<Derived>::Random(int size)
*/ */
template<typename Derived> template<typename Derived>
inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived> inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived>
MatrixBase<Derived>::Random() DenseBase<Derived>::Random()
{ {
return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_random_op<Scalar>()); return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_random_op<Scalar>());
} }
@ -122,7 +122,7 @@ MatrixBase<Derived>::Random()
* \sa class CwiseNullaryOp, setRandom(int), setRandom(int,int) * \sa class CwiseNullaryOp, setRandom(int), setRandom(int,int)
*/ */
template<typename Derived> template<typename Derived>
inline Derived& MatrixBase<Derived>::setRandom() inline Derived& DenseBase<Derived>::setRandom()
{ {
return *this = Random(rows(), cols()); return *this = Random(rows(), cols());
} }

15
Eigen/src/Core/Assign.h
View File

@ -414,13 +414,13 @@ struct ei_assign_impl<Derived1, Derived2, SliceVectorization, NoUnrolling>
}; };
/*************************************************************************** /***************************************************************************
* Part 4 : implementation of MatrixBase methods * Part 4 : implementation of DenseBase methods
***************************************************************************/ ***************************************************************************/
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived> EIGEN_STRONG_INLINE Derived& DenseBase<Derived>
::lazyAssign(const MatrixBase<OtherDerived>& other) ::lazyAssign(const DenseBase<OtherDerived>& other)
{ {
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived) EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
EIGEN_STATIC_ASSERT((ei_is_same_type<typename Derived::Scalar, typename OtherDerived::Scalar>::ret), EIGEN_STATIC_ASSERT((ei_is_same_type<typename Derived::Scalar, typename OtherDerived::Scalar>::ret),
@ -463,16 +463,21 @@ struct ei_assign_selector<Derived,OtherDerived,true,true> {
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase<OtherDerived>& other) EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase<OtherDerived>& other)
{ {
return ei_assign_selector<Derived,OtherDerived>::run(derived(), other.derived()); return ei_assign_selector<Derived,OtherDerived>::run(derived(), other.derived());
} }
template<typename Derived>
EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::operator=(const DenseBase& other)
{
return ei_assign_selector<Derived,Derived>::run(derived(), other.derived());
}
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase& other) EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::operator=(const MatrixBase& other)
{ {
return ei_assign_selector<Derived,Derived>::run(derived(), other.derived()); return ei_assign_selector<Derived,Derived>::run(derived(), other.derived());
} }
#endif // EIGEN_ASSIGN_H #endif // EIGEN_ASSIGN_H

44
Eigen/src/Core/Block.h
View File

@ -36,7 +36,7 @@
* \param _DirectAccessStatus \internal used for partial specialization * \param _DirectAccessStatus \internal used for partial specialization
* *
* This class represents an expression of either a fixed-size or dynamic-size block. It is the return * This class represents an expression of either a fixed-size or dynamic-size block. It is the return
* type of MatrixBase::block(int,int,int,int) and MatrixBase::block<int,int>(int,int) and * type of DenseBase::block(int,int,int,int) and DenseBase::block<int,int>(int,int) and
* most of the time this is the only way it is used. * most of the time this is the only way it is used.
* *
* However, if you want to directly maniputate block expressions, * However, if you want to directly maniputate block expressions,
@ -55,7 +55,7 @@
* \include class_FixedBlock.cpp * \include class_FixedBlock.cpp
* Output: \verbinclude class_FixedBlock.out * Output: \verbinclude class_FixedBlock.out
* *
* \sa MatrixBase::block(int,int,int,int), MatrixBase::block(int,int), class VectorBlock * \sa DenseBase::block(int,int,int,int), DenseBase::block(int,int), class VectorBlock
*/ */
template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessStatus> template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessStatus>
struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> > struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> >
@ -83,7 +83,7 @@ struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> >
}; };
template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessStatus> class Block template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessStatus> class Block
: public MatrixBase<Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> > :public MatrixType::template MakeBase< Block<MatrixType, BlockRows, BlockCols, _DirectAccessStatus> >::Type
{ {
public: public:
@ -213,11 +213,13 @@ template<typename MatrixType, int BlockRows, int BlockCols, int _DirectAccessSta
/** \internal */ /** \internal */
template<typename MatrixType, int BlockRows, int BlockCols> template<typename MatrixType, int BlockRows, int BlockCols>
class Block<MatrixType,BlockRows,BlockCols,HasDirectAccess> class Block<MatrixType,BlockRows,BlockCols,HasDirectAccess>
: public MapBase<Block<MatrixType, BlockRows, BlockCols,HasDirectAccess> > : public MapBase<Block<MatrixType, BlockRows, BlockCols,HasDirectAccess>,
typename MatrixType::template MakeBase< Block<MatrixType, BlockRows, BlockCols,HasDirectAccess> >::Type>
{ {
public: public:
_EIGEN_GENERIC_PUBLIC_INTERFACE(Block, MapBase<Block>) typedef MapBase<Block, typename MatrixType::template MakeBase<Block>::Type> Base;
_EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block) EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
@ -301,7 +303,7 @@ class Block<MatrixType,BlockRows,BlockCols,HasDirectAccess>
* \sa class Block, block(int,int) * \sa class Block, block(int,int)
*/ */
template<typename Derived> template<typename Derived>
inline typename BlockReturnType<Derived>::Type MatrixBase<Derived> inline typename BlockReturnType<Derived>::Type DenseBase<Derived>
::block(int startRow, int startCol, int blockRows, int blockCols) ::block(int startRow, int startCol, int blockRows, int blockCols)
{ {
return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols); return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
@ -309,7 +311,7 @@ inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
/** This is the const version of block(int,int,int,int). */ /** This is the const version of block(int,int,int,int). */
template<typename Derived> template<typename Derived>
inline const typename BlockReturnType<Derived>::Type MatrixBase<Derived> inline const typename BlockReturnType<Derived>::Type DenseBase<Derived>
::block(int startRow, int startCol, int blockRows, int blockCols) const ::block(int startRow, int startCol, int blockRows, int blockCols) const
{ {
return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols); return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
@ -332,7 +334,7 @@ inline const typename BlockReturnType<Derived>::Type MatrixBase<Derived>
* \sa class Block, block(int,int,int,int) * \sa class Block, block(int,int,int,int)
*/ */
template<typename Derived> template<typename Derived>
inline typename BlockReturnType<Derived>::Type MatrixBase<Derived> inline typename BlockReturnType<Derived>::Type DenseBase<Derived>
::corner(CornerType type, int cRows, int cCols) ::corner(CornerType type, int cRows, int cCols)
{ {
switch(type) switch(type)
@ -353,7 +355,7 @@ inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
/** This is the const version of corner(CornerType, int, int).*/ /** This is the const version of corner(CornerType, int, int).*/
template<typename Derived> template<typename Derived>
inline const typename BlockReturnType<Derived>::Type inline const typename BlockReturnType<Derived>::Type
MatrixBase<Derived>::corner(CornerType type, int cRows, int cCols) const DenseBase<Derived>::corner(CornerType type, int cRows, int cCols) const
{ {
switch(type) switch(type)
{ {
@ -385,7 +387,7 @@ MatrixBase<Derived>::corner(CornerType type, int cRows, int cCols) const
template<typename Derived> template<typename Derived>
template<int CRows, int CCols> template<int CRows, int CCols>
inline typename BlockReturnType<Derived, CRows, CCols>::Type inline typename BlockReturnType<Derived, CRows, CCols>::Type
MatrixBase<Derived>::corner(CornerType type) DenseBase<Derived>::corner(CornerType type)
{ {
switch(type) switch(type)
{ {
@ -406,7 +408,7 @@ MatrixBase<Derived>::corner(CornerType type)
template<typename Derived> template<typename Derived>
template<int CRows, int CCols> template<int CRows, int CCols>
inline const typename BlockReturnType<Derived, CRows, CCols>::Type inline const typename BlockReturnType<Derived, CRows, CCols>::Type
MatrixBase<Derived>::corner(CornerType type) const DenseBase<Derived>::corner(CornerType type) const
{ {
switch(type) switch(type)
{ {
@ -442,7 +444,7 @@ MatrixBase<Derived>::corner(CornerType type) const
template<typename Derived> template<typename Derived>
template<int BlockRows, int BlockCols> template<int BlockRows, int BlockCols>
inline typename BlockReturnType<Derived, BlockRows, BlockCols>::Type inline typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
MatrixBase<Derived>::block(int startRow, int startCol) DenseBase<Derived>::block(int startRow, int startCol)
{ {
return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
} }
@ -451,7 +453,7 @@ MatrixBase<Derived>::block(int startRow, int startCol)
template<typename Derived> template<typename Derived>
template<int BlockRows, int BlockCols> template<int BlockRows, int BlockCols>
inline const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type inline const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
MatrixBase<Derived>::block(int startRow, int startCol) const DenseBase<Derived>::block(int startRow, int startCol) const
{ {
return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol); return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
} }
@ -463,16 +465,16 @@ MatrixBase<Derived>::block(int startRow, int startCol) const
* *
* \sa row(), class Block */ * \sa row(), class Block */
template<typename Derived> template<typename Derived>
inline typename MatrixBase<Derived>::ColXpr inline typename DenseBase<Derived>::ColXpr
MatrixBase<Derived>::col(int i) DenseBase<Derived>::col(int i)
{ {
return ColXpr(derived(), i); return ColXpr(derived(), i);
} }
/** This is the const version of col(). */ /** This is the const version of col(). */
template<typename Derived> template<typename Derived>
inline const typename MatrixBase<Derived>::ColXpr inline const typename DenseBase<Derived>::ColXpr
MatrixBase<Derived>::col(int i) const DenseBase<Derived>::col(int i) const
{ {
return ColXpr(derived(), i); return ColXpr(derived(), i);
} }
@ -484,16 +486,16 @@ MatrixBase<Derived>::col(int i) const
* *
* \sa col(), class Block */ * \sa col(), class Block */
template<typename Derived> template<typename Derived>
inline typename MatrixBase<Derived>::RowXpr inline typename DenseBase<Derived>::RowXpr
MatrixBase<Derived>::row(int i) DenseBase<Derived>::row(int i)
{ {
return RowXpr(derived(), i); return RowXpr(derived(), i);
} }
/** This is the const version of row(). */ /** This is the const version of row(). */
template<typename Derived> template<typename Derived>
inline const typename MatrixBase<Derived>::RowXpr inline const typename DenseBase<Derived>::RowXpr
MatrixBase<Derived>::row(int i) const DenseBase<Derived>::row(int i) const
{ {
return RowXpr(derived(), i); return RowXpr(derived(), i);
} }

36
Eigen/src/Core/Coeffs.h
View File

@ -40,7 +40,7 @@
* \sa operator()(int,int) const, coeffRef(int,int), coeff(int) const * \sa operator()(int,int) const, coeffRef(int,int), coeff(int) const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBase<Derived> EIGEN_STRONG_INLINE const typename DenseBase<Derived>::CoeffReturnType DenseBase<Derived>
::coeff(int row, int col) const ::coeff(int row, int col) const
{ {
ei_internal_assert(row >= 0 && row < rows() ei_internal_assert(row >= 0 && row < rows()
@ -53,7 +53,7 @@ EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBa
* \sa operator()(int,int), operator[](int) const * \sa operator()(int,int), operator[](int) const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBase<Derived> EIGEN_STRONG_INLINE const typename DenseBase<Derived>::CoeffReturnType DenseBase<Derived>
::operator()(int row, int col) const ::operator()(int row, int col) const
{ {
ei_assert(row >= 0 && row < rows() ei_assert(row >= 0 && row < rows()
@ -76,7 +76,7 @@ EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBa
* \sa operator()(int,int), coeff(int, int) const, coeffRef(int) * \sa operator()(int,int), coeff(int, int) const, coeffRef(int)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived> EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& DenseBase<Derived>
::coeffRef(int row, int col) ::coeffRef(int row, int col)
{ {
ei_internal_assert(row >= 0 && row < rows() ei_internal_assert(row >= 0 && row < rows()
@ -89,7 +89,7 @@ EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
* \sa operator()(int,int) const, operator[](int) * \sa operator()(int,int) const, operator[](int)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived> EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& DenseBase<Derived>
::operator()(int row, int col) ::operator()(int row, int col)
{ {
ei_assert(row >= 0 && row < rows() ei_assert(row >= 0 && row < rows()
@ -112,7 +112,7 @@ EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
* \sa operator[](int) const, coeffRef(int), coeff(int,int) const * \sa operator[](int) const, coeffRef(int), coeff(int,int) const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBase<Derived> EIGEN_STRONG_INLINE const typename DenseBase<Derived>::CoeffReturnType DenseBase<Derived>
::coeff(int index) const ::coeff(int index) const
{ {
ei_internal_assert(index >= 0 && index < size()); ei_internal_assert(index >= 0 && index < size());
@ -127,7 +127,7 @@ EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBa
* z() const, w() const * z() const, w() const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBase<Derived> EIGEN_STRONG_INLINE const typename DenseBase<Derived>::CoeffReturnType DenseBase<Derived>
::operator[](int index) const ::operator[](int index) const
{ {
ei_assert(index >= 0 && index < size()); ei_assert(index >= 0 && index < size());
@ -144,7 +144,7 @@ EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBa
* z() const, w() const * z() const, w() const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBase<Derived> EIGEN_STRONG_INLINE const typename DenseBase<Derived>::CoeffReturnType DenseBase<Derived>
::operator()(int index) const ::operator()(int index) const
{ {
ei_assert(index >= 0 && index < size()); ei_assert(index >= 0 && index < size());
@ -166,7 +166,7 @@ EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::CoeffReturnType MatrixBa
* \sa operator[](int), coeff(int) const, coeffRef(int,int) * \sa operator[](int), coeff(int) const, coeffRef(int,int)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived> EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& DenseBase<Derived>
::coeffRef(int index) ::coeffRef(int index)
{ {
ei_internal_assert(index >= 0 && index < size()); ei_internal_assert(index >= 0 && index < size());
@ -180,7 +180,7 @@ EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
* \sa operator[](int) const, operator()(int,int), x(), y(), z(), w() * \sa operator[](int) const, operator()(int,int), x(), y(), z(), w()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived> EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& DenseBase<Derived>
::operator[](int index) ::operator[](int index)
{ {
ei_assert(index >= 0 && index < size()); ei_assert(index >= 0 && index < size());
@ -196,7 +196,7 @@ EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
* \sa operator[](int) const, operator()(int,int), x(), y(), z(), w() * \sa operator[](int) const, operator()(int,int), x(), y(), z(), w()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived> EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& DenseBase<Derived>
::operator()(int index) ::operator()(int index)
{ {
ei_assert(index >= 0 && index < size()); ei_assert(index >= 0 && index < size());
@ -254,7 +254,7 @@ EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
template<typename Derived> template<typename Derived>
template<int LoadMode> template<int LoadMode>
EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type
MatrixBase<Derived>::packet(int row, int col) const DenseBase<Derived>::packet(int row, int col) const
{ {
ei_internal_assert(row >= 0 && row < rows() ei_internal_assert(row >= 0 && row < rows()
&& col >= 0 && col < cols()); && col >= 0 && col < cols());
@ -271,7 +271,7 @@ MatrixBase<Derived>::packet(int row, int col) const
*/ */
template<typename Derived> template<typename Derived>
template<int StoreMode> template<int StoreMode>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket EIGEN_STRONG_INLINE void DenseBase<Derived>::writePacket
(int row, int col, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x) (int row, int col, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x)
{ {
ei_internal_assert(row >= 0 && row < rows() ei_internal_assert(row >= 0 && row < rows()
@ -290,7 +290,7 @@ EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket
template<typename Derived> template<typename Derived>
template<int LoadMode> template<int LoadMode>
EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type
MatrixBase<Derived>::packet(int index) const DenseBase<Derived>::packet(int index) const
{ {
ei_internal_assert(index >= 0 && index < size()); ei_internal_assert(index >= 0 && index < size());
return derived().template packet<LoadMode>(index); return derived().template packet<LoadMode>(index);
@ -306,7 +306,7 @@ MatrixBase<Derived>::packet(int index) const
*/ */
template<typename Derived> template<typename Derived>
template<int StoreMode> template<int StoreMode>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket EIGEN_STRONG_INLINE void DenseBase<Derived>::writePacket
(int index, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x) (int index, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x)
{ {
ei_internal_assert(index >= 0 && index < size()); ei_internal_assert(index >= 0 && index < size());
@ -324,7 +324,7 @@ EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int row, int col, const MatrixBase<OtherDerived>& other) EIGEN_STRONG_INLINE void DenseBase<Derived>::copyCoeff(int row, int col, const DenseBase<OtherDerived>& other)
{ {
ei_internal_assert(row >= 0 && row < rows() ei_internal_assert(row >= 0 && row < rows()
&& col >= 0 && col < cols()); && col >= 0 && col < cols());
@ -340,7 +340,7 @@ EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int row, int col, const
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int index, const MatrixBase<OtherDerived>& other) EIGEN_STRONG_INLINE void DenseBase<Derived>::copyCoeff(int index, const DenseBase<OtherDerived>& other)
{ {
ei_internal_assert(index >= 0 && index < size()); ei_internal_assert(index >= 0 && index < size());
derived().coeffRef(index) = other.derived().coeff(index); derived().coeffRef(index) = other.derived().coeff(index);
@ -355,7 +355,7 @@ EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int index, const MatrixB
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived, int StoreMode, int LoadMode> template<typename OtherDerived, int StoreMode, int LoadMode>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyPacket(int row, int col, const MatrixBase<OtherDerived>& other) EIGEN_STRONG_INLINE void DenseBase<Derived>::copyPacket(int row, int col, const DenseBase<OtherDerived>& other)
{ {
ei_internal_assert(row >= 0 && row < rows() ei_internal_assert(row >= 0 && row < rows()
&& col >= 0 && col < cols()); && col >= 0 && col < cols());
@ -372,7 +372,7 @@ EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyPacket(int row, int col, const
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived, int StoreMode, int LoadMode> template<typename OtherDerived, int StoreMode, int LoadMode>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyPacket(int index, const MatrixBase<OtherDerived>& other) EIGEN_STRONG_INLINE void DenseBase<Derived>::copyPacket(int index, const DenseBase<OtherDerived>& other)
{ {
ei_internal_assert(index >= 0 && index < size()); ei_internal_assert(index >= 0 && index < size());
derived().template writePacket<StoreMode>(index, derived().template writePacket<StoreMode>(index,

8
Eigen/src/Core/CommaInitializer.h
View File

@ -47,7 +47,7 @@ struct CommaInitializer
} }
template<typename OtherDerived> template<typename OtherDerived>
inline CommaInitializer(MatrixType& mat, const MatrixBase<OtherDerived>& other) inline CommaInitializer(MatrixType& mat, const DenseBase<OtherDerived>& other)
: m_matrix(mat), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows()) : m_matrix(mat), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
{ {
m_matrix.block(0, 0, other.rows(), other.cols()) = other; m_matrix.block(0, 0, other.rows(), other.cols()) = other;
@ -73,7 +73,7 @@ struct CommaInitializer
/* inserts a matrix expression in the target matrix */ /* inserts a matrix expression in the target matrix */
template<typename OtherDerived> template<typename OtherDerived>
CommaInitializer& operator,(const MatrixBase<OtherDerived>& other) CommaInitializer& operator,(const DenseBase<OtherDerived>& other)
{ {
if (m_col==m_matrix.cols()) if (m_col==m_matrix.cols())
{ {
@ -133,7 +133,7 @@ private:
* \sa CommaInitializer::finished(), class CommaInitializer * \sa CommaInitializer::finished(), class CommaInitializer
*/ */
template<typename Derived> template<typename Derived>
inline CommaInitializer<Derived> MatrixBase<Derived>::operator<< (const Scalar& s) inline CommaInitializer<Derived> DenseBase<Derived>::operator<< (const Scalar& s)
{ {
return CommaInitializer<Derived>(*static_cast<Derived*>(this), s); return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
} }
@ -142,7 +142,7 @@ inline CommaInitializer<Derived> MatrixBase<Derived>::operator<< (const Scalar&
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
inline CommaInitializer<Derived> inline CommaInitializer<Derived>
MatrixBase<Derived>::operator<<(const MatrixBase<OtherDerived>& other) DenseBase<Derived>::operator<<(const DenseBase<OtherDerived>& other)
{ {
return CommaInitializer<Derived>(*static_cast<Derived *>(this), other); return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
} }

3
Eigen/src/Core/CwiseBinaryOp.h
View File

@ -140,7 +140,8 @@ class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Dense>
public: public:
typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived; typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
EIGEN_DENSE_PUBLIC_INTERFACE( Derived ) typedef typename Lhs::template MakeBase< CwiseBinaryOp<BinaryOp, Lhs, Rhs> >::Type Base;
_EIGEN_DENSE_PUBLIC_INTERFACE( Derived )
EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const
{ {

80
Eigen/src/Core/CwiseNullaryOp.h
View File

@ -38,7 +38,7 @@
* However, if you want to write a function returning such an expression, you * However, if you want to write a function returning such an expression, you
* will need to use this class. * will need to use this class.
* *
* \sa class CwiseUnaryOp, class CwiseBinaryOp, MatrixBase::NullaryExpr() * \sa class CwiseUnaryOp, class CwiseBinaryOp, DenseBase::NullaryExpr()
*/ */
template<typename NullaryOp, typename MatrixType> template<typename NullaryOp, typename MatrixType>
struct ei_traits<CwiseNullaryOp<NullaryOp, MatrixType> > : ei_traits<MatrixType> struct ei_traits<CwiseNullaryOp<NullaryOp, MatrixType> > : ei_traits<MatrixType>
@ -121,7 +121,7 @@ class CwiseNullaryOp : ei_no_assignment_operator,
template<typename Derived> template<typename Derived>
template<typename CustomNullaryOp> template<typename CustomNullaryOp>
EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived> EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived>
MatrixBase<Derived>::NullaryExpr(int rows, int cols, const CustomNullaryOp& func) DenseBase<Derived>::NullaryExpr(int rows, int cols, const CustomNullaryOp& func)
{ {
return CwiseNullaryOp<CustomNullaryOp, Derived>(rows, cols, func); return CwiseNullaryOp<CustomNullaryOp, Derived>(rows, cols, func);
} }
@ -144,7 +144,7 @@ MatrixBase<Derived>::NullaryExpr(int rows, int cols, const CustomNullaryOp& func
template<typename Derived> template<typename Derived>
template<typename CustomNullaryOp> template<typename CustomNullaryOp>
EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived> EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived>
MatrixBase<Derived>::NullaryExpr(int size, const CustomNullaryOp& func) DenseBase<Derived>::NullaryExpr(int size, const CustomNullaryOp& func)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, Derived>(1, size, func); if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, Derived>(1, size, func);
@ -153,7 +153,7 @@ MatrixBase<Derived>::NullaryExpr(int size, const CustomNullaryOp& func)
/** \returns an expression of a matrix defined by a custom functor \a func /** \returns an expression of a matrix defined by a custom functor \a func
* *
* This variant is only for fixed-size MatrixBase types. For dynamic-size types, you * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
* need to use the variants taking size arguments. * need to use the variants taking size arguments.
* *
* The template parameter \a CustomNullaryOp is the type of the functor. * The template parameter \a CustomNullaryOp is the type of the functor.
@ -163,7 +163,7 @@ MatrixBase<Derived>::NullaryExpr(int size, const CustomNullaryOp& func)
template<typename Derived> template<typename Derived>
template<typename CustomNullaryOp> template<typename CustomNullaryOp>
EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived> EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived>
MatrixBase<Derived>::NullaryExpr(const CustomNullaryOp& func) DenseBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
{ {
return CwiseNullaryOp<CustomNullaryOp, Derived>(RowsAtCompileTime, ColsAtCompileTime, func); return CwiseNullaryOp<CustomNullaryOp, Derived>(RowsAtCompileTime, ColsAtCompileTime, func);
} }
@ -171,7 +171,7 @@ MatrixBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
/** \returns an expression of a constant matrix of value \a value /** \returns an expression of a constant matrix of value \a value
* *
* The parameters \a rows and \a cols are the number of rows and of columns of * The parameters \a rows and \a cols are the number of rows and of columns of
* the returned matrix. Must be compatible with this MatrixBase type. * the returned matrix. Must be compatible with this DenseBase type.
* *
* This variant is meant to be used for dynamic-size matrix types. For fixed-size types, * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
* it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
@ -182,8 +182,8 @@ MatrixBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
* \sa class CwiseNullaryOp * \sa class CwiseNullaryOp
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Constant(int rows, int cols, const Scalar& value) DenseBase<Derived>::Constant(int rows, int cols, const Scalar& value)
{ {
return NullaryExpr(rows, cols, ei_scalar_constant_op<Scalar>(value)); return NullaryExpr(rows, cols, ei_scalar_constant_op<Scalar>(value));
} }
@ -191,7 +191,7 @@ MatrixBase<Derived>::Constant(int rows, int cols, const Scalar& value)
/** \returns an expression of a constant matrix of value \a value /** \returns an expression of a constant matrix of value \a value
* *
* The parameter \a size is the size of the returned vector. * The parameter \a size is the size of the returned vector.
* Must be compatible with this MatrixBase type. * Must be compatible with this DenseBase type.
* *
* \only_for_vectors * \only_for_vectors
* *
@ -204,15 +204,15 @@ MatrixBase<Derived>::Constant(int rows, int cols, const Scalar& value)
* \sa class CwiseNullaryOp * \sa class CwiseNullaryOp
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Constant(int size, const Scalar& value) DenseBase<Derived>::Constant(int size, const Scalar& value)
{ {
return NullaryExpr(size, ei_scalar_constant_op<Scalar>(value)); return NullaryExpr(size, ei_scalar_constant_op<Scalar>(value));
} }
/** \returns an expression of a constant matrix of value \a value /** \returns an expression of a constant matrix of value \a value
* *
* This variant is only for fixed-size MatrixBase types. For dynamic-size types, you * This variant is only for fixed-size DenseBase types. For dynamic-size types, you
* need to use the variants taking size arguments. * need to use the variants taking size arguments.
* *
* The template parameter \a CustomNullaryOp is the type of the functor. * The template parameter \a CustomNullaryOp is the type of the functor.
@ -220,8 +220,8 @@ MatrixBase<Derived>::Constant(int size, const Scalar& value)
* \sa class CwiseNullaryOp * \sa class CwiseNullaryOp
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Constant(const Scalar& value) DenseBase<Derived>::Constant(const Scalar& value)
{ {
EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived) EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_constant_op<Scalar>(value)); return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_constant_op<Scalar>(value));
@ -229,12 +229,12 @@ MatrixBase<Derived>::Constant(const Scalar& value)
/** \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */ /** \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
template<typename Derived> template<typename Derived>
bool MatrixBase<Derived>::isApproxToConstant bool DenseBase<Derived>::isApproxToConstant
(const Scalar& value, RealScalar prec) const (const Scalar& value, RealScalar prec) const
{ {
for(int j = 0; j < cols(); ++j) for(int j = 0; j < cols(); ++j)
for(int i = 0; i < rows(); ++i) for(int i = 0; i < rows(); ++i)
if(!ei_isApprox(coeff(i, j), value, prec)) if(!ei_isApprox(this->coeff(i, j), value, prec))
return false; return false;
return true; return true;
} }
@ -243,7 +243,7 @@ bool MatrixBase<Derived>::isApproxToConstant
* *
* \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */ * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
template<typename Derived> template<typename Derived>
bool MatrixBase<Derived>::isConstant bool DenseBase<Derived>::isConstant
(const Scalar& value, RealScalar prec) const (const Scalar& value, RealScalar prec) const
{ {
return isApproxToConstant(value, prec); return isApproxToConstant(value, prec);
@ -254,7 +254,7 @@ bool MatrixBase<Derived>::isConstant
* \sa setConstant(), Constant(), class CwiseNullaryOp * \sa setConstant(), Constant(), class CwiseNullaryOp
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::fill(const Scalar& value) EIGEN_STRONG_INLINE void DenseBase<Derived>::fill(const Scalar& value)
{ {
setConstant(value); setConstant(value);
} }
@ -264,7 +264,7 @@ EIGEN_STRONG_INLINE void MatrixBase<Derived>::fill(const Scalar& value)
* \sa fill(), setConstant(int,const Scalar&), setConstant(int,int,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes() * \sa fill(), setConstant(int,const Scalar&), setConstant(int,int,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setConstant(const Scalar& value) EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setConstant(const Scalar& value)
{ {
return derived() = Constant(rows(), cols(), value); return derived() = Constant(rows(), cols(), value);
} }
@ -322,8 +322,8 @@ Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setConstant(int row
* \sa Zero(), Zero(int) * \sa Zero(), Zero(int)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Zero(int rows, int cols) DenseBase<Derived>::Zero(int rows, int cols)
{ {
return Constant(rows, cols, Scalar(0)); return Constant(rows, cols, Scalar(0));
} }
@ -345,8 +345,8 @@ MatrixBase<Derived>::Zero(int rows, int cols)
* \sa Zero(), Zero(int,int) * \sa Zero(), Zero(int,int)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Zero(int size) DenseBase<Derived>::Zero(int size)
{ {
return Constant(size, Scalar(0)); return Constant(size, Scalar(0));
} }
@ -362,8 +362,8 @@ MatrixBase<Derived>::Zero(int size)
* \sa Zero(int), Zero(int,int) * \sa Zero(int), Zero(int,int)
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Zero() DenseBase<Derived>::Zero()
{ {
return Constant(Scalar(0)); return Constant(Scalar(0));
} }
@ -377,11 +377,11 @@ MatrixBase<Derived>::Zero()
* \sa class CwiseNullaryOp, Zero() * \sa class CwiseNullaryOp, Zero()
*/ */
template<typename Derived> template<typename Derived>
bool MatrixBase<Derived>::isZero(RealScalar prec) const bool DenseBase<Derived>::isZero(RealScalar prec) const
{ {
for(int j = 0; j < cols(); ++j) for(int j = 0; j < cols(); ++j)
for(int i = 0; i < rows(); ++i) for(int i = 0; i < rows(); ++i)
if(!ei_isMuchSmallerThan(coeff(i, j), static_cast<Scalar>(1), prec)) if(!ei_isMuchSmallerThan(this->coeff(i, j), static_cast<Scalar>(1), prec))
return false; return false;
return true; return true;
} }
@ -394,7 +394,7 @@ bool MatrixBase<Derived>::isZero(RealScalar prec) const
* \sa class CwiseNullaryOp, Zero() * \sa class CwiseNullaryOp, Zero()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setZero() EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setZero()
{ {
return setConstant(Scalar(0)); return setConstant(Scalar(0));
} }
@ -406,7 +406,7 @@ EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setZero()
* Example: \include Matrix_setZero_int.cpp * Example: \include Matrix_setZero_int.cpp
* Output: \verbinclude Matrix_setZero_int.out * Output: \verbinclude Matrix_setZero_int.out
* *
* \sa MatrixBase::setZero(), setZero(int,int), class CwiseNullaryOp, MatrixBase::Zero() * \sa DenseBase::setZero(), setZero(int,int), class CwiseNullaryOp, DenseBase::Zero()
*/ */
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
@ -424,7 +424,7 @@ Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setZero(int size)
* Example: \include Matrix_setZero_int_int.cpp * Example: \include Matrix_setZero_int_int.cpp
* Output: \verbinclude Matrix_setZero_int_int.out * Output: \verbinclude Matrix_setZero_int_int.out
* *
* \sa MatrixBase::setZero(), setZero(int), class CwiseNullaryOp, MatrixBase::Zero() * \sa DenseBase::setZero(), setZero(int), class CwiseNullaryOp, DenseBase::Zero()
*/ */
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols> template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>& EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
@ -451,8 +451,8 @@ Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setZero(int rows, i
* \sa Ones(), Ones(int), isOnes(), class Ones * \sa Ones(), Ones(int), isOnes(), class Ones
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Ones(int rows, int cols) DenseBase<Derived>::Ones(int rows, int cols)
{ {
return Constant(rows, cols, Scalar(1)); return Constant(rows, cols, Scalar(1));
} }
@ -474,8 +474,8 @@ MatrixBase<Derived>::Ones(int rows, int cols)
* \sa Ones(), Ones(int,int), isOnes(), class Ones * \sa Ones(), Ones(int,int), isOnes(), class Ones
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Ones(int size) DenseBase<Derived>::Ones(int size)
{ {
return Constant(size, Scalar(1)); return Constant(size, Scalar(1));
} }
@ -491,8 +491,8 @@ MatrixBase<Derived>::Ones(int size)
* \sa Ones(int), Ones(int,int), isOnes(), class Ones * \sa Ones(int), Ones(int,int), isOnes(), class Ones
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstantReturnType
MatrixBase<Derived>::Ones() DenseBase<Derived>::Ones()
{ {
return Constant(Scalar(1)); return Constant(Scalar(1));
} }
@ -506,7 +506,7 @@ MatrixBase<Derived>::Ones()
* \sa class CwiseNullaryOp, Ones() * \sa class CwiseNullaryOp, Ones()
*/ */
template<typename Derived> template<typename Derived>
bool MatrixBase<Derived>::isOnes bool DenseBase<Derived>::isOnes
(RealScalar prec) const (RealScalar prec) const
{ {
return isApproxToConstant(Scalar(1), prec); return isApproxToConstant(Scalar(1), prec);
@ -520,7 +520,7 @@ bool MatrixBase<Derived>::isOnes
* \sa class CwiseNullaryOp, Ones() * \sa class CwiseNullaryOp, Ones()
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setOnes() EIGEN_STRONG_INLINE Derived& DenseBase<Derived>::setOnes()
{ {
return setConstant(Scalar(1)); return setConstant(Scalar(1));
} }
@ -620,12 +620,12 @@ bool MatrixBase<Derived>::isIdentity
{ {
if(i == j) if(i == j)
{ {
if(!ei_isApprox(coeff(i, j), static_cast<Scalar>(1), prec)) if(!ei_isApprox(this->coeff(i, j), static_cast<Scalar>(1), prec))
return false; return false;
} }
else else
{ {
if(!ei_isMuchSmallerThan(coeff(i, j), static_cast<RealScalar>(1), prec)) if(!ei_isMuchSmallerThan(this->coeff(i, j), static_cast<RealScalar>(1), prec))
return false; return false;
} }
} }

3
Eigen/src/Core/CwiseUnaryOp.h
View File

@ -106,7 +106,8 @@ class CwiseUnaryOpImpl<UnaryOp,MatrixType,Dense>
public: public:
typedef CwiseUnaryOp<UnaryOp, MatrixType> Derived; typedef CwiseUnaryOp<UnaryOp, MatrixType> Derived;
EIGEN_DENSE_PUBLIC_INTERFACE( Derived ) typedef typename MatrixType::template MakeBase< CwiseUnaryOp<UnaryOp, MatrixType> >::Type Base;
_EIGEN_DENSE_PUBLIC_INTERFACE( Derived )
EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const
{ {

517
Eigen/src/Core/DenseBase.h Normal file
View File

@ -0,0 +1,517 @@
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2006-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
//
// 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 <http://www.gnu.org/licenses/>.
#ifndef EIGEN_DENSEBASE_H
#define EIGEN_DENSEBASE_H
/** \class DenseBase
*
* \brief Base class for all dense matrices, vectors, and arrays
*
* This class is the base that is inherited by all dense objects (matrix, vector, arrays, and expression
* types). The common Eigen API for dense object is contained in this class.
*
* \param Derived is the derived type, e.g. a matrix type, or an expression, etc.
*/
template<typename Derived> class DenseBase
#ifndef EIGEN_PARSED_BY_DOXYGEN
: public ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar,
typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>
#endif // not EIGEN_PARSED_BY_DOXYGEN
{
public:
#ifndef EIGEN_PARSED_BY_DOXYGEN
using ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar,
typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>::operator*;
class InnerIterator;
typedef typename ei_traits<Derived>::Scalar Scalar;
typedef typename ei_packet_traits<Scalar>::type PacketScalar;
#endif // not EIGEN_PARSED_BY_DOXYGEN
enum {
RowsAtCompileTime = ei_traits<Derived>::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 MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
ColsAtCompileTime = ei_traits<Derived>::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 MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
SizeAtCompileTime = (ei_size_at_compile_time<ei_traits<Derived>::RowsAtCompileTime,
ei_traits<Derived>::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<Derived>::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<Derived>::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<ei_traits<Derived>::MaxRowsAtCompileTime,
ei_traits<Derived>::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<Derived>::RowsAtCompileTime == 1
|| ei_traits<Derived>::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<Derived>::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<Derived>::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<T> then RealScalar is \a T.
*
* \sa class NumTraits
*/
typedef typename NumTraits<Scalar>::Real RealScalar;
#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()
&& "MatrixBase::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()
&& "MatrixBase::resize() does not actually allow to resize.");
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** \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<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType;
/** \internal the return type of MatrixBase::eigenvalues() */
typedef Matrix<typename NumTraits<typename ei_traits<Derived>::Scalar>::Real, ei_traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
/** \internal expression tyepe of a column */
typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1> ColXpr;
/** \internal expression tyepe of a column */
typedef Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime> RowXpr;
#endif // not EIGEN_PARSED_BY_DOXYGEN
/** Copies \a other into *this. \returns a reference to *this. */
template<typename OtherDerived>
Derived& operator=(const DenseBase<OtherDerived>& 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 DenseBase& other);
template<typename OtherDerived>
Derived& operator=(const AnyMatrixBase<OtherDerived> &other);
template<typename OtherDerived>
Derived& operator+=(const AnyMatrixBase<OtherDerived> &other);
template<typename OtherDerived>
Derived& operator-=(const AnyMatrixBase<OtherDerived> &other);
template<typename OtherDerived>
Derived& operator=(const ReturnByValue<OtherDerived>& func);
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** Copies \a other into *this without evaluating other. \returns a reference to *this. */
template<typename OtherDerived>
Derived& lazyAssign(const DenseBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN
CommaInitializer<Derived> operator<< (const Scalar& s);
template<typename OtherDerived>
CommaInitializer<Derived> operator<< (const DenseBase<OtherDerived>& 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<typename OtherDerived>
void copyCoeff(int row, int col, const DenseBase<OtherDerived>& other);
template<typename OtherDerived>
void copyCoeff(int index, const DenseBase<OtherDerived>& other);
template<typename OtherDerived, int StoreMode, int LoadMode>
void copyPacket(int row, int col, const DenseBase<OtherDerived>& other);
template<typename OtherDerived, int StoreMode, int LoadMode>
void copyPacket(int index, const DenseBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN
template<int LoadMode>
PacketScalar packet(int row, int col) const;
template<int StoreMode>
void writePacket(int row, int col, const PacketScalar& x);
template<int LoadMode>
PacketScalar packet(int index) const;
template<int StoreMode>
void writePacket(int index, const PacketScalar& x);
template<typename OtherDerived>
Derived& operator+=(const DenseBase<OtherDerived>& other);
template<typename OtherDerived>
Derived& operator-=(const DenseBase<OtherDerived>& other);
Eigen::Transpose<Derived> transpose();
const Eigen::Transpose<Derived> transpose() const;
void transposeInPlace();
#ifndef EIGEN_NO_DEBUG
template<typename OtherDerived>
Derived& lazyAssign(const Transpose<OtherDerived>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,Transpose<DerivedA>,DerivedB>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> >& other);
template<typename OtherDerived>
Derived& lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > >& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > >& other);
#endif
RowXpr row(int i);
const RowXpr row(int i) const;
ColXpr col(int i);
const ColXpr col(int i) const;
typename BlockReturnType<Derived>::Type block(int startRow, int startCol, int blockRows, int blockCols);
const typename BlockReturnType<Derived>::Type
block(int startRow, int startCol, int blockRows, int blockCols) const;
VectorBlock<Derived> segment(int start, int size);
const VectorBlock<Derived> segment(int start, int size) const;
VectorBlock<Derived> start(int size);
const VectorBlock<Derived> start(int size) const;
VectorBlock<Derived> end(int size);
const VectorBlock<Derived> end(int size) const;
typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols);
const typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols) const;
template<int BlockRows, int BlockCols>
typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol);
template<int BlockRows, int BlockCols>
const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol) const;
template<int CRows, int CCols>
typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type);
template<int CRows, int CCols>
const typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type) const;
template<int Size> VectorBlock<Derived,Size> start(void);
template<int Size> const VectorBlock<Derived,Size> start() const;
template<int Size> VectorBlock<Derived,Size> end();
template<int Size> const VectorBlock<Derived,Size> end() const;
template<int Size> VectorBlock<Derived,Size> segment(int start);
template<int Size> const VectorBlock<Derived,Size> segment(int start) const;
Diagonal<Derived,0> diagonal();
const Diagonal<Derived,0> diagonal() const;
template<int Index> Diagonal<Derived,Index> diagonal();
template<int Index> const Diagonal<Derived,Index> diagonal() const;
Diagonal<Derived, Dynamic> diagonal(int index);
const Diagonal<Derived, Dynamic> diagonal(int index) const;
template<unsigned int Mode> TriangularView<Derived, Mode> part();
template<unsigned int Mode> const TriangularView<Derived, Mode> part() const;
template<unsigned int Mode> TriangularView<Derived, Mode> triangularView();
template<unsigned int Mode> const TriangularView<Derived, Mode> triangularView() const;
template<unsigned int UpLo> SelfAdjointView<Derived, UpLo> selfadjointView();
template<unsigned int UpLo> const SelfAdjointView<Derived, UpLo> selfadjointView() 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<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
NullaryExpr(int rows, int cols, const CustomNullaryOp& func);
template<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
NullaryExpr(int size, const CustomNullaryOp& func);
template<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
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<typename OtherDerived>
bool isApprox(const DenseBase<OtherDerived>& other,
RealScalar prec = precision<Scalar>()) const;
bool isMuchSmallerThan(const RealScalar& other,
RealScalar prec = precision<Scalar>()) const;
template<typename OtherDerived>
bool isMuchSmallerThan(const DenseBase<OtherDerived>& other,
RealScalar prec = precision<Scalar>()) const;
bool isApproxToConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
bool isConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
bool isZero(RealScalar prec = precision<Scalar>()) const;
bool isOnes(RealScalar prec = precision<Scalar>()) const;
// template<typename OtherDerived>
// inline bool operator==(const DenseBase<OtherDerived>& other) const
// { return cwiseEqual(other).all(); }
//
// template<typename OtherDerived>
// inline bool operator!=(const DenseBase<OtherDerived>& 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<Derived>::type eval() const
{ return typename ei_eval<Derived>::type(derived()); }
template<typename OtherDerived>
void swap(DenseBase<OtherDerived> EIGEN_REF_TO_TEMPORARY other);
/** \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<Derived> nestByValue() const;
inline const ForceAlignedAccess<Derived> forceAlignedAccess() const;
inline ForceAlignedAccess<Derived> forceAlignedAccess();
template<bool Enable> inline const typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf() const;
template<bool Enable> inline typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf();
Scalar sum() const;
Scalar mean() const;
Scalar trace() const;
Scalar prod() const;
typename ei_traits<Derived>::Scalar minCoeff() const;
typename ei_traits<Derived>::Scalar maxCoeff() const;
typename ei_traits<Derived>::Scalar minCoeff(int* row, int* col) const;
typename ei_traits<Derived>::Scalar maxCoeff(int* row, int* col) const;
typename ei_traits<Derived>::Scalar minCoeff(int* index) const;
typename ei_traits<Derived>::Scalar maxCoeff(int* index) const;
template<typename BinaryOp>
typename ei_result_of<BinaryOp(typename ei_traits<Derived>::Scalar)>::type
redux(const BinaryOp& func) const;
template<typename Visitor>
void visit(Visitor& func) const;
#ifndef EIGEN_PARSED_BY_DOXYGEN
using AnyMatrixBase<Derived>::derived;
inline Derived& const_cast_derived() const
{ return *static_cast<Derived*>(const_cast<DenseBase*>(this)); }
#endif // not EIGEN_PARSED_BY_DOXYGEN
inline const WithFormat<Derived> format(const IOFormat& fmt) const;
/////////// Array module ///////////
bool all(void) const;
bool any(void) const;
int count() const;
const VectorwiseOp<Derived,Horizontal> rowwise() const;
VectorwiseOp<Derived,Horizontal> rowwise();
const VectorwiseOp<Derived,Vertical> colwise() const;
VectorwiseOp<Derived,Vertical> colwise();
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int rows, int cols);
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int size);
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random();
template<typename ThenDerived,typename ElseDerived>
const Select<Derived,ThenDerived,ElseDerived>
select(const DenseBase<ThenDerived>& thenMatrix,
const DenseBase<ElseDerived>& elseMatrix) const;
template<typename ThenDerived>
inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
select(const DenseBase<ThenDerived>& thenMatrix, typename ThenDerived::Scalar elseScalar) const;
template<typename ElseDerived>
inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
select(typename ElseDerived::Scalar thenScalar, const DenseBase<ElseDerived>& elseMatrix) const;
template<int p> RealScalar lpNorm() const;
template<int RowFactor, int ColFactor>
const Replicate<Derived,RowFactor,ColFactor> replicate() const;
const Replicate<Derived,Dynamic,Dynamic> replicate(int rowFacor,int colFactor) const;
Eigen::Reverse<Derived, BothDirections> reverse();
const Eigen::Reverse<Derived, BothDirections> reverse() const;
void reverseInPlace();
#ifdef EIGEN_DENSEBASE_PLUGIN
#include EIGEN_DENSEBASE_PLUGIN
#endif
protected:
/** Default constructor. Do nothing. */
DenseBase()
{
/* 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<Flags>::ret,
INVALID_MATRIXBASE_TEMPLATE_PARAMETERS)
#endif
}
private:
explicit DenseBase(int);
DenseBase(int,int);
template<typename OtherDerived> explicit DenseBase(const DenseBase<OtherDerived>&);
};
#endif // EIGEN_DENSEBASE_H

28
Eigen/src/Core/Fuzzy.h
View File

@ -47,8 +47,8 @@
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
bool MatrixBase<Derived>::isApprox( bool DenseBase<Derived>::isApprox(
const MatrixBase<OtherDerived>& other, const DenseBase<OtherDerived>& other,
RealScalar prec RealScalar prec
) const ) const
{ {
@ -68,15 +68,15 @@ bool MatrixBase<Derived>::isApprox(
* the value of the reference scalar \a other should come from the Hilbert-Schmidt norm * the value of the reference scalar \a other should come from the Hilbert-Schmidt norm
* of a reference matrix of same dimensions. * of a reference matrix of same dimensions.
* *
* \sa isApprox(), isMuchSmallerThan(const MatrixBase<OtherDerived>&, RealScalar) const * \sa isApprox(), isMuchSmallerThan(const DenseBase<OtherDerived>&, RealScalar) const
*/ */
template<typename Derived> template<typename Derived>
bool MatrixBase<Derived>::isMuchSmallerThan( bool DenseBase<Derived>::isMuchSmallerThan(
const typename NumTraits<Scalar>::Real& other, const typename NumTraits<Scalar>::Real& other,
RealScalar prec RealScalar prec
) const ) const
{ {
return cwiseAbs2().sum() <= prec * prec * other * other; return derived().cwiseAbs2().sum() <= prec * prec * other * other;
} }
/** \returns \c true if the norm of \c *this is much smaller than the norm of \a other, /** \returns \c true if the norm of \c *this is much smaller than the norm of \a other,
@ -91,12 +91,12 @@ bool MatrixBase<Derived>::isMuchSmallerThan(
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
bool MatrixBase<Derived>::isMuchSmallerThan( bool DenseBase<Derived>::isMuchSmallerThan(
const MatrixBase<OtherDerived>& other, const DenseBase<OtherDerived>& other,
RealScalar prec RealScalar prec
) const ) const
{ {
return cwiseAbs2().sum() <= prec * prec * other.cwiseAbs2().sum(); return derived().cwiseAbs2().sum() <= prec * prec * other.derived().cwiseAbs2().sum();
} }
#else #else
@ -122,8 +122,8 @@ struct ei_fuzzy_selector;
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
bool MatrixBase<Derived>::isApprox( bool DenseBase<Derived>::isApprox(
const MatrixBase<OtherDerived>& other, const DenseBase<OtherDerived>& other,
RealScalar prec RealScalar prec
) const ) const
{ {
@ -138,10 +138,10 @@ bool MatrixBase<Derived>::isApprox(
* \f[ \Vert v \Vert \leqslant p\,\vert x\vert. \f] * \f[ \Vert v \Vert \leqslant p\,\vert x\vert. \f]
* For matrices, the comparison is done on all columns. * For matrices, the comparison is done on all columns.
* *
* \sa isApprox(), isMuchSmallerThan(const MatrixBase<OtherDerived>&, RealScalar) const * \sa isApprox(), isMuchSmallerThan(const DenseBase<OtherDerived>&, RealScalar) const
*/ */
template<typename Derived> template<typename Derived>
bool MatrixBase<Derived>::isMuchSmallerThan( bool DenseBase<Derived>::isMuchSmallerThan(
const typename NumTraits<Scalar>::Real& other, const typename NumTraits<Scalar>::Real& other,
RealScalar prec RealScalar prec
) const ) const
@ -161,8 +161,8 @@ bool MatrixBase<Derived>::isMuchSmallerThan(
*/ */
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
bool MatrixBase<Derived>::isMuchSmallerThan( bool DenseBase<Derived>::isMuchSmallerThan(
const MatrixBase<OtherDerived>& other, const DenseBase<OtherDerived>& other,
RealScalar prec RealScalar prec
) const ) const
{ {

10
Eigen/src/Core/IO.h
View File

@ -121,7 +121,7 @@ class WithFormat
*/ */
template<typename Derived> template<typename Derived>
inline const WithFormat<Derived> inline const WithFormat<Derived>
MatrixBase<Derived>::format(const IOFormat& fmt) const DenseBase<Derived>::format(const IOFormat& fmt) const
{ {
return WithFormat<Derived>(derived(), fmt); return WithFormat<Derived>(derived(), fmt);
} }
@ -190,21 +190,21 @@ std::ostream & ei_print_matrix(std::ostream & s, const Derived& _m, const IOForm
return s; return s;
} }
/** \relates MatrixBase /** \relates DenseBase
* *
* Outputs the matrix, to the given stream. * Outputs the matrix, to the given stream.
* *
* If you wish to print the matrix with a format different than the default, use MatrixBase::format(). * If you wish to print the matrix with a format different than the default, use DenseBase::format().
* *
* It is also possible to change the default format by defining EIGEN_DEFAULT_IO_FORMAT before including Eigen headers. * It is also possible to change the default format by defining EIGEN_DEFAULT_IO_FORMAT before including Eigen headers.
* If not defined, this will automatically be defined to Eigen::IOFormat(), that is the Eigen::IOFormat with default parameters. * If not defined, this will automatically be defined to Eigen::IOFormat(), that is the Eigen::IOFormat with default parameters.
* *
* \sa MatrixBase::format() * \sa DenseBase::format()
*/ */
template<typename Derived> template<typename Derived>
std::ostream & operator << std::ostream & operator <<
(std::ostream & s, (std::ostream & s,
const MatrixBase<Derived> & m) const DenseBase<Derived> & m)
{ {
return ei_print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT); return ei_print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT);
} }

6
Eigen/src/Core/Map.h
View File

@ -58,11 +58,13 @@ struct ei_traits<Map<MatrixType, Options> > : public ei_traits<MatrixType>
}; };
template<typename MatrixType, int Options> class Map template<typename MatrixType, int Options> class Map
: public MapBase<Map<MatrixType, Options> > : public MapBase<Map<MatrixType, Options>,
typename MatrixType::template MakeBase< Map<MatrixType, Options> >::Type>
{ {
public: public:
_EIGEN_GENERIC_PUBLIC_INTERFACE(Map, MapBase<Map>) typedef MapBase<Map,typename MatrixType::template MakeBase<Map>::Type> Base;
_EIGEN_GENERIC_PUBLIC_INTERFACE(Map)
inline int stride() const { return this->innerSize(); } inline int stride() const { return this->innerSize(); }

6
Eigen/src/Core/MapBase.h
View File

@ -32,12 +32,12 @@
* *
* \sa class Map, class Block * \sa class Map, class Block
*/ */
template<typename Derived> class MapBase template<typename Derived, typename Base> class MapBase
: public MatrixBase<Derived> : public Base
{ {
public: public:
typedef MatrixBase<Derived> Base; // typedef MatrixBase<Derived> Base;
enum { enum {
IsRowMajor = (int(ei_traits<Derived>::Flags) & RowMajorBit) ? 1 : 0, IsRowMajor = (int(ei_traits<Derived>::Flags) & RowMajorBit) ? 1 : 0,
RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime,

213
Eigen/src/Core/MatrixBase.h
View File

@ -52,10 +52,7 @@
* \endcode * \endcode
*/ */
template<typename Derived> class MatrixBase template<typename Derived> class MatrixBase
#ifndef EIGEN_PARSED_BY_DOXYGEN : public DenseBase<Derived>
: public ei_special_scalar_op_base<Derived,typename ei_traits<Derived>::Scalar,
typename NumTraits<typename ei_traits<Derived>::Scalar>::Real>
#endif // not EIGEN_PARSED_BY_DOXYGEN
{ {
public: public:
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
@ -71,6 +68,13 @@ template<typename Derived> class MatrixBase
typedef typename ei_traits<Derived>::Scalar Scalar; typedef typename ei_traits<Derived>::Scalar Scalar;
typedef typename ei_packet_traits<Scalar>::type PacketScalar; typedef typename ei_packet_traits<Scalar>::type PacketScalar;
typedef DenseBase<Derived> Base;
using Base::rows;
using Base::cols;
using Base::size;
using Base::coeff;
using Base::coeffRef;
#endif // not EIGEN_PARSED_BY_DOXYGEN #endif // not EIGEN_PARSED_BY_DOXYGEN
enum { enum {
@ -165,12 +169,12 @@ template<typename Derived> class MatrixBase
#endif // not EIGEN_PARSED_BY_DOXYGEN #endif // not EIGEN_PARSED_BY_DOXYGEN
/** \returns the number of rows. \sa cols(), RowsAtCompileTime */ /** \returns the number of rows. \sa cols(), RowsAtCompileTime */
inline int rows() const { return derived().rows(); } // inline int rows() const { return derived().rows(); }
/** \returns the number of columns. \sa rows(), ColsAtCompileTime*/ /** \returns the number of columns. \sa rows(), ColsAtCompileTime*/
inline int cols() const { return derived().cols(); } // inline int cols() const { return derived().cols(); }
/** \returns the number of coefficients, which is rows()*cols(). /** \returns the number of coefficients, which is rows()*cols().
* \sa rows(), cols(), SizeAtCompileTime. */ * \sa rows(), cols(), SizeAtCompileTime. */
inline int size() const { return rows() * cols(); } // inline int size() const { return rows() * cols(); }
/** \returns the size of the main diagonal, which is min(rows(),cols()). /** \returns the size of the main diagonal, which is min(rows(),cols()).
* \sa rows(), cols(), SizeAtCompileTime. */ * \sa rows(), cols(), SizeAtCompileTime. */
inline int diagonalSize() const { return std::min(rows(),cols()); } inline int diagonalSize() const { return std::min(rows(),cols()); }
@ -215,12 +219,19 @@ template<typename Derived> class MatrixBase
* PlainMatrixType or const PlainMatrixType&. * PlainMatrixType or const PlainMatrixType&.
*/ */
typedef typename ei_plain_matrix_type<Derived>::type PlainMatrixType; typedef typename ei_plain_matrix_type<Derived>::type PlainMatrixType;
// typedef Matrix<typename ei_traits<Derived>::Scalar,
// ei_traits<Derived>::RowsAtCompileTime,
// ei_traits<Derived>::ColsAtCompileTime,
// AutoAlign | (ei_traits<Derived>::Flags&RowMajorBit ? RowMajor : ColMajor),
// ei_traits<Derived>::MaxRowsAtCompileTime,
// ei_traits<Derived>::MaxColsAtCompileTime
// > PlainMatrixType;
/** \internal the column-major plain matrix type corresponding to this expression. Note that is not necessarily /** \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 * 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! * reference to a matrix, not a matrix!
* The only difference from PlainMatrixType is that PlainMatrixType_ColMajor is guaranteed to be column-major. * The only difference from PlainMatrixType is that PlainMatrixType_ColMajor is guaranteed to be column-major.
*/ */
typedef typename ei_plain_matrix_type<Derived>::type PlainMatrixType_ColMajor; // typedef typename ei_plain_matrix_type<Derived>::type PlainMatrixType_ColMajor;
/** \internal the return type of coeff() /** \internal the return type of coeff()
*/ */
@ -249,15 +260,11 @@ template<typename Derived> class MatrixBase
#define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase #define EIGEN_CURRENT_STORAGE_BASE_CLASS Eigen::MatrixBase
#include "../plugins/CommonCwiseUnaryOps.h" #include "../plugins/CommonCwiseUnaryOps.h"
#include "../plugins/MatrixCwiseUnaryOps.h"
#include "../plugins/CommonCwiseBinaryOps.h" #include "../plugins/CommonCwiseBinaryOps.h"
#include "../plugins/MatrixCwiseUnaryOps.h"
#include "../plugins/MatrixCwiseBinaryOps.h" #include "../plugins/MatrixCwiseBinaryOps.h"
#undef EIGEN_CURRENT_STORAGE_BASE_CLASS #undef EIGEN_CURRENT_STORAGE_BASE_CLASS
/** Copies \a other into *this. \returns a reference to *this. */
template<typename OtherDerived>
Derived& operator=(const MatrixBase<OtherDerived>& other);
/** Special case of the template operator=, in order to prevent the compiler /** Special case of the template operator=, in order to prevent the compiler
* from generating a default operator= (issue hit with g++ 4.1) * from generating a default operator= (issue hit with g++ 4.1)
*/ */
@ -276,9 +283,10 @@ template<typename Derived> class MatrixBase
Derived& operator=(const ReturnByValue<OtherDerived>& func); Derived& operator=(const ReturnByValue<OtherDerived>& func);
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
using DenseBase<Derived>::lazyAssign;
/** Copies \a other into *this without evaluating other. \returns a reference to *this. */ /** Copies \a other into *this without evaluating other. \returns a reference to *this. */
template<typename OtherDerived> // template<typename OtherDerived>
Derived& lazyAssign(const MatrixBase<OtherDerived>& other); // Derived& lazyAssign(const MatrixBase<OtherDerived>& other);
template<typename ProductDerived, typename Lhs, typename Rhs> template<typename ProductDerived, typename Lhs, typename Rhs>
Derived& lazyAssign(const ProductBase<ProductDerived, Lhs,Rhs>& other); Derived& lazyAssign(const ProductBase<ProductDerived, Lhs,Rhs>& other);
@ -292,46 +300,6 @@ template<typename Derived> class MatrixBase
EvalBeforeAssigningBit>& other); EvalBeforeAssigningBit>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN #endif // not EIGEN_PARSED_BY_DOXYGEN
CommaInitializer<Derived> operator<< (const Scalar& s);
template<typename OtherDerived>
CommaInitializer<Derived> operator<< (const MatrixBase<OtherDerived>& 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<typename OtherDerived>
void copyCoeff(int row, int col, const MatrixBase<OtherDerived>& other);
template<typename OtherDerived>
void copyCoeff(int index, const MatrixBase<OtherDerived>& other);
template<typename OtherDerived, int StoreMode, int LoadMode>
void copyPacket(int row, int col, const MatrixBase<OtherDerived>& other);
template<typename OtherDerived, int StoreMode, int LoadMode>
void copyPacket(int index, const MatrixBase<OtherDerived>& other);
#endif // not EIGEN_PARSED_BY_DOXYGEN
template<int LoadMode>
PacketScalar packet(int row, int col) const;
template<int StoreMode>
void writePacket(int row, int col, const PacketScalar& x);
template<int LoadMode>
PacketScalar packet(int index) const;
template<int StoreMode>
void writePacket(int index, const PacketScalar& x);
const CoeffReturnType x() const; const CoeffReturnType x() const;
const CoeffReturnType y() const; const CoeffReturnType y() const;
const CoeffReturnType z() const; const CoeffReturnType z() const;
@ -373,71 +341,12 @@ template<typename Derived> class MatrixBase
const PlainMatrixType normalized() const; const PlainMatrixType normalized() const;
void normalize(); void normalize();
Eigen::Transpose<Derived> transpose();
const Eigen::Transpose<Derived> transpose() const;
void transposeInPlace();
const AdjointReturnType adjoint() const; const AdjointReturnType adjoint() const;
void adjointInPlace(); void adjointInPlace();
#ifndef EIGEN_NO_DEBUG
template<typename OtherDerived>
Derived& lazyAssign(const Transpose<OtherDerived>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,Transpose<DerivedA>,DerivedB>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> >& other);
template<typename OtherDerived>
Derived& lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > >& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB>& other);
template<typename DerivedA, typename DerivedB>
Derived& lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > >& other);
#endif
RowXpr row(int i);
const RowXpr row(int i) const;
ColXpr col(int i);
const ColXpr col(int i) const;
Minor<Derived> minor(int row, int col); Minor<Derived> minor(int row, int col);
const Minor<Derived> minor(int row, int col) const; const Minor<Derived> minor(int row, int col) const;
typename BlockReturnType<Derived>::Type block(int startRow, int startCol, int blockRows, int blockCols);
const typename BlockReturnType<Derived>::Type
block(int startRow, int startCol, int blockRows, int blockCols) const;
VectorBlock<Derived> segment(int start, int size);
const VectorBlock<Derived> segment(int start, int size) const;
VectorBlock<Derived> start(int size);
const VectorBlock<Derived> start(int size) const;
VectorBlock<Derived> end(int size);
const VectorBlock<Derived> end(int size) const;
typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols);
const typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols) const;
template<int BlockRows, int BlockCols>
typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol);
template<int BlockRows, int BlockCols>
const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol) const;
template<int CRows, int CCols>
typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type);
template<int CRows, int CCols>
const typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type) const;
template<int Size> VectorBlock<Derived,Size> start(void);
template<int Size> const VectorBlock<Derived,Size> start() const;
template<int Size> VectorBlock<Derived,Size> end();
template<int Size> const VectorBlock<Derived,Size> end() const;
template<int Size> VectorBlock<Derived,Size> segment(int start);
template<int Size> const VectorBlock<Derived,Size> segment(int start) const;
Diagonal<Derived,0> diagonal(); Diagonal<Derived,0> diagonal();
const Diagonal<Derived,0> diagonal() const; const Diagonal<Derived,0> diagonal() const;
@ -456,29 +365,6 @@ template<typename Derived> class MatrixBase
template<unsigned int UpLo> SelfAdjointView<Derived, UpLo> selfadjointView(); template<unsigned int UpLo> SelfAdjointView<Derived, UpLo> selfadjointView();
template<unsigned int UpLo> const SelfAdjointView<Derived, UpLo> selfadjointView() const; template<unsigned int UpLo> const SelfAdjointView<Derived, UpLo> selfadjointView() 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<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
NullaryExpr(int rows, int cols, const CustomNullaryOp& func);
template<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
NullaryExpr(int size, const CustomNullaryOp& func);
template<typename CustomNullaryOp>
static const CwiseNullaryOp<CustomNullaryOp, Derived>
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();
static const IdentityReturnType Identity(); static const IdentityReturnType Identity();
static const IdentityReturnType Identity(int rows, int cols); static const IdentityReturnType Identity(int rows, int cols);
static const BasisReturnType Unit(int size, int i); static const BasisReturnType Unit(int size, int i);
@ -490,27 +376,8 @@ template<typename Derived> class MatrixBase
const DiagonalWrapper<Derived> asDiagonal() const; const DiagonalWrapper<Derived> asDiagonal() const;
void fill(const Scalar& value);
Derived& setConstant(const Scalar& value);
Derived& setZero();
Derived& setOnes();
Derived& setRandom();
Derived& setIdentity(); Derived& setIdentity();
template<typename OtherDerived>
bool isApprox(const MatrixBase<OtherDerived>& other,
RealScalar prec = precision<Scalar>()) const;
bool isMuchSmallerThan(const RealScalar& other,
RealScalar prec = precision<Scalar>()) const;
template<typename OtherDerived>
bool isMuchSmallerThan(const MatrixBase<OtherDerived>& other,
RealScalar prec = precision<Scalar>()) const;
bool isApproxToConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
bool isConstant(const Scalar& value, RealScalar prec = precision<Scalar>()) const;
bool isZero(RealScalar prec = precision<Scalar>()) const;
bool isOnes(RealScalar prec = precision<Scalar>()) const;
bool isIdentity(RealScalar prec = precision<Scalar>()) const; bool isIdentity(RealScalar prec = precision<Scalar>()) const;
bool isDiagonal(RealScalar prec = precision<Scalar>()) const; bool isDiagonal(RealScalar prec = precision<Scalar>()) const;
@ -557,28 +424,9 @@ template<typename Derived> class MatrixBase
template<bool Enable> inline const typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf() const; template<bool Enable> inline const typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf() const;
template<bool Enable> inline typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf(); template<bool Enable> inline typename ei_meta_if<Enable,ForceAlignedAccess<Derived>,Derived&>::ret forceAlignedAccessIf();
Scalar sum() const;
Scalar mean() const; Scalar mean() const;
Scalar trace() const; Scalar trace() const;
Scalar prod() const;
typename ei_traits<Derived>::Scalar minCoeff() const;
typename ei_traits<Derived>::Scalar maxCoeff() const;
typename ei_traits<Derived>::Scalar minCoeff(int* row, int* col) const;
typename ei_traits<Derived>::Scalar maxCoeff(int* row, int* col) const;
typename ei_traits<Derived>::Scalar minCoeff(int* index) const;
typename ei_traits<Derived>::Scalar maxCoeff(int* index) const;
template<typename BinaryOp>
typename ei_result_of<BinaryOp(typename ei_traits<Derived>::Scalar)>::type
redux(const BinaryOp& func) const;
template<typename Visitor>
void visit(Visitor& func) const;
#ifndef EIGEN_PARSED_BY_DOXYGEN #ifndef EIGEN_PARSED_BY_DOXYGEN
using AnyMatrixBase<Derived>::derived; using AnyMatrixBase<Derived>::derived;
inline Derived& const_cast_derived() const inline Derived& const_cast_derived() const
@ -589,19 +437,11 @@ template<typename Derived> class MatrixBase
/////////// Array module /////////// /////////// Array module ///////////
bool all(void) const;
bool any(void) const;
int count() const;
const VectorwiseOp<Derived,Horizontal> rowwise() const; const VectorwiseOp<Derived,Horizontal> rowwise() const;
VectorwiseOp<Derived,Horizontal> rowwise(); VectorwiseOp<Derived,Horizontal> rowwise();
const VectorwiseOp<Derived,Vertical> colwise() const; const VectorwiseOp<Derived,Vertical> colwise() const;
VectorwiseOp<Derived,Vertical> colwise(); VectorwiseOp<Derived,Vertical> colwise();
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int rows, int cols);
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random(int size);
static const CwiseNullaryOp<ei_scalar_random_op<Scalar>,Derived> Random();
template<typename ThenDerived,typename ElseDerived> template<typename ThenDerived,typename ElseDerived>
const Select<Derived,ThenDerived,ElseDerived> const Select<Derived,ThenDerived,ElseDerived>
select(const MatrixBase<ThenDerived>& thenMatrix, select(const MatrixBase<ThenDerived>& thenMatrix,
@ -625,6 +465,9 @@ template<typename Derived> class MatrixBase
const Eigen::Reverse<Derived, BothDirections> reverse() const; const Eigen::Reverse<Derived, BothDirections> reverse() const;
void reverseInPlace(); void reverseInPlace();
ArrayWrapper<Derived> array() { return derived(); }
const ArrayWrapper<Derived> array() const { return derived(); }
/////////// LU module /////////// /////////// LU module ///////////
const FullPivLU<PlainMatrixType> fullPivLu() const; const FullPivLU<PlainMatrixType> fullPivLu() const;
@ -727,9 +570,9 @@ template<typename Derived> class MatrixBase
inline Cwise<Derived> cwise(); inline Cwise<Derived> cwise();
// a workaround waiting the Array class // a workaround waiting the Array class
inline const Cwise<Derived> array() const { return cwise(); } // inline const Cwise<Derived> array() const { return cwise(); }
// a workaround waiting the Array class // a workaround waiting the Array class
inline Cwise<Derived> array() { return cwise(); } // inline Cwise<Derived> array() { return cwise(); }
template<typename OtherDerived> template<typename OtherDerived>
typename ei_plain_matrix_type_column_major<OtherDerived>::type typename ei_plain_matrix_type_column_major<OtherDerived>::type

7
Eigen/src/Core/ProductBase.h
View File

@ -54,8 +54,8 @@ struct ei_nested<ProductBase<Derived,Lhs,Rhs>, N, EvalType>
}; };
#define EIGEN_PRODUCT_PUBLIC_INTERFACE(Derived) \ #define EIGEN_PRODUCT_PUBLIC_INTERFACE(Derived) \
typedef ProductBase<Derived, Lhs, Rhs > ProductBaseType; \ typedef ProductBase<Derived, Lhs, Rhs > Base; \
_EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, ProductBaseType) \ _EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
typedef typename Base::LhsNested LhsNested; \ typedef typename Base::LhsNested LhsNested; \
typedef typename Base::_LhsNested _LhsNested; \ typedef typename Base::_LhsNested _LhsNested; \
typedef typename Base::LhsBlasTraits LhsBlasTraits; \ typedef typename Base::LhsBlasTraits LhsBlasTraits; \
@ -73,7 +73,8 @@ template<typename Derived, typename Lhs, typename Rhs>
class ProductBase : public MatrixBase<Derived> class ProductBase : public MatrixBase<Derived>
{ {
public: public:
_EIGEN_GENERIC_PUBLIC_INTERFACE(ProductBase,MatrixBase<Derived>) typedef MatrixBase<Derived> Base;
_EIGEN_GENERIC_PUBLIC_INTERFACE(ProductBase)
typedef typename Lhs::Nested LhsNested; typedef typename Lhs::Nested LhsNested;
typedef typename ei_cleantype<LhsNested>::type _LhsNested; typedef typename ei_cleantype<LhsNested>::type _LhsNested;

14
Eigen/src/Core/Redux.h
View File

@ -309,12 +309,12 @@ struct ei_redux_impl<Func, Derived, LinearVectorization, CompleteUnrolling>
* The template parameter \a BinaryOp is the type of the functor \a func which must be * The template parameter \a BinaryOp is the type of the functor \a func which must be
* an associative operator. Both current STL and TR1 functor styles are handled. * an associative operator. Both current STL and TR1 functor styles are handled.
* *
* \sa MatrixBase::sum(), MatrixBase::minCoeff(), MatrixBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise() * \sa DenseBase::sum(), DenseBase::minCoeff(), DenseBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise()
*/ */
template<typename Derived> template<typename Derived>
template<typename Func> template<typename Func>
inline typename ei_result_of<Func(typename ei_traits<Derived>::Scalar)>::type inline typename ei_result_of<Func(typename ei_traits<Derived>::Scalar)>::type
MatrixBase<Derived>::redux(const Func& func) const DenseBase<Derived>::redux(const Func& func) const
{ {
typename Derived::Nested nested(derived()); typename Derived::Nested nested(derived());
typedef typename ei_cleantype<typename Derived::Nested>::type ThisNested; typedef typename ei_cleantype<typename Derived::Nested>::type ThisNested;
@ -326,7 +326,7 @@ MatrixBase<Derived>::redux(const Func& func) const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::minCoeff() const DenseBase<Derived>::minCoeff() const
{ {
return this->redux(Eigen::ei_scalar_min_op<Scalar>()); return this->redux(Eigen::ei_scalar_min_op<Scalar>());
} }
@ -335,7 +335,7 @@ MatrixBase<Derived>::minCoeff() const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::maxCoeff() const DenseBase<Derived>::maxCoeff() const
{ {
return this->redux(Eigen::ei_scalar_max_op<Scalar>()); return this->redux(Eigen::ei_scalar_max_op<Scalar>());
} }
@ -346,7 +346,7 @@ MatrixBase<Derived>::maxCoeff() const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::sum() const DenseBase<Derived>::sum() const
{ {
return this->redux(Eigen::ei_scalar_sum_op<Scalar>()); return this->redux(Eigen::ei_scalar_sum_op<Scalar>());
} }
@ -357,7 +357,7 @@ MatrixBase<Derived>::sum() const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::mean() const DenseBase<Derived>::mean() const
{ {
return this->redux(Eigen::ei_scalar_sum_op<Scalar>()) / this->size(); return this->redux(Eigen::ei_scalar_sum_op<Scalar>()) / this->size();
} }
@ -371,7 +371,7 @@ MatrixBase<Derived>::mean() const
*/ */
template<typename Derived> template<typename Derived>
EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::prod() const DenseBase<Derived>::prod() const
{ {
return this->redux(Eigen::ei_scalar_product_op<Scalar>()); return this->redux(Eigen::ei_scalar_product_op<Scalar>());
} }

4
Eigen/src/Core/StableNorm.h
View File

@ -67,10 +67,10 @@ MatrixBase<Derived>::stableNorm() const
{ {
bi = ei_alignmentOffset(&const_cast_derived().coeffRef(0), n); bi = ei_alignmentOffset(&const_cast_derived().coeffRef(0), n);
if (bi>0) if (bi>0)
ei_stable_norm_kernel(start(bi), ssq, scale, invScale); ei_stable_norm_kernel(this->start(bi), ssq, scale, invScale);
} }
for (; bi<n; bi+=blockSize) for (; bi<n; bi+=blockSize)
ei_stable_norm_kernel(segment(bi,std::min(blockSize, n - bi)).template forceAlignedAccessIf<Alignment>(), ssq, scale, invScale); ei_stable_norm_kernel(this->segment(bi,std::min(blockSize, n - bi)).template forceAlignedAccessIf<Alignment>(), ssq, scale, invScale);
return scale * ei_sqrt(ssq); return scale * ei_sqrt(ssq);
} }

39
Eigen/src/Core/Transpose.h
View File

@ -90,7 +90,7 @@ template<typename MatrixType> class Transpose
template<typename MatrixType> class TransposeImpl<MatrixType,Dense> template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
: public MatrixBase<Transpose<MatrixType> > : public MatrixType::template MakeBase<Transpose<MatrixType> >::Type
{ {
const typename ei_cleantype<typename MatrixType::Nested>::type& matrix() const const typename ei_cleantype<typename MatrixType::Nested>::type& matrix() const
{ return derived().nestedExpression(); } { return derived().nestedExpression(); }
@ -99,8 +99,9 @@ template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
public: public:
//EIGEN_DENSE_PUBLIC_INTERFACE(TransposeImpl,MatrixBase<Transpose<MatrixType> >) //EIGEN_DENSE_PUBLpename IC_INTERFACE(TransposeImpl,MatrixBase<Transpose<MatrixType> >)
EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>) typedef typename MatrixType::template MakeBase<Transpose<MatrixType> >::Type Base;
_EIGEN_DENSE_PUBLIC_INTERFACE(Transpose<MatrixType>)
// EIGEN_EXPRESSION_IMPL_COMMON(MatrixBase<Transpose<MatrixType> >) // EIGEN_EXPRESSION_IMPL_COMMON(MatrixBase<Transpose<MatrixType> >)
@ -174,7 +175,7 @@ template<typename MatrixType> class TransposeImpl<MatrixType,Dense>
* \sa transposeInPlace(), adjoint() */ * \sa transposeInPlace(), adjoint() */
template<typename Derived> template<typename Derived>
inline Transpose<Derived> inline Transpose<Derived>
MatrixBase<Derived>::transpose() DenseBase<Derived>::transpose()
{ {
return derived(); return derived();
} }
@ -186,7 +187,7 @@ MatrixBase<Derived>::transpose()
* \sa transposeInPlace(), adjoint() */ * \sa transposeInPlace(), adjoint() */
template<typename Derived> template<typename Derived>
inline const Transpose<Derived> inline const Transpose<Derived>
MatrixBase<Derived>::transpose() const DenseBase<Derived>::transpose() const
{ {
return derived(); return derived();
} }
@ -214,7 +215,7 @@ template<typename Derived>
inline const typename MatrixBase<Derived>::AdjointReturnType inline const typename MatrixBase<Derived>::AdjointReturnType
MatrixBase<Derived>::adjoint() const MatrixBase<Derived>::adjoint() const
{ {
return transpose().nestByValue(); return this->transpose().nestByValue();
} }
/*************************************************************************** /***************************************************************************
@ -261,7 +262,7 @@ struct ei_inplace_transpose_selector<MatrixType,false> { // non square matrix
* *
* \sa transpose(), adjoint(), adjointInPlace() */ * \sa transpose(), adjoint(), adjointInPlace() */
template<typename Derived> template<typename Derived>
inline void MatrixBase<Derived>::transposeInPlace() inline void DenseBase<Derived>::transposeInPlace()
{ {
ei_inplace_transpose_selector<Derived>::run(derived()); ei_inplace_transpose_selector<Derived>::run(derived());
} }
@ -324,61 +325,61 @@ template<typename T> typename T::Scalar* ei_extract_data(const T& m)
template<typename Derived> template<typename Derived>
template<typename OtherDerived> template<typename OtherDerived>
Derived& MatrixBase<Derived>::lazyAssign(const Transpose<OtherDerived>& other) Derived& DenseBase<Derived>::lazyAssign(const Transpose<OtherDerived>& other)
{ {
ei_assert(ei_extract_data(other) != ei_extract_data(derived()) ei_assert(ei_extract_data(other) != ei_extract_data(derived())
&& "aliasing detected during tranposition, please use transposeInPlace()"); && "aliasing detected during tranposition, please use transposeInPlace()");
return lazyAssign(static_cast<const MatrixBase<Transpose<OtherDerived> >& >(other)); return lazyAssign(static_cast<const DenseBase<Transpose<OtherDerived> >& >(other));
} }
template<typename Derived> template<typename Derived>
template<typename DerivedA, typename DerivedB> template<typename DerivedA, typename DerivedB>
Derived& MatrixBase<Derived>:: Derived& DenseBase<Derived>::
lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,Transpose<DerivedA>,DerivedB>& other) lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,Transpose<DerivedA>,DerivedB>& other)
{ {
ei_assert(ei_extract_data(derived()) != ei_extract_data(other.lhs()) ei_assert(ei_extract_data(derived()) != ei_extract_data(other.lhs())
&& "aliasing detected during tranposition, please evaluate your expression"); && "aliasing detected during tranposition, please evaluate your expression");
return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,Transpose<DerivedA>,DerivedB> >& >(other)); return lazyAssign(static_cast<const DenseBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,Transpose<DerivedA>,DerivedB> >& >(other));
} }
template<typename Derived> template<typename Derived>
template<typename DerivedA, typename DerivedB> template<typename DerivedA, typename DerivedB>
Derived& MatrixBase<Derived>:: Derived& DenseBase<Derived>::
lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> >& other) lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> >& other)
{ {
ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs()) ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs())
&& "aliasing detected during tranposition, please evaluate your expression"); && "aliasing detected during tranposition, please evaluate your expression");
return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> > >& >(other)); return lazyAssign(static_cast<const DenseBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,Transpose<DerivedB> > >& >(other));
} }
template<typename Derived> template<typename Derived>
template<typename OtherDerived> Derived& template<typename OtherDerived> Derived&
MatrixBase<Derived>:: DenseBase<Derived>::
lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > >& other) lazyAssign(const CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > >& other)
{ {
ei_assert(ei_extract_data(other) != ei_extract_data(derived()) ei_assert(ei_extract_data(other) != ei_extract_data(derived())
&& "aliasing detected during tranposition, please use adjointInPlace()"); && "aliasing detected during tranposition, please use adjointInPlace()");
return lazyAssign(static_cast<const MatrixBase<CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > > >& >(other)); return lazyAssign(static_cast<const DenseBase<CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<OtherDerived> > > >& >(other));
} }
template<typename Derived> template<typename Derived>
template<typename DerivedA, typename DerivedB> template<typename DerivedA, typename DerivedB>
Derived& MatrixBase<Derived>:: Derived& DenseBase<Derived>::
lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB>& other) lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB>& other)
{ {
ei_assert(ei_extract_data(derived()) != ei_extract_data(other.lhs()) ei_assert(ei_extract_data(derived()) != ei_extract_data(other.lhs())
&& "aliasing detected during tranposition, please evaluate your expression"); && "aliasing detected during tranposition, please evaluate your expression");
return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB> >& >(other)); return lazyAssign(static_cast<const DenseBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedA> > >,DerivedB> >& >(other));
} }
template<typename Derived> template<typename Derived>
template<typename DerivedA, typename DerivedB> template<typename DerivedA, typename DerivedB>
Derived& MatrixBase<Derived>:: Derived& DenseBase<Derived>::
lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > >& other) lazyAssign(const CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > >& other)
{ {
ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs()) ei_assert(ei_extract_data(derived()) != ei_extract_data(other.rhs())
&& "aliasing detected during tranposition, please evaluate your expression"); && "aliasing detected during tranposition, please evaluate your expression");
return lazyAssign(static_cast<const MatrixBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > > >& >(other)); return lazyAssign(static_cast<const DenseBase<CwiseBinaryOp<ei_scalar_sum_op<Scalar>,DerivedA,CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, NestByValue<Eigen::Transpose<DerivedB> > > > >& >(other));
} }
#endif #endif

32
Eigen/src/Core/VectorBlock.h
View File

@ -34,7 +34,7 @@
* \param Size size of the sub-vector we are taking at compile time (optional) * \param Size size of the sub-vector we are taking at compile time (optional)
* *
* This class represents an expression of either a fixed-size or dynamic-size sub-vector. * This class represents an expression of either a fixed-size or dynamic-size sub-vector.
* It is the return type of MatrixBase::segment(int,int) and MatrixBase::segment<int>(int) and * It is the return type of DenseBase::segment(int,int) and DenseBase::segment<int>(int) and
* most of the time this is the only way it is used. * most of the time this is the only way it is used.
* *
* However, if you want to directly maniputate sub-vector expressions, * However, if you want to directly maniputate sub-vector expressions,
@ -53,7 +53,7 @@
* \include class_FixedVectorBlock.cpp * \include class_FixedVectorBlock.cpp
* Output: \verbinclude class_FixedVectorBlock.out * Output: \verbinclude class_FixedVectorBlock.out
* *
* \sa class Block, MatrixBase::segment(int,int,int,int), MatrixBase::segment(int,int) * \sa class Block, DenseBase::segment(int,int,int,int), DenseBase::segment(int,int)
*/ */
template<typename VectorType, int Size> template<typename VectorType, int Size>
struct ei_traits<VectorBlock<VectorType, Size> > struct ei_traits<VectorBlock<VectorType, Size> >
@ -70,12 +70,12 @@ template<typename VectorType, int Size> class VectorBlock
{ {
typedef Block<VectorType, typedef Block<VectorType,
ei_traits<VectorType>::RowsAtCompileTime==1 ? 1 : Size, ei_traits<VectorType>::RowsAtCompileTime==1 ? 1 : Size,
ei_traits<VectorType>::ColsAtCompileTime==1 ? 1 : Size> _Base; ei_traits<VectorType>::ColsAtCompileTime==1 ? 1 : Size> Base;
enum { enum {
IsColVector = ei_traits<VectorType>::ColsAtCompileTime==1 IsColVector = ei_traits<VectorType>::ColsAtCompileTime==1
}; };
public: public:
_EIGEN_GENERIC_PUBLIC_INTERFACE(VectorBlock, _Base) _EIGEN_GENERIC_PUBLIC_INTERFACE(VectorBlock)
using Base::operator=; using Base::operator=;
using Base::operator+=; using Base::operator+=;
@ -121,7 +121,7 @@ template<typename VectorType, int Size> class VectorBlock
* \sa class Block, segment(int) * \sa class Block, segment(int)
*/ */
template<typename Derived> template<typename Derived>
inline VectorBlock<Derived> MatrixBase<Derived> inline VectorBlock<Derived> DenseBase<Derived>
::segment(int start, int size) ::segment(int start, int size)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
@ -131,7 +131,7 @@ inline VectorBlock<Derived> MatrixBase<Derived>
/** This is the const version of segment(int,int).*/ /** This is the const version of segment(int,int).*/
template<typename Derived> template<typename Derived>
inline const VectorBlock<Derived> inline const VectorBlock<Derived>
MatrixBase<Derived>::segment(int start, int size) const DenseBase<Derived>::segment(int start, int size) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived>(derived(), start, size); return VectorBlock<Derived>(derived(), start, size);
@ -154,7 +154,7 @@ MatrixBase<Derived>::segment(int start, int size) const
*/ */
template<typename Derived> template<typename Derived>
inline VectorBlock<Derived> inline VectorBlock<Derived>
MatrixBase<Derived>::start(int size) DenseBase<Derived>::start(int size)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived>(derived(), 0, size); return VectorBlock<Derived>(derived(), 0, size);
@ -163,7 +163,7 @@ MatrixBase<Derived>::start(int size)
/** This is the const version of start(int).*/ /** This is the const version of start(int).*/
template<typename Derived> template<typename Derived>
inline const VectorBlock<Derived> inline const VectorBlock<Derived>
MatrixBase<Derived>::start(int size) const DenseBase<Derived>::start(int size) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived>(derived(), 0, size); return VectorBlock<Derived>(derived(), 0, size);
@ -186,7 +186,7 @@ MatrixBase<Derived>::start(int size) const
*/ */
template<typename Derived> template<typename Derived>
inline VectorBlock<Derived> inline VectorBlock<Derived>
MatrixBase<Derived>::end(int size) DenseBase<Derived>::end(int size)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived>(derived(), this->size() - size, size); return VectorBlock<Derived>(derived(), this->size() - size, size);
@ -195,7 +195,7 @@ MatrixBase<Derived>::end(int size)
/** This is the const version of end(int).*/ /** This is the const version of end(int).*/
template<typename Derived> template<typename Derived>
inline const VectorBlock<Derived> inline const VectorBlock<Derived>
MatrixBase<Derived>::end(int size) const DenseBase<Derived>::end(int size) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived>(derived(), this->size() - size, size); return VectorBlock<Derived>(derived(), this->size() - size, size);
@ -217,7 +217,7 @@ MatrixBase<Derived>::end(int size) const
template<typename Derived> template<typename Derived>
template<int Size> template<int Size>
inline VectorBlock<Derived,Size> inline VectorBlock<Derived,Size>
MatrixBase<Derived>::segment(int start) DenseBase<Derived>::segment(int start)
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived,Size>(derived(), start); return VectorBlock<Derived,Size>(derived(), start);
@ -227,7 +227,7 @@ MatrixBase<Derived>::segment(int start)
template<typename Derived> template<typename Derived>
template<int Size> template<int Size>
inline const VectorBlock<Derived,Size> inline const VectorBlock<Derived,Size>
MatrixBase<Derived>::segment(int start) const DenseBase<Derived>::segment(int start) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived,Size>(derived(), start); return VectorBlock<Derived,Size>(derived(), start);
@ -247,7 +247,7 @@ MatrixBase<Derived>::segment(int start) const
template<typename Derived> template<typename Derived>
template<int Size> template<int Size>
inline VectorBlock<Derived,Size> inline VectorBlock<Derived,Size>
MatrixBase<Derived>::start() DenseBase<Derived>::start()
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived,Size>(derived(), 0); return VectorBlock<Derived,Size>(derived(), 0);
@ -257,7 +257,7 @@ MatrixBase<Derived>::start()
template<typename Derived> template<typename Derived>
template<int Size> template<int Size>
inline const VectorBlock<Derived,Size> inline const VectorBlock<Derived,Size>
MatrixBase<Derived>::start() const DenseBase<Derived>::start() const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived,Size>(derived(), 0); return VectorBlock<Derived,Size>(derived(), 0);
@ -277,7 +277,7 @@ MatrixBase<Derived>::start() const
template<typename Derived> template<typename Derived>
template<int Size> template<int Size>
inline VectorBlock<Derived,Size> inline VectorBlock<Derived,Size>
MatrixBase<Derived>::end() DenseBase<Derived>::end()
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived, Size>(derived(), size() - Size); return VectorBlock<Derived, Size>(derived(), size() - Size);
@ -287,7 +287,7 @@ MatrixBase<Derived>::end()
template<typename Derived> template<typename Derived>
template<int Size> template<int Size>
inline const VectorBlock<Derived,Size> inline const VectorBlock<Derived,Size>
MatrixBase<Derived>::end() const DenseBase<Derived>::end() const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
return VectorBlock<Derived, Size>(derived(), size() - Size); return VectorBlock<Derived, Size>(derived(), size() - Size);

24
Eigen/src/Core/Visitor.h
View File

@ -79,11 +79,11 @@ struct ei_visitor_impl<Visitor, Derived, Dynamic>
* \note compared to one or two \em for \em loops, visitors offer automatic * \note compared to one or two \em for \em loops, visitors offer automatic
* unrolling for small fixed size matrix. * unrolling for small fixed size matrix.
* *
* \sa minCoeff(int*,int*), maxCoeff(int*,int*), MatrixBase::redux() * \sa minCoeff(int*,int*), maxCoeff(int*,int*), DenseBase::redux()
*/ */
template<typename Derived> template<typename Derived>
template<typename Visitor> template<typename Visitor>
void MatrixBase<Derived>::visit(Visitor& visitor) const void DenseBase<Derived>::visit(Visitor& visitor) const
{ {
const bool unroll = SizeAtCompileTime * CoeffReadCost const bool unroll = SizeAtCompileTime * CoeffReadCost
+ (SizeAtCompileTime-1) * ei_functor_traits<Visitor>::Cost + (SizeAtCompileTime-1) * ei_functor_traits<Visitor>::Cost
@ -112,7 +112,7 @@ struct ei_coeff_visitor
/** \internal /** \internal
* \brief Visitor computing the min coefficient with its value and coordinates * \brief Visitor computing the min coefficient with its value and coordinates
* *
* \sa MatrixBase::minCoeff(int*, int*) * \sa DenseBase::minCoeff(int*, int*)
*/ */
template <typename Scalar> template <typename Scalar>
struct ei_min_coeff_visitor : ei_coeff_visitor<Scalar> struct ei_min_coeff_visitor : ei_coeff_visitor<Scalar>
@ -138,7 +138,7 @@ struct ei_functor_traits<ei_min_coeff_visitor<Scalar> > {
/** \internal /** \internal
* \brief Visitor computing the max coefficient with its value and coordinates * \brief Visitor computing the max coefficient with its value and coordinates
* *
* \sa MatrixBase::maxCoeff(int*, int*) * \sa DenseBase::maxCoeff(int*, int*)
*/ */
template <typename Scalar> template <typename Scalar>
struct ei_max_coeff_visitor : ei_coeff_visitor<Scalar> struct ei_max_coeff_visitor : ei_coeff_visitor<Scalar>
@ -164,11 +164,11 @@ struct ei_functor_traits<ei_max_coeff_visitor<Scalar> > {
/** \returns the minimum of all coefficients of *this /** \returns the minimum of all coefficients of *this
* and puts in *row and *col its location. * and puts in *row and *col its location.
* *
* \sa MatrixBase::minCoeff(int*), MatrixBase::maxCoeff(int*,int*), MatrixBase::visitor(), MatrixBase::minCoeff() * \sa DenseBase::minCoeff(int*), DenseBase::maxCoeff(int*,int*), DenseBase::visitor(), DenseBase::minCoeff()
*/ */
template<typename Derived> template<typename Derived>
typename ei_traits<Derived>::Scalar typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::minCoeff(int* row, int* col) const DenseBase<Derived>::minCoeff(int* row, int* col) const
{ {
ei_min_coeff_visitor<Scalar> minVisitor; ei_min_coeff_visitor<Scalar> minVisitor;
this->visit(minVisitor); this->visit(minVisitor);
@ -180,11 +180,11 @@ MatrixBase<Derived>::minCoeff(int* row, int* col) const
/** \returns the minimum of all coefficients of *this /** \returns the minimum of all coefficients of *this
* and puts in *index its location. * and puts in *index its location.
* *
* \sa MatrixBase::minCoeff(int*,int*), MatrixBase::maxCoeff(int*,int*), MatrixBase::visitor(), MatrixBase::minCoeff() * \sa DenseBase::minCoeff(int*,int*), DenseBase::maxCoeff(int*,int*), DenseBase::visitor(), DenseBase::minCoeff()
*/ */
template<typename Derived> template<typename Derived>
typename ei_traits<Derived>::Scalar typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::minCoeff(int* index) const DenseBase<Derived>::minCoeff(int* index) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
ei_min_coeff_visitor<Scalar> minVisitor; ei_min_coeff_visitor<Scalar> minVisitor;
@ -196,11 +196,11 @@ MatrixBase<Derived>::minCoeff(int* index) const
/** \returns the maximum of all coefficients of *this /** \returns the maximum of all coefficients of *this
* and puts in *row and *col its location. * and puts in *row and *col its location.
* *
* \sa MatrixBase::minCoeff(int*,int*), MatrixBase::visitor(), MatrixBase::maxCoeff() * \sa DenseBase::minCoeff(int*,int*), DenseBase::visitor(), DenseBase::maxCoeff()
*/ */
template<typename Derived> template<typename Derived>
typename ei_traits<Derived>::Scalar typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::maxCoeff(int* row, int* col) const DenseBase<Derived>::maxCoeff(int* row, int* col) const
{ {
ei_max_coeff_visitor<Scalar> maxVisitor; ei_max_coeff_visitor<Scalar> maxVisitor;
this->visit(maxVisitor); this->visit(maxVisitor);
@ -212,11 +212,11 @@ MatrixBase<Derived>::maxCoeff(int* row, int* col) const
/** \returns the maximum of all coefficients of *this /** \returns the maximum of all coefficients of *this
* and puts in *index its location. * and puts in *index its location.
* *
* \sa MatrixBase::maxCoeff(int*,int*), MatrixBase::minCoeff(int*,int*), MatrixBase::visitor(), MatrixBase::maxCoeff() * \sa DenseBase::maxCoeff(int*,int*), DenseBase::minCoeff(int*,int*), DenseBase::visitor(), DenseBase::maxCoeff()
*/ */
template<typename Derived> template<typename Derived>
typename ei_traits<Derived>::Scalar typename ei_traits<Derived>::Scalar
MatrixBase<Derived>::maxCoeff(int* index) const DenseBase<Derived>::maxCoeff(int* index) const
{ {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived) EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
ei_max_coeff_visitor<Scalar> maxVisitor; ei_max_coeff_visitor<Scalar> maxVisitor;

1
Eigen/src/Core/util/ForwardDeclarations.h
View File

@ -65,6 +65,7 @@ template<typename MatrixType, unsigned int Mode> class SelfAdjointView;
template<typename ExpressionType> class WithFormat; template<typename ExpressionType> class WithFormat;
template<typename MatrixType> struct CommaInitializer; template<typename MatrixType> struct CommaInitializer;
template<typename Derived> class ReturnByValue; template<typename Derived> class ReturnByValue;
template<typename ExpressionType> class ArrayWrapper;
template<typename DecompositionType, typename Rhs> struct ei_solve_retval_base; template<typename DecompositionType, typename Rhs> struct ei_solve_retval_base;
template<typename DecompositionType, typename Rhs> struct ei_solve_retval; template<typename DecompositionType, typename Rhs> struct ei_solve_retval;

21
Eigen/src/Core/util/Macros.h
View File

@ -281,8 +281,7 @@ using Eigen::ei_cos;
using Base::operator /=; \ using Base::operator /=; \
EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived) EIGEN_INHERIT_ASSIGNMENT_EQUAL_OPERATOR(Derived)
#define _EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, BaseClass) \ #define _EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
typedef BaseClass Base; \
typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; \ typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; \
typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; \ typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; \
typedef typename Base::PacketScalar PacketScalar; \ typedef typename Base::PacketScalar PacketScalar; \
@ -299,7 +298,8 @@ using Eigen::ei_cos;
IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; IsVectorAtCompileTime = Base::IsVectorAtCompileTime };
#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \ #define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
_EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, Eigen::MatrixBase<Derived>) typedef Eigen::MatrixBase<Derived> Base; \
_EIGEN_GENERIC_PUBLIC_INTERFACE(Derived)
#define EIGEN_GENERIC_PUBLIC_INTERFACE_NEW(Derived) \ #define EIGEN_GENERIC_PUBLIC_INTERFACE_NEW(Derived) \
typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; \ typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; \
@ -315,8 +315,7 @@ using Eigen::ei_cos;
IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; IsVectorAtCompileTime = Base::IsVectorAtCompileTime };
#define _EIGEN_DENSE_PUBLIC_INTERFACE(Derived, BaseClass) \ #define _EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \
typedef BaseClass Base; \
typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; \ typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; \
typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; \ typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; \
typedef typename Base::PacketScalar PacketScalar; \ typedef typename Base::PacketScalar PacketScalar; \
@ -334,7 +333,8 @@ using Eigen::ei_cos;
using Base::derived; using Base::derived;
#define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \ #define EIGEN_DENSE_PUBLIC_INTERFACE(Derived) \
_EIGEN_DENSE_PUBLIC_INTERFACE(Derived, Eigen::MatrixBase<Derived>) typedef Eigen::MatrixBase<Derived> Base; \
_EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
#define EIGEN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b) #define EIGEN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
@ -344,4 +344,13 @@ using Eigen::ei_cos;
#define EIGEN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b) #define EIGEN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b)
#define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b))) #define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b)))
#define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR) \
template<typename OtherDerived> \
inline const CwiseBinaryOp<FUNCTOR<Scalar>, Derived, OtherDerived> \
METHOD(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \
{ \
return CwiseBinaryOp<FUNCTOR<Scalar>, Derived, OtherDerived>(derived(), other.derived()); \
}
#endif // EIGEN_MACROS_H #endif // EIGEN_MACROS_H

1
Eigen/src/Core/util/XprHelper.h
View File

@ -133,6 +133,7 @@ struct ei_eval<Matrix<_Scalar, _Rows, _Cols, _StorageOrder, _MaxRows, _MaxCols>,
*/ */
template<typename T> struct ei_plain_matrix_type template<typename T> struct ei_plain_matrix_type
{ {
// typedef typename T::PlainMatrixType type;
typedef Matrix<typename ei_traits<T>::Scalar, typedef Matrix<typename ei_traits<T>::Scalar,
ei_traits<T>::RowsAtCompileTime, ei_traits<T>::RowsAtCompileTime,
ei_traits<T>::ColsAtCompileTime, ei_traits<T>::ColsAtCompileTime,

6
Eigen/src/Geometry/AlignedBox.h
View File

@ -67,7 +67,7 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
inline int dim() const { return AmbientDimAtCompileTime==Dynamic ? m_min.size()-1 : AmbientDimAtCompileTime; } inline int dim() const { return AmbientDimAtCompileTime==Dynamic ? m_min.size()-1 : AmbientDimAtCompileTime; }
/** \returns true if the box is null, i.e, empty. */ /** \returns true if the box is null, i.e, empty. */
inline bool isNull() const { return (m_min.array() > m_max).any(); } inline bool isNull() const { return (m_min.array() > m_max.array()).any(); }
/** Makes \c *this a null/empty box. */ /** Makes \c *this a null/empty box. */
inline void setNull() inline void setNull()
@ -90,11 +90,11 @@ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_AmbientDim)
/** \returns true if the point \a p is inside the box \c *this. */ /** \returns true if the point \a p is inside the box \c *this. */
inline bool contains(const VectorType& p) const inline bool contains(const VectorType& p) const
{ return (m_min.array()<=p).all() && (p.array()<=m_max).all(); } { return (m_min.array()<=p.array()).all() && (p.array()<=m_max.array()).all(); }
/** \returns true if the box \a b is entirely inside the box \c *this. */ /** \returns true if the box \a b is entirely inside the box \c *this. */
inline bool contains(const AlignedBox& b) const inline bool contains(const AlignedBox& b) const
{ return (m_min.array()<=b.min()).all() && (b.max().array()<=m_max).all(); } { return (m_min.array()<=b.min().array()).all() && (b.max().array()<=m_max.array()).all(); }
/** Extends \c *this such that it contains the point \a p and returns a reference to \c *this. */ /** Extends \c *this such that it contains the point \a p and returns a reference to \c *this. */
inline AlignedBox& extend(const VectorType& p) inline AlignedBox& extend(const VectorType& p)

8
Eigen/src/Householder/Householder.h
View File

@ -102,8 +102,8 @@ void MatrixBase<Derived>::applyHouseholderOnTheLeft(
Map<Matrix<Scalar, 1, ColsAtCompileTime, PlainMatrixType::Options, 1, MaxColsAtCompileTime> > tmp(workspace,cols()); Map<Matrix<Scalar, 1, ColsAtCompileTime, PlainMatrixType::Options, 1, MaxColsAtCompileTime> > tmp(workspace,cols());
Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols()); Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols());
tmp.noalias() = essential.adjoint() * bottom; tmp.noalias() = essential.adjoint() * bottom;
tmp += row(0); tmp += this->row(0);
row(0) -= tau * tmp; this->row(0) -= tau * tmp;
bottom.noalias() -= tau * essential * tmp; bottom.noalias() -= tau * essential * tmp;
} }
@ -117,8 +117,8 @@ void MatrixBase<Derived>::applyHouseholderOnTheRight(
Map<Matrix<Scalar, RowsAtCompileTime, 1, PlainMatrixType::Options, MaxRowsAtCompileTime, 1> > tmp(workspace,rows()); Map<Matrix<Scalar, RowsAtCompileTime, 1, PlainMatrixType::Options, MaxRowsAtCompileTime, 1> > tmp(workspace,rows());
Block<Derived, Derived::RowsAtCompileTime, EssentialPart::SizeAtCompileTime> right(derived(), 0, 1, rows(), cols()-1); Block<Derived, Derived::RowsAtCompileTime, EssentialPart::SizeAtCompileTime> right(derived(), 0, 1, rows(), cols()-1);
tmp.noalias() = right * essential.conjugate(); tmp.noalias() = right * essential.conjugate();
tmp += col(0); tmp += this->col(0);
col(0) -= tau * tmp; this->col(0) -= tau * tmp;
right.noalias() -= tau * tmp * essential.transpose(); right.noalias() -= tau * tmp * essential.transpose();
} }

8
Eigen/src/Jacobi/Jacobi.h
View File

@ -279,8 +279,8 @@ template<typename Derived>
template<typename OtherScalar> template<typename OtherScalar>
inline void MatrixBase<Derived>::applyOnTheLeft(int p, int q, const PlanarRotation<OtherScalar>& j) inline void MatrixBase<Derived>::applyOnTheLeft(int p, int q, const PlanarRotation<OtherScalar>& j)
{ {
RowXpr x(row(p)); RowXpr x(this->row(p));
RowXpr y(row(q)); RowXpr y(this->row(q));
ei_apply_rotation_in_the_plane(x, y, j); ei_apply_rotation_in_the_plane(x, y, j);
} }
@ -294,8 +294,8 @@ template<typename Derived>
template<typename OtherScalar> template<typename OtherScalar>
inline void MatrixBase<Derived>::applyOnTheRight(int p, int q, const PlanarRotation<OtherScalar>& j) inline void MatrixBase<Derived>::applyOnTheRight(int p, int q, const PlanarRotation<OtherScalar>& j)
{ {
ColXpr x(col(p)); ColXpr x(this->col(p));
ColXpr y(col(q)); ColXpr y(this->col(q));
ei_apply_rotation_in_the_plane(x, y, j.transpose()); ei_apply_rotation_in_the_plane(x, y, j.transpose());
} }

8
Eigen/src/QR/ColPivHouseholderQR.h
View File

@ -252,7 +252,7 @@ typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::logAbsDetermina
{ {
ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized."); ei_assert(m_isInitialized && "ColPivHouseholderQR is not initialized.");
ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
return m_qr.diagonal().cwise().abs().cwise().log().sum(); return m_qr.diagonal().cwiseAbs().array().log().sum();
} }
template<typename MatrixType> template<typename MatrixType>
@ -311,7 +311,7 @@ ColPivHouseholderQR<MatrixType>& ColPivHouseholderQR<MatrixType>::compute(const
m_qr.corner(BottomRight, rows-k, cols-k-1) m_qr.corner(BottomRight, rows-k, cols-k-1)
.applyHouseholderOnTheLeft(m_qr.col(k).end(rows-k-1), m_hCoeffs.coeffRef(k), &temp.coeffRef(k+1)); .applyHouseholderOnTheLeft(m_qr.col(k).end(rows-k-1), m_hCoeffs.coeffRef(k), &temp.coeffRef(k+1));
colSqNorms.end(cols-k-1) -= m_qr.row(k).end(cols-k-1).cwise().abs2(); colSqNorms.end(cols-k-1) -= m_qr.row(k).end(cols-k-1).cwiseAbs2();
} }
for(int k = 0; k < matrix.cols(); ++k) m_cols_permutation.coeffRef(k) = k; for(int k = 0; k < matrix.cols(); ++k) m_cols_permutation.coeffRef(k) = k;
@ -355,8 +355,8 @@ struct ei_solve_retval<ColPivHouseholderQR<_MatrixType>, Rhs>
if(!dec().isSurjective()) if(!dec().isSurjective())
{ {
// is c is in the image of R ? // is c is in the image of R ?
RealScalar biggest_in_upper_part_of_c = c.corner(TopLeft, dec().rank(), c.cols()).cwise().abs().maxCoeff(); RealScalar biggest_in_upper_part_of_c = c.corner(TopLeft, dec().rank(), c.cols()).cwiseAbs().maxCoeff();
RealScalar biggest_in_lower_part_of_c = c.corner(BottomLeft, rows-dec().rank(), c.cols()).cwise().abs().maxCoeff(); RealScalar biggest_in_lower_part_of_c = c.corner(BottomLeft, rows-dec().rank(), c.cols()).cwiseAbs().maxCoeff();
// FIXME brain dead // FIXME brain dead
const RealScalar m_precision = epsilon<Scalar>() * std::min(rows,cols); const RealScalar m_precision = epsilon<Scalar>() * std::min(rows,cols);
if(!ei_isMuchSmallerThan(biggest_in_lower_part_of_c, biggest_in_upper_part_of_c, m_precision*4)) if(!ei_isMuchSmallerThan(biggest_in_lower_part_of_c, biggest_in_upper_part_of_c, m_precision*4))

8
Eigen/src/QR/FullPivHouseholderQR.h
View File

@ -253,7 +253,7 @@ typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::logAbsDetermin
{ {
ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized."); ei_assert(m_isInitialized && "FullPivHouseholderQR is not initialized.");
ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
return m_qr.diagonal().cwise().abs().cwise().log().sum(); return m_qr.diagonal().cwiseAbs().array().log().sum();
} }
template<typename MatrixType> template<typename MatrixType>
@ -284,7 +284,7 @@ FullPivHouseholderQR<MatrixType>& FullPivHouseholderQR<MatrixType>::compute(cons
RealScalar biggest_in_corner; RealScalar biggest_in_corner;
biggest_in_corner = m_qr.corner(Eigen::BottomRight, rows-k, cols-k) biggest_in_corner = m_qr.corner(Eigen::BottomRight, rows-k, cols-k)
.cwise().abs() .cwiseAbs()
.maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner); .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
row_of_biggest_in_corner += k; row_of_biggest_in_corner += k;
col_of_biggest_in_corner += k; col_of_biggest_in_corner += k;
@ -367,8 +367,8 @@ struct ei_solve_retval<FullPivHouseholderQR<_MatrixType>, Rhs>
if(!dec().isSurjective()) if(!dec().isSurjective())
{ {
// is c is in the image of R ? // is c is in the image of R ?
RealScalar biggest_in_upper_part_of_c = c.corner(TopLeft, dec().rank(), c.cols()).cwise().abs().maxCoeff(); RealScalar biggest_in_upper_part_of_c = c.corner(TopLeft, dec().rank(), c.cols()).cwiseAbs().maxCoeff();
RealScalar biggest_in_lower_part_of_c = c.corner(BottomLeft, rows-dec().rank(), c.cols()).cwise().abs().maxCoeff(); RealScalar biggest_in_lower_part_of_c = c.corner(BottomLeft, rows-dec().rank(), c.cols()).cwiseAbs().maxCoeff();
// FIXME brain dead // FIXME brain dead
const RealScalar m_precision = epsilon<Scalar>() * std::min(rows,cols); const RealScalar m_precision = epsilon<Scalar>() * std::min(rows,cols);
if(!ei_isMuchSmallerThan(biggest_in_lower_part_of_c, biggest_in_upper_part_of_c, m_precision)) if(!ei_isMuchSmallerThan(biggest_in_lower_part_of_c, biggest_in_upper_part_of_c, m_precision))

2
Eigen/src/QR/HouseholderQR.h
View File

@ -177,7 +177,7 @@ typename MatrixType::RealScalar HouseholderQR<MatrixType>::logAbsDeterminant() c
{ {
ei_assert(m_isInitialized && "HouseholderQR is not initialized."); ei_assert(m_isInitialized && "HouseholderQR is not initialized.");
ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!"); ei_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
return m_qr.diagonal().cwise().abs().cwise().log().sum(); return m_qr.diagonal().cwiseAbs().array().log().sum();
} }
template<typename MatrixType> template<typename MatrixType>

7
Eigen/src/SVD/SVD.h
View File

@ -190,7 +190,8 @@ SVD<MatrixType>& SVD<MatrixType>::compute(const MatrixType& matrix)
SingularValuesType& W = m_sigma; SingularValuesType& W = m_sigma;
bool flag; bool flag;
int i,its,j,k,l,nm; int i,its,j,k,nm;
int l=0;
Scalar anorm, c, f, g, h, s, scale, x, y, z; Scalar anorm, c, f, g, h, s, scale, x, y, z;
bool convergence = true; bool convergence = true;
Scalar eps = precision<Scalar>(); Scalar eps = precision<Scalar>();
@ -205,7 +206,7 @@ SVD<MatrixType>& SVD<MatrixType>::compute(const MatrixType& matrix)
g = s = scale = 0.0; g = s = scale = 0.0;
if (i < m) if (i < m)
{ {
scale = A.col(i).end(m-i).cwise().abs().sum(); scale = A.col(i).end(m-i).cwiseAbs().sum();
if (scale != Scalar(0)) if (scale != Scalar(0))
{ {
for (k=i; k<m; k++) for (k=i; k<m; k++)
@ -230,7 +231,7 @@ SVD<MatrixType>& SVD<MatrixType>::compute(const MatrixType& matrix)
g = s = scale = 0.0; g = s = scale = 0.0;
if (i+1 <= m && i+1 != n) if (i+1 <= m && i+1 != n)
{ {
scale = A.row(i).end(n-l+1).cwise().abs().sum(); scale = A.row(i).end(n-l+1).cwiseAbs().sum();
if (scale != Scalar(0)) if (scale != Scalar(0))
{ {
for (k=l-1; k<n; k++) for (k=l-1; k<n; k++)

243
Eigen/src/plugins/ArrayCwiseBinaryOps.h Normal file
View File

@ -0,0 +1,243 @@
/** \returns an expression of the coefficient-wise \< operator of *this and \a other
*
* Example: \include Cwise_less.cpp
* Output: \verbinclude Cwise_less.out
*
* \sa all(), any(), operator>(), operator<=()
*/
EIGEN_MAKE_CWISE_BINARY_OP(operator<,std::less)
/** \returns an expression of the coefficient-wise \<= operator of *this and \a other
*
* Example: \include Cwise_less_equal.cpp
* Output: \verbinclude Cwise_less_equal.out
*
* \sa all(), any(), operator>=(), operator<()
*/
EIGEN_MAKE_CWISE_BINARY_OP(operator<=,std::less_equal)
// template<typename ExpressionType>
// template<typename OtherDerived>
// inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
// operator<=(const MatrixBase<OtherDerived> &other) const
// {
// return EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)(_expression(), other.derived());
// }
/** \returns an expression of the coefficient-wise \> operator of *this and \a other
*
* Example: \include Cwise_greater.cpp
* Output: \verbinclude Cwise_greater.out
*
* \sa all(), any(), operator>=(), operator<()
*/
EIGEN_MAKE_CWISE_BINARY_OP(operator>,std::greater)
// template<typename ExpressionType>
// template<typename OtherDerived>
// inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
// operator>(const MatrixBase<OtherDerived> &other) const
// {
// return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)(_expression(), other.derived());
// }
/** \returns an expression of the coefficient-wise \>= operator of *this and \a other
*
* Example: \include Cwise_greater_equal.cpp
* Output: \verbinclude Cwise_greater_equal.out
*
* \sa all(), any(), operator>(), operator<=()
*/
EIGEN_MAKE_CWISE_BINARY_OP(operator>=,std::greater_equal)
// template<typename ExpressionType>
// template<typename OtherDerived>
// inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
// operator>=(const MatrixBase<OtherDerived> &other) const
// {
// return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)(_expression(), other.derived());
// }
/** \returns an expression of the coefficient-wise == operator of *this and \a other
*
* \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 isApprox() and
* isMuchSmallerThan().
*
* Example: \include Cwise_equal_equal.cpp
* Output: \verbinclude Cwise_equal_equal.out
*
* \sa all(), any(), isApprox(), isMuchSmallerThan()
*/
EIGEN_MAKE_CWISE_BINARY_OP(operator==,std::equal_to)
// template<typename ExpressionType>
// template<typename OtherDerived>
// inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
// operator==(const MatrixBase<OtherDerived> &other) const
// {
// return EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)(_expression(), other.derived());
// }
/** \returns an expression of the coefficient-wise != operator of *this and \a other
*
* \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 isApprox() and
* isMuchSmallerThan().
*
* Example: \include Cwise_not_equal.cpp
* Output: \verbinclude Cwise_not_equal.out
*
* \sa all(), any(), isApprox(), isMuchSmallerThan()
*/
EIGEN_MAKE_CWISE_BINARY_OP(operator!=,std::not_equal_to)
// template<typename ExpressionType>
// template<typename OtherDerived>
// inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
// operator!=(const MatrixBase<OtherDerived> &other) const
// {
// return EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)(_expression(), other.derived());
// }
// comparisons to scalar value
#if 0
/** \returns an expression of the coefficient-wise \< operator of *this and a scalar \a s
*
* \sa operator<(const MatrixBase<OtherDerived> &) const
*/
template<typename ExpressionType>
inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)
operator<(Scalar s) const
{
return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)(_expression(),
typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
}
/** \returns an expression of the coefficient-wise \<= operator of *this and a scalar \a s
*
* \sa operator<=(const MatrixBase<OtherDerived> &) const
*/
template<typename ExpressionType>
inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)
operator<=(Scalar s) const
{
return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)(_expression(),
typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
}
/** \returns an expression of the coefficient-wise \> operator of *this and a scalar \a s
*
* \sa operator>(const MatrixBase<OtherDerived> &) const
*/
template<typename ExpressionType>
inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)
operator>(Scalar s) const
{
return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)(_expression(),
typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
}
/** \returns an expression of the coefficient-wise \>= operator of *this and a scalar \a s
*
* \sa operator>=(const MatrixBase<OtherDerived> &) const
*/
template<typename ExpressionType>
inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)
operator>=(Scalar s) const
{
return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)(_expression(),
typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
}
/** \returns an expression of the coefficient-wise == operator of *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 isApprox() and
* isMuchSmallerThan().
*
* \sa operator==(const MatrixBase<OtherDerived> &) const
*/
template<typename ExpressionType>
inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)
operator==(Scalar s) const
{
return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)(_expression(),
typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
}
/** \returns an expression of the coefficient-wise != operator of *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 isApprox() and
* isMuchSmallerThan().
*
* \sa operator!=(const MatrixBase<OtherDerived> &) const
*/
template<typename ExpressionType>
inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)
operator!=(Scalar s) const
{
return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)(_expression(),
typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
}
#endif
// scalar addition
/** \returns an expression of \c *this with each coeff incremented by the constant \a scalar
*
* Example: \include Cwise_plus.cpp
* Output: \verbinclude Cwise_plus.out
*
* \sa operator+=(), operator-()
*/
inline const CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived>
operator+(const Scalar& scalar) const
{
return CwiseUnaryOp<ei_scalar_add_op<Scalar>, Derived>(derived(), ei_scalar_add_op<Scalar>(scalar));
}
/** Adds the given \a scalar to each coeff of this expression.
*
* Example: \include Cwise_plus_equal.cpp
* Output: \verbinclude Cwise_plus_equal.out
*
* \sa operator+(), operator-=()
*/
// template<typename ExpressionType>
// inline ExpressionType& operator+=(const Scalar& scalar)
// {
// return m_matrix.const_cast_derived() = *this + scalar;
// }
/** \returns an expression of \c *this with each coeff decremented by the constant \a scalar
*
* Example: \include Cwise_minus.cpp
* Output: \verbinclude Cwise_minus.out
*
* \sa operator+(), operator-=()
*/
// template<typename ExpressionType>
// inline const typename ScalarAddReturnType
// operator-(const Scalar& scalar) const
// {
// return *this + (-scalar);
// }
/** Substracts the given \a scalar from each coeff of this expression.
*
* Example: \include Cwise_minus_equal.cpp
* Output: \verbinclude Cwise_minus_equal.out
*
* \sa operator+=(), operator-()
*/
// template<typename ExpressionType>
// inline ExpressionType& operator-=(const Scalar& scalar)
// {
// return m_matrix.const_cast_derived() = *this - scalar;
// }

148
Eigen/src/plugins/ArrayCwiseUnaryOps.h Normal file
View File

@ -0,0 +1,148 @@
/** \returns an expression of the coefficient-wise absolute value of \c *this
*
* Example: \include Cwise_abs.cpp
* Output: \verbinclude Cwise_abs.out
*
* \sa abs2()
*/
EIGEN_STRONG_INLINE const CwiseUnaryOp<ei_scalar_abs_op<Scalar>, Derived>
abs() const
{
return derived();
}
/** \returns an expression of the coefficient-wise squared absolute value of \c *this
*
* Example: \include Cwise_abs2.cpp
* Output: \verbinclude Cwise_abs2.out
*
* \sa abs(), square()
*/
EIGEN_STRONG_INLINE const CwiseUnaryOp<ei_scalar_abs2_op<Scalar>, Derived>
abs2() const
{
return derived();
}
/** \returns an expression of the coefficient-wise exponential of *this.
*
* Example: \include Cwise_exp.cpp
* Output: \verbinclude Cwise_exp.out
*
* \sa pow(), log(), sin(), cos()
*/
inline const CwiseUnaryOp<ei_scalar_exp_op<Scalar>, Derived>
exp() const
{
return derived();
}
/** \returns an expression of the coefficient-wise logarithm of *this.
*
* Example: \include Cwise_log.cpp
* Output: \verbinclude Cwise_log.out
*
* \sa exp()
*/
inline const CwiseUnaryOp<ei_scalar_log_op<Scalar>, Derived>
log() const
{
return derived();
}
/** \returns an expression of the coefficient-wise square root of *this.
*
* Example: \include Cwise_sqrt.cpp
* Output: \verbinclude Cwise_sqrt.out
*
* \sa pow(), square()
*/
inline const CwiseUnaryOp<ei_scalar_sqrt_op<Scalar>, Derived>
sqrt() const
{
return derived();
}
/** \returns an expression of the coefficient-wise cosine of *this.
*
* Example: \include Cwise_cos.cpp
* Output: \verbinclude Cwise_cos.out
*
* \sa sin(), exp()
*/
inline const CwiseUnaryOp<ei_scalar_cos_op<Scalar>, Derived>
cos() const
{
return derived();
}
/** \returns an expression of the coefficient-wise sine of *this.
*
* Example: \include Cwise_sin.cpp
* Output: \verbinclude Cwise_sin.out
*
* \sa cos(), exp()
*/
inline const CwiseUnaryOp<ei_scalar_sin_op<Scalar>, Derived>
sin() const
{
return derived();
}
/** \returns an expression of the coefficient-wise power of *this to the given exponent.
*
* Example: \include Cwise_pow.cpp
* Output: \verbinclude Cwise_pow.out
*
* \sa exp(), log()
*/
inline const CwiseUnaryOp<ei_scalar_pow_op<Scalar>, Derived>
pow(const Scalar& exponent) const
{
return CwiseUnaryOp<ei_scalar_pow_op<Scalar>,Derived>
(derived(), ei_scalar_pow_op<Scalar>(exponent));
}
/** \returns an expression of the coefficient-wise inverse of *this.
*
* Example: \include Cwise_inverse.cpp
* Output: \verbinclude Cwise_inverse.out
*
* \sa operator/(), operator*()
*/
inline const CwiseUnaryOp<ei_scalar_inverse_op<Scalar>, Derived>
inverse() const
{
return derived();
}
/** \returns an expression of the coefficient-wise square of *this.
*
* Example: \include Cwise_square.cpp
* Output: \verbinclude Cwise_square.out
*
* \sa operator/(), operator*(), abs2()
*/
inline const CwiseUnaryOp<ei_scalar_square_op<Scalar>, Derived>
square() const
{
return derived();
}
/** \returns an expression of the coefficient-wise cube of *this.
*
* Example: \include Cwise_cube.cpp
* Output: \verbinclude Cwise_cube.out
*
* \sa square(), pow()
*/
inline const CwiseUnaryOp<ei_scalar_cube_op<Scalar>, Derived>
cube() const
{
return derived();
}

16
Eigen/src/plugins/CommonCwiseBinaryOps.h
View File

@ -31,14 +31,7 @@
* *
* \sa class CwiseBinaryOp, MatrixBase::operator-=() * \sa class CwiseBinaryOp, MatrixBase::operator-=()
*/ */
template<typename OtherDerived> EIGEN_MAKE_CWISE_BINARY_OP(operator-,ei_scalar_difference_op)
EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_difference_op<typename ei_traits<Derived>::Scalar>,
Derived, OtherDerived>
operator-(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{
return CwiseBinaryOp<ei_scalar_difference_op<Scalar>,
Derived, OtherDerived>(derived(), other.derived());
}
/** \returns an expression of the sum of \c *this and \a other /** \returns an expression of the sum of \c *this and \a other
* *
@ -46,12 +39,7 @@ operator-(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
* *
* \sa class CwiseBinaryOp, MatrixBase::operator+=() * \sa class CwiseBinaryOp, MatrixBase::operator+=()
*/ */
template<typename OtherDerived> EIGEN_MAKE_CWISE_BINARY_OP(operator+,ei_scalar_sum_op)
EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived>
operator+(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const
{
return CwiseBinaryOp<ei_scalar_sum_op<Scalar>, Derived, OtherDerived>(derived(), other.derived());
}
/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
* *

1
test/geo_alignedbox.cpp
View File

@ -22,7 +22,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>
#include <Eigen/LU> #include <Eigen/LU>

1
test/geo_eulerangles.cpp
View File

@ -22,7 +22,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>
#include <Eigen/LU> #include <Eigen/LU>

1
test/geo_homogeneous.cpp
View File

@ -22,7 +22,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>

1
test/geo_hyperplane.cpp
View File

@ -23,7 +23,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>
#include <Eigen/LU> #include <Eigen/LU>

1
test/geo_orthomethods.cpp
View File

@ -22,7 +22,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>
#include <Eigen/LU> #include <Eigen/LU>

1
test/geo_parametrizedline.cpp
View File

@ -23,7 +23,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>
#include <Eigen/LU> #include <Eigen/LU>

3
test/geo_quaternion.cpp
View File

@ -23,7 +23,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>
#include <Eigen/LU> #include <Eigen/LU>
@ -96,7 +95,7 @@ template<typename Scalar> void quaternion(void)
VERIFY_IS_APPROX(-v1.normalized(),(q2.setFromTwoVectors(v1,-v1)*v1).normalized()); VERIFY_IS_APPROX(-v1.normalized(),(q2.setFromTwoVectors(v1,-v1)*v1).normalized());
if (ei_is_same_type<Scalar,double>::ret) if (ei_is_same_type<Scalar,double>::ret)
{ {
v3 = v1.cwise()+eps; v3 = v1.array()+eps;
VERIFY_IS_APPROX( v3.normalized(),(q2.setFromTwoVectors(v1, v3)*v1).normalized()); VERIFY_IS_APPROX( v3.normalized(),(q2.setFromTwoVectors(v1, v3)*v1).normalized());
VERIFY_IS_APPROX(-v3.normalized(),(q2.setFromTwoVectors(v1,-v3)*v1).normalized()); VERIFY_IS_APPROX(-v3.normalized(),(q2.setFromTwoVectors(v1,-v3)*v1).normalized());
} }

1
test/geo_transformations.cpp
View File

@ -22,7 +22,6 @@
// License and a copy of the GNU General Public License along with // License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>. // Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h" #include "main.h"
#include <Eigen/Geometry> #include <Eigen/Geometry>
#include <Eigen/LU> #include <Eigen/LU>