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

See also
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)
 

Protected Member Functions

 DenseBase ()
 

Related Functions

(Note that these are not member functions.)

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

Member Typedef Documentation

◆ 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<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>::MaxColsAtCompileTime > Eigen::DenseBase< Derived >::PlainArray

The plain array type corresponding to this expression.

See also
PlainObject

◆ PlainMatrix

template<typename Derived >
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>::MaxColsAtCompileTime > Eigen::DenseBase< Derived >::PlainMatrix

The plain matrix type corresponding to this expression.

See also
PlainObject

◆ PlainObject

template<typename Derived >
typedef internal::conditional<internal::is_same<typenameinternal::traits<Derived>::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<Derived>::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<Derived>::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

See also
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

Member Enumeration Documentation

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

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

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

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

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

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

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

Constructor & Destructor Documentation

◆ DenseBase()

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

Default constructor. Do nothing.

Member Function Documentation

◆ 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
See also
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.
See also
hasNaN()

◆ any()

template<typename Derived >
bool Eigen::DenseBase< Derived >::any
inline
Returns
true if at least one coefficient is true
See also
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.

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

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

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

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

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

See also
class CwiseNullaryOp

◆ count()

template<typename Derived >
Eigen::Index Eigen::DenseBase< Derived >::count
inline
Returns
the number of coefficients which evaluate to true
See also
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.

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

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

See also
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).
See also
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<Scalar>::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.
See also
internal::isMuchSmallerThan(const RealScalar&, RealScalar) const

◆ isApproxToConstant()

template<typename Derived >
bool Eigen::DenseBase< Derived >::isApproxToConstant ( const Scalar val,
const RealScalar &  prec = NumTraits<Scalar>::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<Scalar>::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<Scalar>::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.
See also
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.

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

◆ isOnes()

template<typename Derived >
bool Eigen::DenseBase< Derived >::isOnes ( const RealScalar &  prec = NumTraits<Scalar>::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
See also
class CwiseNullaryOp, Ones()

◆ isZero()

template<typename Derived >
bool Eigen::DenseBase< Derived >::isZero ( const RealScalar &  prec = NumTraits<Scalar>::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
See also
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
See also
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
See also
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&)
See also
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
See also
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.
See also
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.
See also
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
See also
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.
See also
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.
See also
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.

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

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

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

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

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

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

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

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

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

See also
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
Instead, use the transposeInPlace() method:
m.transposeInPlace();
which gives Eigen good opportunities for optimization, or alternatively you can also do:
m = m.transpose().eval();
See also
transposeInPlace(), adjoint()

◆ 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() !

See also
transposeInPlace(), adjoint()

◆ 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.
See also
transpose(), adjoint(), adjointInPlace()

◆ 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.
See also
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
See also
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
See also
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
See also
Zero(), Zero(Index,Index)

Friends And Related Function Documentation

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

See also
DenseBase::format()

The documentation for this class was generated from the following files: