Eigen  3.4.90 (git rev a4098ac676528a83cfb73d4d26ce1b42ec05f47c)
Eigen::DenseBase< Derived > Class Template Reference

## Detailed Description

template<typename Derived>
class Eigen::DenseBase< Derived >

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 related expression types). The common Eigen API for dense objects is contained in this class.

Template Parameters
 Derived is the derived type, e.g., a matrix type or an expression.

This class can be extended with the help of the plugin mechanism described on the page Extending MatrixBase (and other classes) by defining the preprocessor symbol EIGEN_DENSEBASE_PLUGIN.

The class hierarchy
Inheritance diagram for Eigen::DenseBase< Derived >:

## Public Types

enum  {
RowsAtCompileTime ,
ColsAtCompileTime ,
SizeAtCompileTime ,
MaxRowsAtCompileTime ,
MaxColsAtCompileTime ,
MaxSizeAtCompileTime ,
IsVectorAtCompileTime ,
NumDimensions ,
Flags ,
IsRowMajor ,
InnerSizeAtCompileTime ,
InnerStrideAtCompileTime ,
OuterStrideAtCompileTime
}

typedef random_access_iterator_type const_iterator

typedef random_access_iterator_type iterator

typedef Array< typename internal::traits< Derived >::Scalar, internal::traits< Derived >::RowsAtCompileTime, internal::traits< Derived >::ColsAtCompileTime, AutoAlign|(internal::traits< Derived >::Flags &RowMajorBit ? RowMajor :ColMajor), internal::traits< Derived >::MaxRowsAtCompileTime, internal::traits< Derived >::MaxColsAtCompileTimePlainArray

typedef Matrix< typename internal::traits< Derived >::Scalar, internal::traits< Derived >::RowsAtCompileTime, internal::traits< Derived >::ColsAtCompileTime, AutoAlign|(internal::traits< Derived >::Flags &RowMajorBit ? RowMajor :ColMajor), internal::traits< Derived >::MaxRowsAtCompileTime, internal::traits< Derived >::MaxColsAtCompileTimePlainMatrix

typedef internal::conditional< internal::is_same< typenameinternal::traits< Derived >::XprKind, MatrixXpr >::value, PlainMatrix, PlainArray >::type PlainObject
The plain matrix or array type corresponding to this expression. More...

typedef internal::traits< Derived >::Scalar Scalar

typedef internal::traits< Derived >::StorageIndex StorageIndex
The type used to store indices. More...

typedef Scalar value_type

Public Types inherited from Eigen::EigenBase< Derived >
typedef Eigen::Index Index
The interface type of indices. More...

## Public Member Functions

bool all () const

bool allFinite () const

bool any () const

iterator begin ()

const_iterator begin () const

const_iterator cbegin () const

const_iterator cend () const

ColwiseReturnType colwise ()

ConstColwiseReturnType colwise () const

Index count () const

iterator end ()

const_iterator end () const

EvalReturnType eval () const

void fill (const Scalar &value)

template<unsigned int Added, unsigned int Removed>
EIGEN_DEPRECATED const Derived & flagged () const

const WithFormat< Derived > format (const IOFormat &fmt) const

bool hasNaN () const

EIGEN_CONSTEXPR Index innerSize () const

template<typename OtherDerived >
bool isApprox (const DenseBase< OtherDerived > &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

bool isApproxToConstant (const Scalar &value, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

bool isConstant (const Scalar &value, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

template<typename OtherDerived >
bool isMuchSmallerThan (const DenseBase< OtherDerived > &other, const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

template<typename Derived >
bool isMuchSmallerThan (const typename NumTraits< Scalar >::Real &other, const RealScalar &prec) const

bool isOnes (const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

bool isZero (const RealScalar &prec=NumTraits< Scalar >::dummy_precision()) const

template<typename OtherDerived >
EIGEN_DEPRECATED Derived & lazyAssign (const DenseBase< OtherDerived > &other)

template<int NaNPropagation>
internal::traits< Derived >::Scalar maxCoeff () const

template<int NaNPropagation, typename IndexType >
internal::traits< Derived >::Scalar maxCoeff (IndexType *index) const

template<int NaNPropagation, typename IndexType >
internal::traits< Derived >::Scalar maxCoeff (IndexType *row, IndexType *col) const

Scalar mean () const

template<int NaNPropagation>
internal::traits< Derived >::Scalar minCoeff () const

template<int NaNPropagation, typename IndexType >
internal::traits< Derived >::Scalar minCoeff (IndexType *index) const

template<int NaNPropagation, typename IndexType >
internal::traits< Derived >::Scalar minCoeff (IndexType *row, IndexType *col) const

const NestByValue< Derived > nestByValue () const

template<typename OtherDerived >
CommaInitializer< Derived > operator<< (const DenseBase< OtherDerived > &other)

CommaInitializer< Derived > operator<< (const Scalar &s)

Derived & operator= (const DenseBase &other)

template<typename OtherDerived >
Derived & operator= (const DenseBase< OtherDerived > &other)

template<typename OtherDerived >
Derived & operator= (const EigenBase< OtherDerived > &other)
Copies the generic expression other into *this. More...

EIGEN_CONSTEXPR Index outerSize () const

Scalar prod () const

template<typename Func >
internal::traits< Derived >::Scalar redux (const Func &func) const

template<int RowFactor, int ColFactor>
const Replicate< Derived, RowFactor, ColFactor > replicate () const

const Replicate< Derived, Dynamic, Dynamicreplicate (Index rowFactor, Index colFactor) const

void resize (Index newSize)

void resize (Index rows, Index cols)

ReverseReturnType reverse ()

ConstReverseReturnType reverse () const

void reverseInPlace ()

RowwiseReturnType rowwise ()

ConstRowwiseReturnType rowwise () const

template<typename ThenDerived , typename ElseDerived >
const Select< Derived, ThenDerived, ElseDerived > select (const DenseBase< ThenDerived > &thenMatrix, const DenseBase< ElseDerived > &elseMatrix) const

template<typename ThenDerived >
const Select< Derived, ThenDerived, typename ThenDerived::ConstantReturnType > select (const DenseBase< ThenDerived > &thenMatrix, const typename ThenDerived::Scalar &elseScalar) const

template<typename ElseDerived >
const Select< Derived, typename ElseDerived::ConstantReturnType, ElseDerived > select (const typename ElseDerived::Scalar &thenScalar, const DenseBase< ElseDerived > &elseMatrix) const

Derived & setConstant (const Scalar &value)

Derived & setLinSpaced (const Scalar &low, const Scalar &high)
Sets a linearly spaced vector. More...

Derived & setLinSpaced (Index size, const Scalar &low, const Scalar &high)
Sets a linearly spaced vector. More...

Derived & setOnes ()

Derived & setRandom ()

Derived & setZero ()

Scalar sum () const

template<typename OtherDerived >
void swap (const DenseBase< OtherDerived > &other)

template<typename OtherDerived >
void swap (PlainObjectBase< OtherDerived > &other)

TransposeReturnType transpose ()

ConstTransposeReturnType transpose () const

void transposeInPlace ()

CoeffReturnType value () const

template<typename Visitor >
void visit (Visitor &func) const

Public Member Functions inherited from Eigen::DenseCoeffsBase< Derived, DirectWriteAccessors >
EIGEN_CONSTEXPR Index cols () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index colStride () const EIGEN_NOEXCEPT

Derived & derived ()

const Derived & derived () const

EIGEN_CONSTEXPR Index innerStride () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index outerStride () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index rows () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index rowStride () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index size () const EIGEN_NOEXCEPT

Public Member Functions inherited from Eigen::DenseCoeffsBase< Derived, WriteAccessors >
Scalar & coeffRef (Index index)

Scalar & coeffRef (Index row, Index col)

EIGEN_CONSTEXPR Index cols () const EIGEN_NOEXCEPT

Derived & derived ()

const Derived & derived () const

Scalar & operator() (Index index)

Scalar & operator() (Index row, Index col)

Scalar & operator[] (Index index)

EIGEN_CONSTEXPR Index rows () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index size () const EIGEN_NOEXCEPT

Scalar & w ()

Scalar & x ()

Scalar & y ()

Scalar & z ()

Public Member Functions inherited from Eigen::DenseCoeffsBase< Derived, ReadOnlyAccessors >
CoeffReturnType coeff (Index index) const

CoeffReturnType coeff (Index row, Index col) const

EIGEN_CONSTEXPR Index cols () const EIGEN_NOEXCEPT

Derived & derived ()

const Derived & derived () const

CoeffReturnType operator() (Index index) const

CoeffReturnType operator() (Index row, Index col) const

CoeffReturnType operator[] (Index index) const

EIGEN_CONSTEXPR Index rows () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index size () const EIGEN_NOEXCEPT

CoeffReturnType w () const

CoeffReturnType x () const

CoeffReturnType y () const

CoeffReturnType z () const

Public Member Functions inherited from Eigen::EigenBase< Derived >
EIGEN_CONSTEXPR Index cols () const EIGEN_NOEXCEPT

Derived & derived ()

const Derived & derived () const

EIGEN_CONSTEXPR Index rows () const EIGEN_NOEXCEPT

EIGEN_CONSTEXPR Index size () const EIGEN_NOEXCEPT

## Static Public Member Functions

static const ConstantReturnType Constant (const Scalar &value)

static const ConstantReturnType Constant (Index rows, Index cols, const Scalar &value)

static const ConstantReturnType Constant (Index size, const Scalar &value)

static const RandomAccessLinSpacedReturnType LinSpaced (const Scalar &low, const Scalar &high)
Sets a linearly spaced vector. More...

static const RandomAccessLinSpacedReturnType LinSpaced (Index size, const Scalar &low, const Scalar &high)
Sets a linearly spaced vector. More...

static EIGEN_DEPRECATED const RandomAccessLinSpacedReturnType LinSpaced (Sequential_t, const Scalar &low, const Scalar &high)

static EIGEN_DEPRECATED const RandomAccessLinSpacedReturnType LinSpaced (Sequential_t, Index size, const Scalar &low, const Scalar &high)

template<typename CustomNullaryOp >
static const CwiseNullaryOp< CustomNullaryOp, PlainObjectNullaryExpr (const CustomNullaryOp &func)

template<typename CustomNullaryOp >
static const CwiseNullaryOp< CustomNullaryOp, PlainObjectNullaryExpr (Index rows, Index cols, const CustomNullaryOp &func)

template<typename CustomNullaryOp >
static const CwiseNullaryOp< CustomNullaryOp, PlainObjectNullaryExpr (Index size, const CustomNullaryOp &func)

static const ConstantReturnType Ones ()

static const ConstantReturnType Ones (Index rows, Index cols)

static const ConstantReturnType Ones (Index size)

static const RandomReturnType Random ()

static const RandomReturnType Random (Index rows, Index cols)

static const RandomReturnType Random (Index size)

static const ConstantReturnType Zero ()

static const ConstantReturnType Zero (Index rows, Index cols)

static const ConstantReturnType Zero (Index size)

DenseBase ()

## Related Functions

(Note that these are not member functions.)

template<typename Derived >
std::ostream & operator<< (std::ostream &s, const DenseBase< Derived > &m)

## ◆ const_iterator

template<typename Derived >
 typedef random_access_iterator_type Eigen::DenseBase< Derived >::const_iterator

This is the const version of iterator (aka read-only)

## ◆ iterator

template<typename Derived >
 typedef random_access_iterator_type Eigen::DenseBase< Derived >::iterator

STL-like RandomAccessIterator iterator type as returned by the begin() and end() methods.

## ◆ PlainArray

template<typename Derived >
 typedef Array::Scalar, internal::traits::RowsAtCompileTime, internal::traits::ColsAtCompileTime, AutoAlign | (internal::traits::Flags&RowMajorBit ? RowMajor : ColMajor), internal::traits::MaxRowsAtCompileTime, internal::traits::MaxColsAtCompileTime > Eigen::DenseBase< Derived >::PlainArray

The plain array type corresponding to this expression.

PlainObject

## ◆ PlainMatrix

template<typename Derived >
 typedef Matrix::Scalar, internal::traits::RowsAtCompileTime, internal::traits::ColsAtCompileTime, AutoAlign | (internal::traits::Flags&RowMajorBit ? RowMajor : ColMajor), internal::traits::MaxRowsAtCompileTime, internal::traits::MaxColsAtCompileTime > Eigen::DenseBase< Derived >::PlainMatrix

The plain matrix type corresponding to this expression.

PlainObject

## ◆ PlainObject

template<typename Derived >
 typedef internal::conditional::XprKind,MatrixXpr>::value,PlainMatrix,PlainArray>::type Eigen::DenseBase< Derived >::PlainObject

The plain matrix or array type corresponding to this expression.

This 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 PlainObject or const PlainObject&.

## ◆ Scalar

template<typename Derived >
 typedef internal::traits::Scalar Eigen::DenseBase< Derived >::Scalar

The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.

## ◆ StorageIndex

template<typename Derived >
 typedef internal::traits::StorageIndex Eigen::DenseBase< Derived >::StorageIndex

The type used to store indices.

This typedef is relevant for types that store multiple indices such as PermutationMatrix or Transpositions, otherwise it defaults to Eigen::Index

Preprocessor directives, Eigen::Index, SparseMatrixBase.

## ◆ value_type

template<typename Derived >
 typedef Scalar Eigen::DenseBase< Derived >::value_type

The numeric type of the expression' coefficients, e.g. float, double, int or std::complex<float>, etc.

It is an alias for the Scalar type

## ◆ anonymous enum

template<typename Derived >
 anonymous enum
Enumerator
RowsAtCompileTime

The number of rows at compile-time. This is just a copy of the value provided by the Derived type. If a value is not known at compile-time, it is set to the Dynamic constant.

MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime
ColsAtCompileTime

The number of columns at compile-time. This is just a copy of the value provided by the Derived type. If a value is not known at compile-time, it is set to the Dynamic constant.

MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime
SizeAtCompileTime

This is equal to the number of coefficients, i.e. the number of rows times the number of columns, or to Dynamic if this is not known at compile-time.

RowsAtCompileTime, ColsAtCompileTime
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 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.

RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
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 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.

ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
MaxSizeAtCompileTime

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

SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
IsVectorAtCompileTime

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).

NumDimensions

This value is equal to Tensor::NumDimensions, i.e. 0 for scalars, 1 for vectors, and 2 for matrices.

Flags

This stores expression Flags flags which may or may not be inherited by new expressions constructed from this one. See the list of flags.

IsRowMajor

True if this expression has row-major storage order.

## ◆ DenseBase()

template<typename Derived >
 Eigen::DenseBase< Derived >::DenseBase ( )
inlineprotected

Default constructor. Do nothing.

## ◆ all()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::all
inline
Returns
true if all coefficients are true

Example:

Vector3f boxMin(Vector3f::Zero()), boxMax(Vector3f::Ones());
Vector3f p0 = Vector3f::Random(), p1 = Vector3f::Random().cwiseAbs();
// let's check if p0 and p1 are inside the axis aligned box defined by the corners boxMin,boxMax:
cout << "Is (" << p0.transpose() << ") inside the box: "
<< ((boxMin.array()<p0.array()).all() && (boxMax.array()>p0.array()).all()) << endl;
cout << "Is (" << p1.transpose() << ") inside the box: "
<< ((boxMin.array()<p1.array()).all() && (boxMax.array()>p1.array()).all()) << endl;
static const ConstantReturnType Ones()
Definition: CwiseNullaryOp.h:672
static const ConstantReturnType Zero()
Definition: CwiseNullaryOp.h:516
bool all() const
Definition: BooleanRedux.h:81
static const RandomReturnType Random()
Definition: Random.h:115

Output:

Is (    -1 -0.737  0.511) inside the box: 0
Is (0.0827 0.0655  0.562) inside the box: 1

any(), Cwise::operator<()

## ◆ allFinite()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::allFinite
inline
Returns
true if *this contains only finite numbers, i.e., no NaN and no +/-INF values.
hasNaN()

## ◆ any()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::any
inline
Returns
true if at least one coefficient is true
all()

## ◆ begin() [1/2]

template<typename Derived >
 DenseBase< Derived >::iterator Eigen::DenseBase< Derived >::begin
inline

returns an iterator to the first element of the 1D vector or array This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

end(), cbegin()

## ◆ begin() [2/2]

template<typename Derived >
 DenseBase< Derived >::const_iterator Eigen::DenseBase< Derived >::begin
inline

const version of begin()

## ◆ cbegin()

template<typename Derived >
 DenseBase< Derived >::const_iterator Eigen::DenseBase< Derived >::cbegin
inline

returns a read-only const_iterator to the first element of the 1D vector or array This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

cend(), begin()

## ◆ cend()

template<typename Derived >
 DenseBase< Derived >::const_iterator Eigen::DenseBase< Derived >::cend
inline

returns a read-only const_iterator to the element following the last element of the 1D vector or array This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

begin(), cend()

## ◆ colwise() [1/2]

template<typename Derived >
 DenseBase< Derived >::ColwiseReturnType Eigen::DenseBase< Derived >::colwise
inline
Returns
a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
rowwise(), class VectorwiseOp, Reductions, visitors and broadcasting

## ◆ colwise() [2/2]

template<typename Derived >
 ConstColwiseReturnType Eigen::DenseBase< Derived >::colwise ( ) const
inline
Returns
a VectorwiseOp wrapper of *this broadcasting and partial reductions

Example:

Matrix3d m = Matrix3d::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the sum of each column:" << endl << m.colwise().sum() << endl;
cout << "Here is the maximum absolute value of each column:"
<< endl << m.cwiseAbs().colwise().maxCoeff() << endl;

Output:

Here is the matrix m:
-1 -0.0827  -0.906
-0.737  0.0655   0.358
0.511  -0.562   0.359
Here is the sum of each column:
-1.23 -0.579  -0.19
Here is the maximum absolute value of each column:
1 0.562 0.906

rowwise(), class VectorwiseOp, Reductions, visitors and broadcasting

## ◆ Constant() [1/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Constant ( const Scalar & value )
inlinestatic
Returns
an expression of a constant matrix of value value

This variant is only for fixed-size DenseBase types. For dynamic-size types, you need to use the variants taking size arguments.

The template parameter CustomNullaryOp is the type of the functor.

class CwiseNullaryOp

## ◆ Constant() [2/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Constant ( Index rows, Index cols, const Scalar & value )
inlinestatic
Returns
an expression of a constant matrix of value value

The parameters rows and cols are the number of rows and of columns of 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, it is redundant to pass rows and cols as arguments, so Zero() should be used instead.

The template parameter CustomNullaryOp is the type of the functor.

class CwiseNullaryOp

## ◆ Constant() [3/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Constant ( Index size, const Scalar & value )
inlinestatic
Returns
an expression of a constant matrix of value value

The parameter size is the size of the returned vector. Must be compatible with this DenseBase type.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

This variant is meant to be used for dynamic-size vector types. For fixed-size types, it is redundant to pass size as argument, so Zero() should be used instead.

The template parameter CustomNullaryOp is the type of the functor.

class CwiseNullaryOp

## ◆ count()

template<typename Derived >
 Eigen::Index Eigen::DenseBase< Derived >::count
inline
Returns
the number of coefficients which evaluate to true
all(), any()

## ◆ end() [1/2]

template<typename Derived >
 DenseBase< Derived >::iterator Eigen::DenseBase< Derived >::end
inline

returns an iterator to the element following the last element of the 1D vector or array This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

begin(), cend()

## ◆ end() [2/2]

template<typename Derived >
 DenseBase< Derived >::const_iterator Eigen::DenseBase< Derived >::end
inline

const version of end()

## ◆ eval()

template<typename Derived >
 EvalReturnType Eigen::DenseBase< Derived >::eval ( ) const
inline
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.

Warning
Be careful with eval() and the auto C++ keyword, as detailed in this page .

## ◆ fill()

template<typename Derived >
 void Eigen::DenseBase< Derived >::fill ( const Scalar & val )
inline

Alias for setConstant(): sets all coefficients in this expression to val.

setConstant(), Constant(), class CwiseNullaryOp

## ◆ flagged()

template<typename Derived >
template<unsigned int Added, unsigned int Removed>
 EIGEN_DEPRECATED const Derived & Eigen::DenseBase< Derived >::flagged ( ) const
inline
Deprecated:
it now returns *this

## ◆ format()

template<typename Derived >
 const WithFormat< Derived > Eigen::DenseBase< Derived >::format ( const IOFormat & fmt ) const
inline
Returns
a WithFormat proxy object allowing to print a matrix the with given format fmt.

See class IOFormat for some examples.

class IOFormat, class WithFormat

## ◆ hasNaN()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::hasNaN
inline
Returns
true is *this contains at least one Not A Number (NaN).
allFinite()

## ◆ innerSize()

template<typename Derived >
 EIGEN_CONSTEXPR Index Eigen::DenseBase< Derived >::innerSize ( ) const
inline
Returns
the inner size.
Note
For a vector, this is just the size. For a matrix (non-vector), this is the minor dimension with respect to the storage order, i.e., the number of rows for a column-major matrix, and the number of columns for a row-major matrix.

## ◆ isApprox()

template<typename Derived >
template<typename OtherDerived >
 bool Eigen::DenseBase< Derived >::isApprox ( const DenseBase< OtherDerived > & other, const RealScalar & prec = NumTraits::dummy_precision() ) const
Returns
true if *this is approximately equal to other, within the precision determined by prec.
Note
The fuzzy compares are done multiplicatively. Two vectors $$v$$ and $$w$$ are considered to be approximately equal within precision $$p$$ if

$\Vert v - w \Vert \leqslant p\,\min(\Vert v\Vert, \Vert w\Vert).$

For matrices, the comparison is done using the Hilbert-Schmidt norm (aka Frobenius norm L2 norm).
Because of the multiplicativeness of this comparison, one can't use this function to check whether *this is approximately equal to the zero matrix or vector. Indeed, isApprox(zero) returns false unless *this itself is exactly the zero matrix or vector. If you want to test whether *this is zero, use internal::isMuchSmallerThan(const RealScalar&, RealScalar) instead.
internal::isMuchSmallerThan(const RealScalar&, RealScalar) const

## ◆ isApproxToConstant()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::isApproxToConstant ( const Scalar & val, const RealScalar & prec = NumTraits::dummy_precision() ) const
Returns
true if all coefficients in this matrix are approximately equal to val, to within precision prec

## ◆ isConstant()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::isConstant ( const Scalar & val, const RealScalar & prec = NumTraits::dummy_precision() ) const

This is just an alias for isApproxToConstant().

Returns
true if all coefficients in this matrix are approximately equal to value, to within precision prec

## ◆ isMuchSmallerThan() [1/2]

template<typename Derived >
template<typename OtherDerived >
 bool Eigen::DenseBase< Derived >::isMuchSmallerThan ( const DenseBase< OtherDerived > & other, const RealScalar & prec = NumTraits::dummy_precision() ) const
Returns
true if the norm of *this is much smaller than the norm of other, within the precision determined by prec.
Note
The fuzzy compares are done multiplicatively. A vector $$v$$ is considered to be much smaller than a vector $$w$$ within precision $$p$$ if

$\Vert v \Vert \leqslant p\,\Vert w\Vert.$

For matrices, the comparison is done using the Hilbert-Schmidt norm.
isApprox(), isMuchSmallerThan(const RealScalar&, RealScalar) const

## ◆ isMuchSmallerThan() [2/2]

template<typename Derived >
template<typename Derived >
 bool Eigen::DenseBase< Derived >::isMuchSmallerThan ( const typename NumTraits< Scalar >::Real & other, const RealScalar & prec ) const
Returns
true if the norm of *this is much smaller than other, within the precision determined by prec.
Note
The fuzzy compares are done multiplicatively. A vector $$v$$ is considered to be much smaller than $$x$$ within precision $$p$$ if

$\Vert v \Vert \leqslant p\,\vert x\vert.$

For matrices, the comparison is done using the Hilbert-Schmidt norm. For this reason, the value of the reference scalar other should come from the Hilbert-Schmidt norm of a reference matrix of same dimensions.

isApprox(), isMuchSmallerThan(const DenseBase<OtherDerived>&, RealScalar) const

## ◆ isOnes()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::isOnes ( const RealScalar & prec = NumTraits::dummy_precision() ) const
Returns
true if *this is approximately equal to the matrix where all coefficients are equal to 1, within the precision given by prec.

Example:

Matrix3d m = Matrix3d::Ones();
m(0,2) += 1e-4;
cout << "Here's the matrix m:" << endl << m << endl;
cout << "m.isOnes() returns: " << m.isOnes() << endl;
cout << "m.isOnes(1e-3) returns: " << m.isOnes(1e-3) << endl;

Output:

Here's the matrix m:
1 1 1
1 1 1
1 1 1
m.isOnes() returns: 0
m.isOnes(1e-3) returns: 1

class CwiseNullaryOp, Ones()

## ◆ isZero()

template<typename Derived >
 bool Eigen::DenseBase< Derived >::isZero ( const RealScalar & prec = NumTraits::dummy_precision() ) const
Returns
true if *this is approximately equal to the zero matrix, within the precision given by prec.

Example:

Matrix3d m = Matrix3d::Zero();
m(0,2) = 1e-4;
cout << "Here's the matrix m:" << endl << m << endl;
cout << "m.isZero() returns: " << m.isZero() << endl;
cout << "m.isZero(1e-3) returns: " << m.isZero(1e-3) << endl;

Output:

Here's the matrix m:
0      0 0.0001
0      0      0
0      0      0
m.isZero() returns: 0
m.isZero(1e-3) returns: 1

class CwiseNullaryOp, Zero()

## ◆ lazyAssign()

template<typename Derived >
template<typename OtherDerived >
 EIGEN_DEPRECATED Derived & Eigen::DenseBase< Derived >::lazyAssign ( const DenseBase< OtherDerived > & other )

## ◆ LinSpaced() [1/4]

template<typename Derived >
 const DenseBase< Derived >::RandomAccessLinSpacedReturnType Eigen::DenseBase< Derived >::LinSpaced ( const Scalar & low, const Scalar & high )
inlinestatic

Sets a linearly spaced vector.

The function generates 'size' equally spaced values in the closed interval [low,high]. When size is set to 1, a vector of length 1 containing 'high' is returned.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

Example:

cout << VectorXi::LinSpaced(4,7,10).transpose() << endl;
cout << VectorXd::LinSpaced(5,0.0,1.0).transpose() << endl;
static EIGEN_DEPRECATED const RandomAccessLinSpacedReturnType LinSpaced(Sequential_t, Index size, const Scalar &low, const Scalar &high)
Definition: CwiseNullaryOp.h:246

Output:

 7  8  9 10
0 0.25  0.5 0.75    1


For integer scalar types, an even spacing is possible if and only if the length of the range, i.e., high-low is a scalar multiple of size-1, or if size is a scalar multiple of the number of values high-low+1 (meaning each value can be repeated the same number of time). If one of these two considions is not satisfied, then high is lowered to the largest value satisfying one of this constraint. Here are some examples:

Example:

cout << "Even spacing inputs:" << endl;
cout << VectorXi::LinSpaced(8,1,4).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,8).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,15).transpose() << endl;
cout << "Uneven spacing inputs:" << endl;
cout << VectorXi::LinSpaced(8,1,7).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,9).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,16).transpose() << endl;

Output:

Even spacing inputs:
1 1 2 2 3 3 4 4
1 2 3 4 5 6 7 8
1  3  5  7  9 11 13 15
Uneven spacing inputs:
1 1 2 2 3 3 4 4
1 2 3 4 5 6 7 8
1  3  5  7  9 11 13 15

setLinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp Special version for fixed size types which does not require the size parameter.

## ◆ LinSpaced() [2/4]

template<typename Derived >
 const DenseBase< Derived >::RandomAccessLinSpacedReturnType Eigen::DenseBase< Derived >::LinSpaced ( Index size, const Scalar & low, const Scalar & high )
inlinestatic

Sets a linearly spaced vector.

The function generates 'size' equally spaced values in the closed interval [low,high]. When size is set to 1, a vector of length 1 containing 'high' is returned.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

Example:

cout << VectorXi::LinSpaced(4,7,10).transpose() << endl;
cout << VectorXd::LinSpaced(5,0.0,1.0).transpose() << endl;

Output:

 7  8  9 10
0 0.25  0.5 0.75    1


For integer scalar types, an even spacing is possible if and only if the length of the range, i.e., high-low is a scalar multiple of size-1, or if size is a scalar multiple of the number of values high-low+1 (meaning each value can be repeated the same number of time). If one of these two considions is not satisfied, then high is lowered to the largest value satisfying one of this constraint. Here are some examples:

Example:

cout << "Even spacing inputs:" << endl;
cout << VectorXi::LinSpaced(8,1,4).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,8).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,15).transpose() << endl;
cout << "Uneven spacing inputs:" << endl;
cout << VectorXi::LinSpaced(8,1,7).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,9).transpose() << endl;
cout << VectorXi::LinSpaced(8,1,16).transpose() << endl;

Output:

Even spacing inputs:
1 1 2 2 3 3 4 4
1 2 3 4 5 6 7 8
1  3  5  7  9 11 13 15
Uneven spacing inputs:
1 1 2 2 3 3 4 4
1 2 3 4 5 6 7 8
1  3  5  7  9 11 13 15

setLinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp

## ◆ LinSpaced() [3/4]

template<typename Derived >
 EIGEN_DEPRECATED const DenseBase< Derived >::RandomAccessLinSpacedReturnType Eigen::DenseBase< Derived >::LinSpaced ( Sequential_t , const Scalar & low, const Scalar & high )
inlinestatic
Deprecated:
because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(const Scalar&,const Scalar&)
LinSpaced(const Scalar&, const Scalar&)

## ◆ LinSpaced() [4/4]

template<typename Derived >
 EIGEN_DEPRECATED const DenseBase< Derived >::RandomAccessLinSpacedReturnType Eigen::DenseBase< Derived >::LinSpaced ( Sequential_t , Index size, const Scalar & low, const Scalar & high )
inlinestatic
Deprecated:
because of accuracy loss. In Eigen 3.3, it is an alias for LinSpaced(Index,const Scalar&,const Scalar&)

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

Example:

cout << VectorXi::LinSpaced(Sequential,4,7,10).transpose() << endl;
cout << VectorXd::LinSpaced(Sequential,5,0.0,1.0).transpose() << endl;

Output:

 7  8  9 10
0 0.25  0.5 0.75    1

LinSpaced(Index,const Scalar&, const Scalar&), setLinSpaced(Index,const Scalar&,const Scalar&)

## ◆ maxCoeff() [1/3]

template<typename Derived >
template<int NaNPropagation>
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::maxCoeff
inline
Returns
the maximum of all coefficients of *this. In case *this contains NaN, NaNPropagation determines the behavior: NaNPropagation == PropagateFast : undefined NaNPropagation == PropagateNaN : result is NaN NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN
Warning
the matrix must be not empty, otherwise an assertion is triggered.

## ◆ maxCoeff() [2/3]

template<typename Derived >
template<int NaNPropagation, typename IndexType >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::maxCoeff ( IndexType * index ) const
Returns
the maximum of all coefficients of *this and puts in *index its location.

In case *this contains NaN, NaNPropagation determines the behavior: NaNPropagation == PropagateFast : undefined NaNPropagation == PropagateNaN : result is NaN NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN

Warning
the matrix must be not empty, otherwise an assertion is triggered.
DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visitor(), DenseBase::maxCoeff()

## ◆ maxCoeff() [3/3]

template<typename Derived >
template<int NaNPropagation, typename IndexType >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::maxCoeff ( IndexType * rowId, IndexType * colId ) const
Returns
the maximum of all coefficients of *this and puts in *row and *col its location.

In case *this contains NaN, NaNPropagation determines the behavior: NaNPropagation == PropagateFast : undefined NaNPropagation == PropagateNaN : result is NaN NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN

Warning
the matrix must be not empty, otherwise an assertion is triggered.
DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::maxCoeff()

## ◆ mean()

template<typename Derived >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::mean
inline
Returns
the mean of all coefficients of *this
trace(), prod(), sum()

## ◆ minCoeff() [1/3]

template<typename Derived >
template<int NaNPropagation>
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::minCoeff
inline
Returns
the minimum of all coefficients of *this. In case *this contains NaN, NaNPropagation determines the behavior: NaNPropagation == PropagateFast : undefined NaNPropagation == PropagateNaN : result is NaN NaNPropagation == PropagateNumbers : result is minimum of elements that are not NaN
Warning
the matrix must be not empty, otherwise an assertion is triggered.

## ◆ minCoeff() [2/3]

template<typename Derived >
template<int NaNPropagation, typename IndexType >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::minCoeff ( IndexType * index ) const
Returns
the minimum of all coefficients of *this and puts in *index its location.

In case *this contains NaN, NaNPropagation determines the behavior: NaNPropagation == PropagateFast : undefined NaNPropagation == PropagateNaN : result is NaN NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN

Warning
the matrix must be not empty, otherwise an assertion is triggered.
DenseBase::minCoeff(IndexType*,IndexType*), DenseBase::maxCoeff(IndexType*,IndexType*), DenseBase::visit(), DenseBase::minCoeff()

## ◆ minCoeff() [3/3]

template<typename Derived >
template<int NaNPropagation, typename IndexType >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::minCoeff ( IndexType * rowId, IndexType * colId ) const
Returns
the minimum of all coefficients of *this and puts in *row and *col its location.

In case *this contains NaN, NaNPropagation determines the behavior: NaNPropagation == PropagateFast : undefined NaNPropagation == PropagateNaN : result is NaN NaNPropagation == PropagateNumbers : result is maximum of elements that are not NaN

Warning
the matrix must be not empty, otherwise an assertion is triggered.
DenseBase::minCoeff(Index*), DenseBase::maxCoeff(Index*,Index*), DenseBase::visit(), DenseBase::minCoeff()

## ◆ nestByValue()

template<typename Derived >
 const NestByValue< Derived > Eigen::DenseBase< Derived >::nestByValue
inline
Returns
an expression of the temporary version of *this.

## ◆ NullaryExpr() [1/3]

template<typename Derived >
template<typename CustomNullaryOp >
 const CwiseNullaryOp< CustomNullaryOp, PlainObject > Eigen::DenseBase< Derived >::NullaryExpr ( const CustomNullaryOp & func )
inlinestatic
Returns
an expression of a matrix defined by a custom functor func

This variant is only for fixed-size DenseBase types. For dynamic-size types, you need to use the variants taking size arguments.

The template parameter CustomNullaryOp is the type of the functor.

class CwiseNullaryOp

## ◆ NullaryExpr() [2/3]

template<typename Derived >
template<typename CustomNullaryOp >
 const CwiseNullaryOp< CustomNullaryOp, PlainObject > Eigen::DenseBase< Derived >::NullaryExpr ( Index rows, Index cols, const CustomNullaryOp & func )
inlinestatic
Returns
an expression of a matrix defined by a custom functor func

The parameters rows and cols are the number of rows and of columns of the returned matrix. Must be compatible with this MatrixBase type.

This variant is meant to be used for dynamic-size matrix types. For fixed-size types, it is redundant to pass rows and cols as arguments, so Zero() should be used instead.

The template parameter CustomNullaryOp is the type of the functor.

class CwiseNullaryOp

## ◆ NullaryExpr() [3/3]

template<typename Derived >
template<typename CustomNullaryOp >
 const CwiseNullaryOp< CustomNullaryOp, PlainObject > Eigen::DenseBase< Derived >::NullaryExpr ( Index size, const CustomNullaryOp & func )
inlinestatic
Returns
an expression of a matrix defined by a custom functor func

The parameter size is the size of the returned vector. Must be compatible with this MatrixBase type.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

This variant is meant to be used for dynamic-size vector types. For fixed-size types, it is redundant to pass size as argument, so Zero() should be used instead.

The template parameter CustomNullaryOp is the type of the functor.

Here is an example with C++11 random generators:

#include <Eigen/Core>
#include <iostream>
#include <random>
int main() {
std::default_random_engine generator;
std::poisson_distribution<int> distribution(4.1);
auto poisson = [&] () {return distribution(generator);};
std::cout << v << "\n";
}
static const CwiseNullaryOp< CustomNullaryOp, PlainObject > NullaryExpr(Index rows, Index cols, const CustomNullaryOp &func)
Definition: CwiseNullaryOp.h:116
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:182

Output:

 2 10  5  5  4  2  2  2  6  2

class CwiseNullaryOp

## ◆ Ones() [1/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Ones
inlinestatic
Returns
an expression of a fixed-size matrix or vector where all coefficients equal one.

This variant is only for fixed-size MatrixBase types. For dynamic-size types, you need to use the variants taking size arguments.

Example:

cout << Matrix2d::Ones() << endl;
cout << 6 * RowVector4i::Ones() << endl;

Output:

1 1
1 1
6 6 6 6

Ones(Index), Ones(Index,Index), isOnes(), class Ones

## ◆ Ones() [2/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Ones ( Index rows, Index cols )
inlinestatic
Returns
an expression of a matrix where all coefficients equal one.

The parameters rows and cols are the number of rows and of columns of the returned matrix. Must be compatible with this MatrixBase type.

This variant is meant to be used for dynamic-size matrix types. For fixed-size types, it is redundant to pass rows and cols as arguments, so Ones() should be used instead.

Example:

cout << MatrixXi::Ones(2,3) << endl;

Output:

1 1 1
1 1 1

Ones(), Ones(Index), isOnes(), class Ones

## ◆ Ones() [3/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Ones ( Index newSize )
inlinestatic
Returns
an expression of a vector where all coefficients equal one.

The parameter newSize is the size of the returned vector. Must be compatible with this MatrixBase type.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

This variant is meant to be used for dynamic-size vector types. For fixed-size types, it is redundant to pass size as argument, so Ones() should be used instead.

Example:

cout << 6 * RowVectorXi::Ones(4) << endl;
cout << VectorXf::Ones(2) << endl;

Output:

6 6 6 6
1
1

Ones(), Ones(Index,Index), isOnes(), class Ones

## ◆ operator<<() [1/2]

template<typename Derived >
template<typename OtherDerived >
 CommaInitializer< Derived > Eigen::DenseBase< Derived >::operator<< ( const DenseBase< OtherDerived > & other )
inline

## ◆ operator<<() [2/2]

template<typename Derived >
 CommaInitializer< Derived > Eigen::DenseBase< Derived >::operator<< ( const Scalar & s )
inline

Convenient operator to set the coefficients of a matrix.

The coefficients must be provided in a row major order and exactly match the size of the matrix. Otherwise an assertion is raised.

Example:

Matrix3i m1;
m1 << 1, 2, 3,
4, 5, 6,
7, 8, 9;
cout << m1 << endl << endl;
Matrix3i m2 = Matrix3i::Identity();
m2.block(0,0, 2,2) << 10, 11, 12, 13;
cout << m2 << endl << endl;
Vector2i v1;
v1 << 14, 15;
m2 << v1.transpose(), 16,
v1, m1.block(1,1,2,2);
cout << m2 << endl;
static const IdentityReturnType Identity()
Definition: CwiseNullaryOp.h:801

Output:

1 2 3
4 5 6
7 8 9

10 11  0
12 13  0
0  0  1

14 15 16
14  5  6
15  8  9

Note
According the c++ standard, the argument expressions of this comma initializer are evaluated in arbitrary order.
CommaInitializer::finished(), class CommaInitializer

## ◆ operator=() [1/3]

template<typename Derived >
 Derived & Eigen::DenseBase< Derived >::operator= ( const DenseBase< Derived > & other )
inline

Special case of the template operator=, in order to prevent the compiler from generating a default operator= (issue hit with g++ 4.1)

## ◆ operator=() [2/3]

template<typename Derived >
template<typename OtherDerived >
 Derived & Eigen::DenseBase< Derived >::operator= ( const DenseBase< OtherDerived > & other )
inline

Copies other into *this.

Returns
a reference to *this.

## ◆ operator=() [3/3]

template<typename Derived >
template<typename OtherDerived >
 Derived & Eigen::DenseBase< Derived >::operator= ( const EigenBase< OtherDerived > & other )

Copies the generic expression other into *this.

The expression must provide a (templated) evalTo(Derived& dst) const function which does the actual job. In practice, this allows any user to write its own special matrix without having to modify MatrixBase

Returns
a reference to *this.

## ◆ outerSize()

template<typename Derived >
 EIGEN_CONSTEXPR Index Eigen::DenseBase< Derived >::outerSize ( ) const
inline
Returns
the outer size.
Note
For a vector, this returns just 1. For a matrix (non-vector), this is the major dimension with respect to the storage order, i.e., the number of columns for a column-major matrix, and the number of rows for a row-major matrix.

## ◆ prod()

template<typename Derived >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::prod
inline
Returns
the product of all coefficients of *this

Example:

Matrix3d m = Matrix3d::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the product of all the coefficients:" << endl << m.prod() << endl;

Output:

Here is the matrix m:
-1 -0.0827  -0.906
-0.737  0.0655   0.358
0.511  -0.562   0.359
Here is the product of all the coefficients:
-0.000133

sum(), mean(), trace()

## ◆ Random() [1/3]

template<typename Derived >
 const DenseBase< Derived >::RandomReturnType Eigen::DenseBase< Derived >::Random
inlinestatic
Returns
a fixed-size random matrix or vector expression

Numbers are uniformly spread through their whole definition range for integer types, and in the [-1:1] range for floating point scalar types.

This variant is only for fixed-size MatrixBase types. For dynamic-size types, you need to use the variants taking size arguments.

Example:

cout << 100 * Matrix2i::Random() << endl;

Output:

-1000   500
-800  -100


This expression has the "evaluate before nesting" flag so that it will be evaluated into a temporary matrix whenever it is nested in a larger expression. This prevents unexpected behavior with expressions involving random matrices.

Warning
This function is not re-entrant.
DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random(Index)

## ◆ Random() [2/3]

template<typename Derived >
 const DenseBase< Derived >::RandomReturnType Eigen::DenseBase< Derived >::Random ( Index rows, Index cols )
inlinestatic
Returns
a random matrix expression

Numbers are uniformly spread through their whole definition range for integer types, and in the [-1:1] range for floating point scalar types.

The parameters rows and cols are the number of rows and of columns of the returned matrix. Must be compatible with this MatrixBase type.

Warning
This function is not re-entrant.

This variant is meant to be used for dynamic-size matrix types. For fixed-size types, it is redundant to pass rows and cols as arguments, so Random() should be used instead.

Example:

cout << MatrixXi::Random(2,3) << endl;

Output:

-10   5   1
-8  -1  -6


This expression has the "evaluate before nesting" flag so that it will be evaluated into a temporary matrix whenever it is nested in a larger expression. This prevents unexpected behavior with expressions involving random matrices.

See DenseBase::NullaryExpr(Index, const CustomNullaryOp&) for an example using C++11 random generators.

DenseBase::setRandom(), DenseBase::Random(Index), DenseBase::Random()

## ◆ Random() [3/3]

template<typename Derived >
 const DenseBase< Derived >::RandomReturnType Eigen::DenseBase< Derived >::Random ( Index size )
inlinestatic
Returns
a random vector expression

Numbers are uniformly spread through their whole definition range for integer types, and in the [-1:1] range for floating point scalar types.

The parameter size is the size of the returned vector. Must be compatible with this MatrixBase type.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

Warning
This function is not re-entrant.

This variant is meant to be used for dynamic-size vector types. For fixed-size types, it is redundant to pass size as argument, so Random() should be used instead.

Example:

cout << VectorXi::Random(2) << endl;

Output:

-10
-8


This expression has the "evaluate before nesting" flag so that it will be evaluated into a temporary vector whenever it is nested in a larger expression. This prevents unexpected behavior with expressions involving random matrices.

DenseBase::setRandom(), DenseBase::Random(Index,Index), DenseBase::Random()

## ◆ redux()

template<typename Derived >
template<typename Func >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::redux ( const Func & func ) const
inline
Returns
the result of a full redux operation on the whole matrix or vector using func

The template parameter BinaryOp is the type of the functor func which must be an associative operator. Both current C++98 and C++11 functor styles are handled.

Warning
the matrix must be not empty, otherwise an assertion is triggered.
DenseBase::sum(), DenseBase::minCoeff(), DenseBase::maxCoeff(), MatrixBase::colwise(), MatrixBase::rowwise()

## ◆ replicate() [1/2]

template<typename Derived >
template<int RowFactor, int ColFactor>
 const Replicate< Derived, RowFactor, ColFactor > Eigen::DenseBase< Derived >::replicate
Returns
an expression of the replication of *this

Example:

MatrixXi m = MatrixXi::Random(2,3);
cout << "Here is the matrix m:" << endl << m << endl;
cout << "m.replicate<3,2>() = ..." << endl;
cout << m.replicate<3,2>() << endl;

Output:

Here is the matrix m:
-10   5   1
-8  -1  -6
m.replicate<3,2>() = ...
-10   5   1 -10   5   1
-8  -1  -6  -8  -1  -6
-10   5   1 -10   5   1
-8  -1  -6  -8  -1  -6
-10   5   1 -10   5   1
-8  -1  -6  -8  -1  -6

VectorwiseOp::replicate(), DenseBase::replicate(Index,Index), class Replicate

## ◆ replicate() [2/2]

template<typename Derived >
 const Replicate< Derived, Dynamic, Dynamic > Eigen::DenseBase< Derived >::replicate ( Index rowFactor, Index colFactor ) const
inline
Returns
an expression of the replication of *this

Example:

Vector3i v = Vector3i::Random();
cout << "Here is the vector v:" << endl << v << endl;
cout << "v.replicate(2,5) = ..." << endl;
cout << v.replicate(2,5) << endl;

Output:

Here is the vector v:
-10
-8
5
v.replicate(2,5) = ...
-10 -10 -10 -10 -10
-8  -8  -8  -8  -8
5   5   5   5   5
-10 -10 -10 -10 -10
-8  -8  -8  -8  -8
5   5   5   5   5

VectorwiseOp::replicate(), DenseBase::replicate<int,int>(), class Replicate

## ◆ resize() [1/2]

template<typename Derived >
 void Eigen::DenseBase< Derived >::resize ( Index newSize )
inline

Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does nothing else.

## ◆ resize() [2/2]

template<typename Derived >
 void Eigen::DenseBase< Derived >::resize ( Index rows, Index cols )
inline

Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods are Matrix::resize() and Array::resize(). The present method only asserts that the new size equals the old size, and does nothing else.

## ◆ reverse() [1/2]

template<typename Derived >
 DenseBase< Derived >::ReverseReturnType Eigen::DenseBase< Derived >::reverse
inline
Returns
an expression of the reverse of *this.

Example:

MatrixXi m = MatrixXi::Random(3,4);
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the reverse of m:" << endl << m.reverse() << endl;
cout << "Here is the coefficient (1,0) in the reverse of m:" << endl
<< m.reverse()(1,0) << endl;
cout << "Let us overwrite this coefficient with the value 4." << endl;
m.reverse()(1,0) = 4;
cout << "Now the matrix m is:" << endl << m << endl;

Output:

Here is the matrix m:
-10  -1 -10   9
-8   1   4  -2
5  -6   4   0
Here is the reverse of m:
0   4  -6   5
-2   4   1  -8
9 -10  -1 -10
Here is the coefficient (1,0) in the reverse of m:
-2
Let us overwrite this coefficient with the value 4.
Now the matrix m is:
-10  -1 -10   9
-8   1   4   4
5  -6   4   0


## ◆ reverse() [2/2]

template<typename Derived >
 ConstReverseReturnType Eigen::DenseBase< Derived >::reverse ( ) const
inline

This is the const version of reverse().

## ◆ reverseInPlace()

template<typename Derived >
 void Eigen::DenseBase< Derived >::reverseInPlace
inline

This is the "in place" version of reverse: it reverses *this.

In most cases it is probably better to simply use the reversed expression of a matrix. However, when reversing the matrix data itself is really needed, then this "in-place" version is probably the right choice because it provides the following additional benefits:

• less error prone: doing the same operation with .reverse() requires special care:
m = m.reverse().eval();
• this API enables reverse operations without the need for a temporary
• it allows future optimizations (cache friendliness, etc.)
VectorwiseOp::reverseInPlace(), reverse()

## ◆ rowwise() [1/2]

template<typename Derived >
 DenseBase< Derived >::RowwiseReturnType Eigen::DenseBase< Derived >::rowwise
inline
Returns
a writable VectorwiseOp wrapper of *this providing additional partial reduction operations
colwise(), class VectorwiseOp, Reductions, visitors and broadcasting

## ◆ rowwise() [2/2]

template<typename Derived >
 ConstRowwiseReturnType Eigen::DenseBase< Derived >::rowwise ( ) const
inline
Returns
a VectorwiseOp wrapper of *this for broadcasting and partial reductions

Example:

Matrix3d m = Matrix3d::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the sum of each row:" << endl << m.rowwise().sum() << endl;
cout << "Here is the maximum absolute value of each row:"
<< endl << m.cwiseAbs().rowwise().maxCoeff() << endl;

Output:

Here is the matrix m:
-1 -0.0827  -0.906
-0.737  0.0655   0.358
0.511  -0.562   0.359
Here is the sum of each row:
-1.99
-0.314
0.308
Here is the maximum absolute value of each row:
1
0.737
0.562

colwise(), class VectorwiseOp, Reductions, visitors and broadcasting

## ◆ select() [1/3]

template<typename Derived >
template<typename ThenDerived , typename ElseDerived >
 const Select< Derived, ThenDerived, ElseDerived > Eigen::DenseBase< Derived >::select ( const DenseBase< ThenDerived > & thenMatrix, const DenseBase< ElseDerived > & elseMatrix ) const
inline
Returns
a matrix where each coefficient (i,j) is equal to thenMatrix(i,j) if *this(i,j), and elseMatrix(i,j) otherwise.

Example:

MatrixXi m(3, 3);
m << 1, 2, 3,
4, 5, 6,
7, 8, 9;
m = (m.array() >= 5).select(-m, m);
cout << m << endl;
const Select< Derived, ThenDerived, ElseDerived > select(const DenseBase< ThenDerived > &thenMatrix, const DenseBase< ElseDerived > &elseMatrix) const
Definition: Select.h:128

Output:

 1  2  3
4 -5 -6
-7 -8 -9

class Select

## ◆ select() [2/3]

template<typename Derived >
template<typename ThenDerived >
 const Select< Derived, ThenDerived, typename ThenDerived::ConstantReturnType > Eigen::DenseBase< Derived >::select ( const DenseBase< ThenDerived > & thenMatrix, const typename ThenDerived::Scalar & elseScalar ) const
inline

Version of DenseBase::select(const DenseBase&, const DenseBase&) with the else expression being a scalar value.

DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select

## ◆ select() [3/3]

template<typename Derived >
template<typename ElseDerived >
 const Select< Derived, typename ElseDerived::ConstantReturnType, ElseDerived > Eigen::DenseBase< Derived >::select ( const typename ElseDerived::Scalar & thenScalar, const DenseBase< ElseDerived > & elseMatrix ) const
inline

Version of DenseBase::select(const DenseBase&, const DenseBase&) with the then expression being a scalar value.

DenseBase::select(const DenseBase<ThenDerived>&, const DenseBase<ElseDerived>&) const, class Select

## ◆ setConstant()

template<typename Derived >
 Derived & Eigen::DenseBase< Derived >::setConstant ( const Scalar & val )
inline

Sets all coefficients in this expression to value val.

fill(), setConstant(Index,const Scalar&), setConstant(Index,Index,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()

## ◆ setLinSpaced() [1/2]

template<typename Derived >
 Derived & Eigen::DenseBase< Derived >::setLinSpaced ( const Scalar & low, const Scalar & high )
inline

Sets a linearly spaced vector.

The function fills *this with equally spaced values in the closed interval [low,high]. When size is set to 1, a vector of length 1 containing 'high' is returned.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

For integer scalar types, do not miss the explanations on the definition of even spacing .

LinSpaced(Index,const Scalar&,const Scalar&), setLinSpaced(Index, const Scalar&, const Scalar&), CwiseNullaryOp

## ◆ setLinSpaced() [2/2]

template<typename Derived >
 Derived & Eigen::DenseBase< Derived >::setLinSpaced ( Index newSize, const Scalar & low, const Scalar & high )
inline

Sets a linearly spaced vector.

The function generates 'size' equally spaced values in the closed interval [low,high]. When size is set to 1, a vector of length 1 containing 'high' is returned.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

Example:

VectorXf v;
v.setLinSpaced(5,0.5f,1.5f);
cout << v << endl;

Output:

 0.5
0.75
1
1.25
1.5


For integer scalar types, do not miss the explanations on the definition of even spacing .

LinSpaced(Index,const Scalar&,const Scalar&), CwiseNullaryOp

## ◆ setOnes()

template<typename Derived >
 Derived & Eigen::DenseBase< Derived >::setOnes
inline

Sets all coefficients in this expression to one.

Example:

Matrix4i m = Matrix4i::Random();
m.row(1).setOnes();
cout << m << endl;

Output:

-10   1   4   7
1   1   1   1
5 -10  -2  -9
-1   4   0   1

class CwiseNullaryOp, Ones()

## ◆ setRandom()

template<typename Derived >
 Derived & Eigen::DenseBase< Derived >::setRandom
inline

Sets all coefficients in this expression to random values.

Numbers are uniformly spread through their whole definition range for integer types, and in the [-1:1] range for floating point scalar types.

Warning
This function is not re-entrant.

Example:

Matrix4i m = Matrix4i::Zero();
m.col(1).setRandom();
cout << m << endl;

Output:

  0 -10   0   0
0  -8   0   0
0   5   0   0
0  -1   0   0

class CwiseNullaryOp, setRandom(Index), setRandom(Index,Index)

## ◆ setZero()

template<typename Derived >
 Derived & Eigen::DenseBase< Derived >::setZero
inline

Sets all coefficients in this expression to zero.

Example:

Matrix4i m = Matrix4i::Random();
m.row(1).setZero();
cout << m << endl;

Output:

-10   1   4   7
0   0   0   0
5 -10  -2  -9
-1   4   0   1

class CwiseNullaryOp, Zero()

## ◆ sum()

template<typename Derived >
 internal::traits< Derived >::Scalar Eigen::DenseBase< Derived >::sum
inline
Returns
the sum of all coefficients of *this

If *this is empty, then the value 0 is returned.

trace(), prod(), mean()

## ◆ swap() [1/2]

template<typename Derived >
template<typename OtherDerived >
 void Eigen::DenseBase< Derived >::swap ( const DenseBase< OtherDerived > & other )
inline

swaps *this with the expression other.

## ◆ swap() [2/2]

template<typename Derived >
template<typename OtherDerived >
 void Eigen::DenseBase< Derived >::swap ( PlainObjectBase< OtherDerived > & other )
inline

swaps *this with the matrix or array other.

## ◆ transpose() [1/2]

template<typename Derived >
 Transpose< Derived > Eigen::DenseBase< Derived >::transpose
inline
Returns
an expression of the transpose of *this.

Example:

Matrix2i m = Matrix2i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the transpose of m:" << endl << m.transpose() << endl;
cout << "Here is the coefficient (1,0) in the transpose of m:" << endl
<< m.transpose()(1,0) << endl;
cout << "Let us overwrite this coefficient with the value 0." << endl;
m.transpose()(1,0) = 0;
cout << "Now the matrix m is:" << endl << m << endl;

Output:

Here is the matrix m:
-10   5
-8  -1
Here is the transpose of m:
-10  -8
5  -1
Here is the coefficient (1,0) in the transpose of m:
5
Let us overwrite this coefficient with the value 0.
Now the matrix m is:
-10   0
-8  -1

Warning
If you want to replace a matrix by its own transpose, do NOT do this:
m = m.transpose(); // bug!!! caused by aliasing effect
m.transposeInPlace();
which gives Eigen good opportunities for optimization, or alternatively you can also do:
m = m.transpose().eval();

## ◆ transpose() [2/2]

template<typename Derived >
 DenseBase< Derived >::ConstTransposeReturnType Eigen::DenseBase< Derived >::transpose
inline

This is the const version of transpose().

Make sure you read the warning for transpose() !

## ◆ transposeInPlace()

template<typename Derived >
 void Eigen::DenseBase< Derived >::transposeInPlace
inline

This is the "in place" version of transpose(): it replaces *this by its own transpose. Thus, doing

m.transposeInPlace();

has the same effect on m as doing

m = m.transpose().eval();

and is faster and also safer because in the latter line of code, forgetting the eval() results in a bug caused by aliasing.

Notice however that this method is only useful if you want to replace a matrix by its own transpose. If you just need the transpose of a matrix, use transpose().

Note
if the matrix is not square, then *this must be a resizable matrix. This excludes (non-square) fixed-size matrices, block-expressions and maps.

## ◆ value()

template<typename Derived >
 CoeffReturnType Eigen::DenseBase< Derived >::value ( ) const
inline
Returns
the unique coefficient of a 1x1 expression

## ◆ visit()

template<typename Derived >
template<typename Visitor >
 void Eigen::DenseBase< Derived >::visit ( Visitor & visitor ) const

Applies the visitor visitor to the whole coefficients of the matrix or vector.

The template parameter Visitor is the type of the visitor and provides the following interface:

struct MyVisitor {
// called for the first coefficient
void init(const Scalar& value, Index i, Index j);
// called for all other coefficients
void operator() (const Scalar& value, Index i, Index j);
};
internal::traits< Derived >::Scalar Scalar
Definition: DenseBase.h:61
CoeffReturnType value() const
Definition: DenseBase.h:516
Scalar & operator()(Index row, Index col)
Definition: DenseCoeffsBase.h:366
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:41
Note
compared to one or two for loops, visitors offer automatic unrolling for small fixed size matrix.
if the matrix is empty, then the visitor is left unchanged.
minCoeff(Index*,Index*), maxCoeff(Index*,Index*), DenseBase::redux()

## ◆ Zero() [1/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Zero
inlinestatic
Returns
an expression of a fixed-size zero matrix or vector.

This variant is only for fixed-size MatrixBase types. For dynamic-size types, you need to use the variants taking size arguments.

Example:

cout << Matrix2d::Zero() << endl;
cout << RowVector4i::Zero() << endl;

Output:

0 0
0 0
0 0 0 0

Zero(Index), Zero(Index,Index)

## ◆ Zero() [2/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Zero ( Index rows, Index cols )
inlinestatic
Returns
an expression of a zero matrix.

The parameters rows and cols are the number of rows and of columns of the returned matrix. Must be compatible with this MatrixBase type.

This variant is meant to be used for dynamic-size matrix types. For fixed-size types, it is redundant to pass rows and cols as arguments, so Zero() should be used instead.

Example:

cout << MatrixXi::Zero(2,3) << endl;

Output:

0 0 0
0 0 0

Zero(), Zero(Index)

## ◆ Zero() [3/3]

template<typename Derived >
 const DenseBase< Derived >::ConstantReturnType Eigen::DenseBase< Derived >::Zero ( Index size )
inlinestatic
Returns
an expression of a zero vector.

The parameter size is the size of the returned vector. Must be compatible with this MatrixBase type.

This is only for vectors (either row-vectors or column-vectors), i.e. matrices which are known at compile-time to have either one row or one column.

This variant is meant to be used for dynamic-size vector types. For fixed-size types, it is redundant to pass size as argument, so Zero() should be used instead.

Example:

cout << RowVectorXi::Zero(4) << endl;
cout << VectorXf::Zero(2) << endl;

Output:

0 0 0 0
0
0

Zero(), Zero(Index,Index)

## ◆ operator<<()

template<typename Derived >
 std::ostream & operator<< ( std::ostream & s, const DenseBase< Derived > & m )
related

Outputs the matrix, to the given stream.

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. If not defined, this will automatically be defined to Eigen::IOFormat(), that is the Eigen::IOFormat with default parameters.