template<typename Derived>

Eigen::DenseBase class

template<typename Derived>

enum Eigen::DenseBase<Derived>::(anonymous)

template<typename Derived>

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

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

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.

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.

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.

template<typename Derived>

typedef internal::conditional<internal::is_same<typename internal::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&.

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.

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

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

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Constant(Index rows, Index cols, const Scalar& 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.

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Constant(Index size, const Scalar& 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.

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Constant(const Scalar& 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.

template<typename Derived>

static const SequentialLinSpacedReturnType Eigen::DenseBase<Derived>::LinSpaced(Sequential_t, Index size, const Scalar& low, const Scalar& high)

template<typename Derived>

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

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

template<typename Derived>

static const SequentialLinSpacedReturnType Eigen::DenseBase<Derived>::LinSpaced(Sequential_t, const Scalar& low, const Scalar& high)

template<typename Derived>

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

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

template<typename Derived> template<typename CustomNullaryOp>

static const CwiseNullaryOp<CustomNullaryOp, PlainObject> Eigen::DenseBase<Derived>::NullaryExpr(Index rows, Index cols, const CustomNullaryOp& 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.

template<typename Derived> template<typename CustomNullaryOp>

static const CwiseNullaryOp<CustomNullaryOp, PlainObject> Eigen::DenseBase<Derived>::NullaryExpr(Index size, const CustomNullaryOp& 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>

using namespace Eigen;

int main() {
  std::default_random_engine generator;
  std::poisson_distribution<int> distribution(4.1);
  auto poisson = [&] () {return distribution(generator);};

  RowVectorXi v = RowVectorXi::NullaryExpr(10, poisson );
  std::cout << v << "\n";
}

Output:

2 3 1 4 3 4 4 3 2 3

template<typename Derived> template<typename CustomNullaryOp>

static const CwiseNullaryOp<CustomNullaryOp, PlainObject> Eigen::DenseBase<Derived>::NullaryExpr(const CustomNullaryOp& 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.

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Ones(Index rows, Index cols)

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

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Ones(Index size)

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

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Ones()

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

template<typename Derived>

static const RandomReturnType Eigen::DenseBase<Derived>::Random(Index rows, Index cols)

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.

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:

 7  6  9
-2  6 -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.

template<typename Derived>

static const RandomReturnType Eigen::DenseBase<Derived>::Random(Index size)

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.

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:

 7
-2

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.

template<typename Derived>

static const RandomReturnType Eigen::DenseBase<Derived>::Random()

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:

 700  600
-200  600

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.

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Zero(Index rows, Index cols)

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

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Zero(Index size)

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

template<typename Derived>

static const ConstantReturnType Eigen::DenseBase<Derived>::Zero()

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

template<typename Derived>

Eigen::DenseBase<Derived>::DenseBase() protected

Default constructor. Do nothing.

template<typename Derived>

bool Eigen::DenseBase<Derived>::all() const

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;

Output:

Is (  0.68 -0.211  0.566) inside the box: 0
Is (0.597 0.823 0.605) inside the box: 1

template<typename Derived>

bool Eigen::DenseBase<Derived>::allFinite() const

template<typename Derived>

bool Eigen::DenseBase<Derived>::any() const

template<typename Derived>

iterator Eigen::DenseBase<Derived>::begin()

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.

template<typename Derived>

const_iterator Eigen::DenseBase<Derived>::begin() const

const version of begin()

template<typename Derived> template<typename NRowsType, typename NColsType>

FixedBlockXpr<...,...>::Type Eigen::DenseBase<Derived>::block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)

Example using runtime (aka dynamic) sizes:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.block(1, 1, 2, 2):" << endl << m.block(1, 1, 2, 2) << endl;
m.block(1, 1, 2, 2).setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.block(1, 1, 2, 2):
-6  1
-3  0
Now the matrix m is:
 7  9 -5 -3
-2  0  0  0
 6  0  0  9
 6  6  3  9

New in Eigen 3.4.:

The number of rows blockRows and columns blockCols can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. In the later case, n plays the role of a runtime fallback value in case N equals Eigen::Dynamic. Here is an example with a fixed number of rows NRows and dynamic number of columns cols: mat.block(i,j,fix<NRows>,cols)

This function thus fully covers the features offered by the following overloads block<NRows,NCols>(Index, Index), and block<NRows,NCols>(Index, Index, Index, Index) that are thus obsolete. Indeed, this generic version avoids redundancy, it preserves the argument order, and prevents the need to rely on the template keyword in templated code.

but with less redundancy and more consistency as it does not modify the argument order and seamlessly enable hybrid fixed/dynamic sizes.

template<typename Derived> template<typename NRowsType, typename NColsType>

const ConstFixedBlockXpr<...,...>::Type Eigen::DenseBase<Derived>::block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const

This is the const version of block(Index,Index,NRowsType,NColsType)

template<typename Derived> template<int NRows, int NCols>

FixedBlockXpr<NRows, NCols>::Type Eigen::DenseBase<Derived>::block(Index startRow, Index startCol)

The template parameters NRows and NCols are the number of rows and columns in the block.

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.block<2,2>(1,1):" << endl << m.block<2,2>(1,1) << endl;
m.block<2,2>(1,1).setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.block<2,2>(1,1):
-6  1
-3  0
Now the matrix m is:
 7  9 -5 -3
-2  0  0  0
 6  0  0  9
 6  6  3  9

template<typename Derived> template<int NRows, int NCols>

const ConstFixedBlockXpr<NRows, NCols>::Type Eigen::DenseBase<Derived>::block(Index startRow, Index startCol) const

This is the const version of block<>(Index, Index). */.

template<typename Derived> template<int NRows, int NCols>

FixedBlockXpr<NRows, NCols>::Type Eigen::DenseBase<Derived>::block(Index startRow, Index startCol, Index blockRows, Index blockCols)

This function is mainly useful for blocks where the number of rows is specified at compile-time and the number of columns is specified at run-time, or vice versa. The compile-time and run-time information should not contradict. In other words, blockRows should equal NRows unless NRows is Dynamic, and the same for the number of columns.

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the block:" << endl << m.block<2, Dynamic>(1, 1, 2, 3) << endl;
m.block<2, Dynamic>(1, 1, 2, 3).setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is the block:
-6  1  0
-3  0  9
Now the matrix m is:
 7  9 -5 -3
-2  0  0  0
 6  0  0  0
 6  6  3  9

template<typename Derived> template<int NRows, int NCols>

const ConstFixedBlockXpr<NRows, NCols>::Type Eigen::DenseBase<Derived>::block(Index startRow, Index startCol, Index blockRows, Index blockCols) const

This is the const version of block<>(Index, Index, Index, Index).

template<typename Derived> template<typename NRowsType, typename NColsType>

FixedBlockXpr<...,...>::Type Eigen::DenseBase<Derived>::bottomLeftCorner(NRowsType cRows, NColsType cCols)

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.bottomLeftCorner(2, 2):" << endl;
cout << m.bottomLeftCorner(2, 2) << endl;
m.bottomLeftCorner(2, 2).setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.bottomLeftCorner(2, 2):
 6 -3
 6  6
Now the matrix m is:
 7  9 -5 -3
-2 -6  1  0
 0  0  0  9
 0  0  3  9

The number of rows blockRows and columns blockCols can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NRowsType, typename NColsType>

ConstFixedBlockXpr<...,...>::Type Eigen::DenseBase<Derived>::bottomLeftCorner(NRowsType cRows, NColsType cCols) const

This is the const version of bottomLeftCorner(NRowsType, NColsType).

template<typename Derived> template<int CRows, int CCols>

FixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomLeftCorner()

The template parameters CRows and CCols are the number of rows and columns in the corner.

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.bottomLeftCorner<2,2>():" << endl;
cout << m.bottomLeftCorner<2,2>() << endl;
m.bottomLeftCorner<2,2>().setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

block(Index,Index,NRowsType,NColsType), class Block

template<typename Derived> template<int CRows, int CCols>

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomLeftCorner() const

This is the const version of bottomLeftCorner<int, int>().

template<typename Derived> template<int CRows, int CCols>

FixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomLeftCorner(Index cRows, Index cCols)

This function is mainly useful for corners where the number of rows is specified at compile-time and the number of columns is specified at run-time, or vice versa. The compile-time and run-time information should not contradict. In other words, cRows should equal CRows unless CRows is Dynamic, and the same for the number of columns.

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.bottomLeftCorner<2,Dynamic>(2,2):" << endl;
cout << m.bottomLeftCorner<2,Dynamic>(2,2) << endl;
m.bottomLeftCorner<2,Dynamic>(2,2).setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

class Block

template<typename Derived> template<int CRows, int CCols>

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomLeftCorner(Index cRows, Index cCols) const

This is the const version of bottomLeftCorner<int, int>(Index, Index).

template<typename Derived> template<typename NRowsType, typename NColsType>

FixedBlockXpr<...,...>::Type Eigen::DenseBase<Derived>::bottomRightCorner(NRowsType cRows, NColsType cCols)

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.bottomRightCorner(2, 2):" << endl;
cout << m.bottomRightCorner(2, 2) << endl;
m.bottomRightCorner(2, 2).setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.bottomRightCorner(2, 2):
0 9
3 9
Now the matrix m is:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  0
 6  6  0  0

The number of rows blockRows and columns blockCols can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NRowsType, typename NColsType>

const ConstFixedBlockXpr<...,...>::Type Eigen::DenseBase<Derived>::bottomRightCorner(NRowsType cRows, NColsType cCols) const

This is the const version of bottomRightCorner(NRowsType, NColsType).

template<typename Derived> template<int CRows, int CCols>

FixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomRightCorner()

The template parameters CRows and CCols are the number of rows and columns in the corner.

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.bottomRightCorner<2,2>():" << endl;
cout << m.bottomRightCorner<2,2>() << endl;
m.bottomRightCorner<2,2>().setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

block(Index,Index,NRowsType,NColsType), class Block

template<typename Derived> template<int CRows, int CCols>

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomRightCorner() const

This is the const version of bottomRightCorner<int, int>().

template<typename Derived> template<int CRows, int CCols>

FixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomRightCorner(Index cRows, Index cCols)

This function is mainly useful for corners where the number of rows is specified at compile-time and the number of columns is specified at run-time, or vice versa. The compile-time and run-time information should not contradict. In other words, cRows should equal CRows unless CRows is Dynamic, and the same for the number of columns.

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.bottomRightCorner<2,Dynamic>(2,2):" << endl;
cout << m.bottomRightCorner<2,Dynamic>(2,2) << endl;
m.bottomRightCorner<2,Dynamic>(2,2).setZero();
cout << "Now the matrix m is:" << endl << m << endl;

Output:

class Block

template<typename Derived> template<int CRows, int CCols>

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::DenseBase<Derived>::bottomRightCorner(Index cRows, Index cCols) const

This is the const version of bottomRightCorner<int, int>(Index, Index).

template<typename Derived> template<typename NRowsType>

NRowsBlockXpr<...>::Type Eigen::DenseBase<Derived>::bottomRows(NRowsType n)

Example:

Array44i a = Array44i::Random();
cout << "Here is the array a:" << endl << a << endl;
cout << "Here is a.bottomRows(2):" << endl;
cout << a.bottomRows(2) << endl;
a.bottomRows(2).setZero();
cout << "Now the array a is:" << endl << a << endl;

Output:

Here is the array a:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is a.bottomRows(2):
 6 -3  0  9
 6  6  3  9
Now the array a is:
 7  9 -5 -3
-2 -6  1  0
 0  0  0  0
 0  0  0  0

The number of rows n can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NRowsType>

const ConstNRowsBlockXpr<...>::Type Eigen::DenseBase<Derived>::bottomRows(NRowsType n) const

This is the const version of bottomRows(NRowsType).

template<typename Derived> template<int N>

NRowsBlockXpr<N>::Type Eigen::DenseBase<Derived>::bottomRows(Index n = N)

The compile-time and run-time information should not contradict. In other words, n should equal N unless N is Dynamic.

Example:

Array44i a = Array44i::Random();
cout << "Here is the array a:" << endl << a << endl;
cout << "Here is a.bottomRows<2>():" << endl;
cout << a.bottomRows<2>() << endl;
a.bottomRows<2>().setZero();
cout << "Now the array a is:" << endl << a << endl;

Output:

block(Index,Index,NRowsType,NColsType), class Block

template<typename Derived> template<int N>

ConstNRowsBlockXpr<N>::Type Eigen::DenseBase<Derived>::bottomRows(Index n = N) const

This is the const version of bottomRows<int>().

template<typename Derived> template<typename NewType>

CastXpr<NewType>::Type Eigen::DenseBase<Derived>::cast() const

The template parameter NewScalar is the type we are casting the scalars to.

template<typename Derived>

const_iterator Eigen::DenseBase<Derived>::cbegin() const

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.

template<typename Derived>

const_iterator Eigen::DenseBase<Derived>::cend() const

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.

template<typename Derived>

ColXpr Eigen::DenseBase<Derived>::col(Index i)

Example:

Matrix3d m = Matrix3d::Identity();
m.col(1) = Vector3d(4,5,6);
cout << m << endl;

Output:

row(), class Block

template<typename Derived>

ConstColXpr Eigen::DenseBase<Derived>::col(Index i) const

This is the const version of col().

template<typename Derived>

ConstColwiseReturnType Eigen::DenseBase<Derived>::colwise() const

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:
  0.68  0.597  -0.33
-0.211  0.823  0.536
 0.566 -0.605 -0.444
Here is the sum of each column:
  1.04  0.815 -0.238
Here is the maximum absolute value of each column:
 0.68 0.823 0.536

template<typename Derived>

ColwiseReturnType Eigen::DenseBase<Derived>::colwise()

template<typename Derived>

ConjugateReturnType Eigen::DenseBase<Derived>::conjugate() const

template<typename Derived> template<bool Cond>

internal::conditional<Cond, ConjugateReturnType, const Derived&>::type Eigen::DenseBase<Derived>::conjugateIf() const

template<typename Derived>

Index Eigen::DenseBase<Derived>::count() const

template<typename Derived>

iterator Eigen::DenseBase<Derived>::end()

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.

template<typename Derived>

const_iterator Eigen::DenseBase<Derived>::end() const

const version of end()

template<typename Derived>

EvalReturnType Eigen::DenseBase<Derived>::eval() const

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.

template<typename Derived>

void Eigen::DenseBase<Derived>::fill(const Scalar& value)

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

template<typename Derived> template<unsigned int Added, unsigned int Removed>

EIGEN_DEPRECATED const Derived& Eigen::DenseBase<Derived>::flagged() const

template<typename Derived>

const WithFormat<Derived> Eigen::DenseBase<Derived>::format(const IOFormat& fmt) const

See class IOFormat for some examples.

template<typename Derived>

bool Eigen::DenseBase<Derived>::hasNaN() const

template<typename Derived> template<typename NType>

FixedSegmentReturnType<...>::Type Eigen::DenseBase<Derived>::head(NType n)

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:

RowVector4i v = RowVector4i::Random();
cout << "Here is the vector v:" << endl << v << endl;
cout << "Here is v.head(2):" << endl << v.head(2) << endl;
v.head(2).setZero();
cout << "Now the vector v is:" << endl << v << endl;

Output:

Here is the vector v:
 7 -2  6  6
Here is v.head(2):
 7 -2
Now the vector v is:
0 0 6 6

The number of coefficients n can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NType>

const ConstFixedSegmentReturnType<...>::Type Eigen::DenseBase<Derived>::head(NType n) const

This is the const version of head(NType).

template<typename Derived> template<int N>

FixedSegmentReturnType<N>::Type Eigen::DenseBase<Derived>::head(Index n = N)

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.

The compile-time and run-time information should not contradict. In other words, n should equal N unless N is Dynamic.

Example:

RowVector4i v = RowVector4i::Random();
cout << "Here is the vector v:" << endl << v << endl;
cout << "Here is v.head(2):" << endl << v.head<2>() << endl;
v.head<2>().setZero();
cout << "Now the vector v is:" << endl << v << endl;

Output:

Here is the vector v:
 7 -2  6  6
Here is v.head(2):
 7 -2
Now the vector v is:
0 0 6 6

template<typename Derived> template<int N>

ConstFixedSegmentReturnType<N>::Type Eigen::DenseBase<Derived>::head(Index n = N) const

This is the const version of head<int>().

template<typename Derived>

const ImagReturnType Eigen::DenseBase<Derived>::imag() const

template<typename Derived>

NonConstImagReturnType Eigen::DenseBase<Derived>::imag()

template<typename Derived>

Index Eigen::DenseBase<Derived>::innerSize() const

template<typename Derived>

InnerVectorReturnType Eigen::DenseBase<Derived>::innerVector(Index outer)

template<typename Derived>

const ConstInnerVectorReturnType Eigen::DenseBase<Derived>::innerVector(Index outer) const

template<typename Derived>

InnerVectorsReturnType Eigen::DenseBase<Derived>::innerVectors(Index outerStart, Index outerSize)

template<typename Derived>

const ConstInnerVectorsReturnType Eigen::DenseBase<Derived>::innerVectors(Index outerStart, Index outerSize) const

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived>

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

template<typename Derived>

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

This is just an alias for isApproxToConstant().

template<typename Derived> template<typename Derived>

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

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.

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived>

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

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

template<typename Derived>

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

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

template<typename Derived> template<typename NColsType>

NColsBlockXpr<...>::Type Eigen::DenseBase<Derived>::leftCols(NColsType n)

Example:

Array44i a = Array44i::Random();
cout << "Here is the array a:" << endl << a << endl;
cout << "Here is a.leftCols(2):" << endl;
cout << a.leftCols(2) << endl;
a.leftCols(2).setZero();
cout << "Now the array a is:" << endl << a << endl;

Output:

Here is the array a:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is a.leftCols(2):
 7  9
-2 -6
 6 -3
 6  6
Now the array a is:
 0  0 -5 -3
 0  0  1  0
 0  0  0  9
 0  0  3  9

The number of columns n can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NColsType>

const ConstNColsBlockXpr<...>::Type Eigen::DenseBase<Derived>::leftCols(NColsType n) const

This is the const version of leftCols(NColsType).

template<typename Derived> template<int N>

NColsBlockXpr<N>::Type Eigen::DenseBase<Derived>::leftCols(Index n = N)

The compile-time and run-time information should not contradict. In other words, n should equal N unless N is Dynamic.

Example:

Array44i a = Array44i::Random();
cout << "Here is the array a:" << endl << a << endl;
cout << "Here is a.leftCols<2>():" << endl;
cout << a.leftCols<2>() << endl;
a.leftCols<2>().setZero();
cout << "Now the array a is:" << endl << a << endl;

Output:

block(Index,Index,NRowsType,NColsType), class Block

template<typename Derived> template<int N>

ConstNColsBlockXpr<N>::Type Eigen::DenseBase<Derived>::leftCols(Index n = N) const

This is the const version of leftCols<int>().

template<typename Derived>

internal::traits<Derived>::Scalar Eigen::DenseBase<Derived>::maxCoeff() const

template<typename Derived> template<typename IndexType>

internal::traits<Derived>::Scalar Eigen::DenseBase<Derived>::maxCoeff(IndexType* row, IndexType* col) const

template<typename Derived> template<typename IndexType>

internal::traits<Derived>::Scalar Eigen::DenseBase<Derived>::maxCoeff(IndexType* index) const

template<typename Derived>

Scalar Eigen::DenseBase<Derived>::mean() const

template<typename Derived> template<typename NColsType>

NColsBlockXpr<...>::Type Eigen::DenseBase<Derived>::middleCols(Index startCol, NColsType numCols)

Example:

#include <Eigen/Core>
#include <iostream>

using namespace Eigen;
using namespace std;

int main(void)
{
    int const N = 5;
    MatrixXi A(N,N);
    A.setRandom();
    cout << "A =\n" << A << '\n' << endl;
    cout << "A(1..3,:) =\n" << A.middleCols(1,3) << endl;
    return 0;
}

Output:

A =
  7  -6   0   9 -10
 -2  -3   3   3  -5
  6   6  -3   5  -8
  6  -5   0  -8   6
  9   1   9   2  -7

A(1..3,:) =
-6  0  9
-3  3  3
 6 -3  5
-5  0 -8
 1  9  2

The number of columns n can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NColsType>

const ConstNColsBlockXpr<...>::Type Eigen::DenseBase<Derived>::middleCols(Index startCol, NColsType numCols) const

This is the const version of middleCols(Index,NColsType).

template<typename Derived> template<int N>

NColsBlockXpr<N>::Type Eigen::DenseBase<Derived>::middleCols(Index startCol, Index n = N)

The compile-time and run-time information should not contradict. In other words, n should equal N unless N is Dynamic.

Example:

#include <Eigen/Core>
#include <iostream>

using namespace Eigen;
using namespace std;

int main(void)
{
    int const N = 5;
    MatrixXi A(N,N);
    A.setRandom();
    cout << "A =\n" << A << '\n' << endl;
    cout << "A(:,1..3) =\n" << A.middleCols<3>(1) << endl;
    return 0;
}

Output:

block(Index,Index,NRowsType,NColsType), class Block

template<typename Derived> template<int N>

ConstNColsBlockXpr<N>::Type Eigen::DenseBase<Derived>::middleCols(Index startCol, Index n = N) const

This is the const version of middleCols<int>().

template<typename Derived> template<typename NRowsType>

NRowsBlockXpr<...>::Type Eigen::DenseBase<Derived>::middleRows(Index startRow, NRowsType n)

Example:

#include <Eigen/Core>
#include <iostream>

using namespace Eigen;
using namespace std;

int main(void)
{
    int const N = 5;
    MatrixXi A(N,N);
    A.setRandom();
    cout << "A =\n" << A << '\n' << endl;
    cout << "A(2..3,:) =\n" << A.middleRows(2,2) << endl;
    return 0;
}

Output:

A =
  7  -6   0   9 -10
 -2  -3   3   3  -5
  6   6  -3   5  -8
  6  -5   0  -8   6
  9   1   9   2  -7

A(2..3,:) =
 6  6 -3  5 -8
 6 -5  0 -8  6

The number of rows n can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NRowsType>

const ConstNRowsBlockXpr<...>::Type Eigen::DenseBase<Derived>::middleRows(Index startRow, NRowsType n) const

This is the const version of middleRows(Index,NRowsType).

template<typename Derived> template<int N>

NRowsBlockXpr<N>::Type Eigen::DenseBase<Derived>::middleRows(Index startRow, Index n = N)

The compile-time and run-time information should not contradict. In other words, n should equal N unless N is Dynamic.

Example:

#include <Eigen/Core>
#include <iostream>

using namespace Eigen;
using namespace std;

int main(void)
{
    int const N = 5;
    MatrixXi A(N,N);
    A.setRandom();
    cout << "A =\n" << A << '\n' << endl;
    cout << "A(1..3,:) =\n" << A.middleRows<3>(1) << endl;
    return 0;
}

Output:

block(Index,Index,NRowsType,NColsType), class Block

template<typename Derived> template<int N>

ConstNRowsBlockXpr<N>::Type Eigen::DenseBase<Derived>::middleRows(Index startRow, Index n = N) const

This is the const version of middleRows<int>().

template<typename Derived>

internal::traits<Derived>::Scalar Eigen::DenseBase<Derived>::minCoeff() const

template<typename Derived> template<typename IndexType>

internal::traits<Derived>::Scalar Eigen::DenseBase<Derived>::minCoeff(IndexType* row, IndexType* col) const

template<typename Derived> template<typename IndexType>

internal::traits<Derived>::Scalar Eigen::DenseBase<Derived>::minCoeff(IndexType* index) const

template<typename Derived>

const NestByValue<Derived> Eigen::DenseBase<Derived>::nestByValue() const

template<typename Derived>

Index Eigen::DenseBase<Derived>::nonZeros() const

template<typename Derived> template<typename RowIndices, typename ColIndices>

IndexedView_or_Block Eigen::DenseBase<Derived>::operator()(const RowIndices& rowIndices, const ColIndices& colIndices)

Each parameter must either be:

• An integer indexing a single row or column
• Eigen::all indexing the full set of respective rows or columns in increasing order
• An ArithmeticSequence as returned by the Eigen::seq and Eigen::seqN functions
• Any Eigen's vector/array of integers or expressions
• Plain C arrays: int[N]

• And more generally any type exposing the following two member functions:

  <integral type> operator[](<integral type>) const;
  <integral type> size() const;

  where <integral type> stands for any integer type compatible with Eigen::Index (i.e. std::ptrdiff_t).

The last statement implies compatibility with std::vector, std::valarray, std::array, many of the Range-v3's ranges, etc.

If the submatrix can be represented using a starting position (i,j) and positive sizes (rows,columns), then this method will returns a Block object after extraction of the relevant information from the passed arguments. This is the case when all arguments are either:

• An integer
• Eigen::all
• An ArithmeticSequence with compile-time increment strictly equal to 1, as returned by Eigen::seq(a,b), and Eigen::seqN(a,N).

Otherwise a more general IndexedView<Derived,RowIndices',ColIndices'> object will be returned, after conversion of the inputs to more suitable types RowIndices' and ColIndices'.

For 1D vectors and arrays, you better use the operator()(const Indices&) overload, which behave the same way but taking a single parameter.

See also this question and its answer for an example of how to duplicate coefficients.

template<typename Derived> template<typename Indices>

IndexedView_or_VectorBlock Eigen::DenseBase<Derived>::operator()(const Indices& indices)

This is an overload of operator()(const RowIndices&, const ColIndices&) for 1D vectors or arrays

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.

template<typename Derived>

const NegativeReturnType Eigen::DenseBase<Derived>::operator-() const

template<typename Derived>

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

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;

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

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived> template<typename OtherDerived>

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

Copies other into *this.

template<typename Derived>

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

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

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

template<typename Derived>

Index Eigen::DenseBase<Derived>::outerSize() const

template<typename Derived>

Scalar Eigen::DenseBase<Derived>::prod() const

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:
  0.68  0.597  -0.33
-0.211  0.823  0.536
 0.566 -0.605 -0.444
Here is the product of all the coefficients:
0.0019

template<typename Derived>

RealReturnType Eigen::DenseBase<Derived>::real() const

template<typename Derived>

NonConstRealReturnType Eigen::DenseBase<Derived>::real()

template<typename Derived> template<typename Func>

internal::traits<Derived>::Scalar Eigen::DenseBase<Derived>::redux(const Func& func) const

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.

template<typename Derived> template<int RowFactor, int ColFactor>

const Replicate<Derived, RowFactor, ColFactor> Eigen::DenseBase<Derived>::replicate() const

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:
 7  6  9
-2  6 -6
m.replicate<3,2>() = ...
 7  6  9  7  6  9
-2  6 -6 -2  6 -6
 7  6  9  7  6  9
-2  6 -6 -2  6 -6
 7  6  9  7  6  9
-2  6 -6 -2  6 -6

template<typename Derived>

const Replicate<Derived, Dynamic, Dynamic> Eigen::DenseBase<Derived>::replicate(Index rowFactor, Index colFactor) const

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:
 7
-2
 6
v.replicate(2,5) = ...
 7  7  7  7  7
-2 -2 -2 -2 -2
 6  6  6  6  6
 7  7  7  7  7
-2 -2 -2 -2 -2
 6  6  6  6  6

template<typename Derived> template<int Order = ColMajor, typename NRowsType, typename NColsType>

Reshaped<Derived,...> Eigen::DenseBase<Derived>::reshaped(NRowsType nRows, NColsType nCols)

Dynamic size example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.reshaped(2, 8):" << endl << m.reshaped(2, 8) << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.reshaped(2, 8):
 7  6  9 -3 -5  0 -3  9
-2  6 -6  6  1  3  0  9

The number of rows nRows and columns nCols can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. In the later case, n plays the role of a runtime fallback value in case N equals Eigen::Dynamic. Here is an example with a fixed number of rows and columns:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.reshaped(fix<2>,fix<8>):" << endl << m.reshaped(fix<2>,fix<8>) << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.reshaped(fix<2>,fix<8>):
 7  6  9 -3 -5  0 -3  9
-2  6 -6  6  1  3  0  9

Finally, one of the sizes parameter can be automatically deduced from the other one by passing AutoSize as in the following example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.reshaped(2, AutoSize):" << endl << m.reshaped(2, AutoSize) << endl;
cout << "Here is m.reshaped<RowMajor>(AutoSize, fix<8>):" << endl << m.reshaped<RowMajor>(AutoSize, fix<8>) << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.reshaped(2, AutoSize):
 7  6  9 -3 -5  0 -3  9
-2  6 -6  6  1  3  0  9
Here is m.reshaped<RowMajor>(AutoSize, fix<8>):
 7  9 -5 -3 -2 -6  1  0
 6 -3  0  9  6  6  3  9

AutoSize does preserve compile-time sizes when possible, i.e., when the sizes of the input are known at compile time and that the other size is passed at compile-time using Eigen::fix<N> as above.

template<typename Derived> template<int Order = ColMajor, typename NRowsType, typename NColsType>

const Reshaped<const Derived,...> Eigen::DenseBase<Derived>::reshaped(NRowsType nRows, NColsType nCols) const

This is the const version of reshaped(NRowsType,NColsType).

template<typename Derived> template<int Order = ColMajor>

Reshaped<Derived,...> Eigen::DenseBase<Derived>::reshaped()

This overloads is essentially a shortcut for A.reshaped<Order>(AutoSize,fix<1>).

• If Order==ColMajor (the default), then it returns a column-vector from the stacked columns of *this.
• If Order==RowMajor, then it returns a column-vector from the stacked rows of *this.
• If Order==AutoOrder, then it returns a column-vector with elements stacked following the storage order of *this. This mode is the recommended one when the particular ordering of the element is not relevant.

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.reshaped().transpose():" << endl << m.reshaped().transpose() << endl;
cout << "Here is m.reshaped<RowMajor>().transpose():  " << endl << m.reshaped<RowMajor>().transpose() << endl;

Output:

Here is the matrix m:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is m.reshaped().transpose():
 7 -2  6  6  9 -6 -3  6 -5  1  0  3 -3  0  9  9
Here is m.reshaped<RowMajor>().transpose():  
 7  9 -5 -3 -2 -6  1  0  6 -3  0  9  6  6  3  9

If you want more control, you can still fall back to reshaped(NRowsType,NColsType).

template<typename Derived> template<int Order = ColMajor>

const Reshaped<const Derived,...> Eigen::DenseBase<Derived>::reshaped() const

This is the const version of reshaped().

template<typename Derived>

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

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.

template<typename Derived>

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

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.

template<typename Derived>

ReverseReturnType Eigen::DenseBase<Derived>::reverse()

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:
 7  6 -3  1
-2  9  6  0
 6 -6 -5  3
Here is the reverse of m:
 3 -5 -6  6
 0  6  9 -2
 1 -3  6  7
Here is the coefficient (1,0) in the reverse of m:
0
Let us overwrite this coefficient with the value 4.
Now the matrix m is:
 7  6 -3  1
-2  9  6  4
 6 -6 -5  3

template<typename Derived>

ConstReverseReturnType Eigen::DenseBase<Derived>::reverse() const

This is the const version of reverse().

template<typename Derived>

void Eigen::DenseBase<Derived>::reverseInPlace()

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

template<typename Derived> template<typename NColsType>

NColsBlockXpr<...>::Type Eigen::DenseBase<Derived>::rightCols(NColsType n)

Example:

Array44i a = Array44i::Random();
cout << "Here is the array a:" << endl << a << endl;
cout << "Here is a.rightCols(2):" << endl;
cout << a.rightCols(2) << endl;
a.rightCols(2).setZero();
cout << "Now the array a is:" << endl << a << endl;

Output:

Here is the array a:
 7  9 -5 -3
-2 -6  1  0
 6 -3  0  9
 6  6  3  9
Here is a.rightCols(2):
-5 -3
 1  0
 0  9
 3  9
Now the array a is:
 7  9  0  0
-2 -6  0  0
 6 -3  0  0
 6  6  0  0

The number of columns n can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NColsType>

const ConstNColsBlockXpr<...>::Type Eigen::DenseBase<Derived>::rightCols(NColsType n) const

This is the const version of rightCols(NColsType).

template<typename Derived> template<int N>

NColsBlockXpr<N>::Type Eigen::DenseBase<Derived>::rightCols(Index n = N)

The compile-time and run-time information should not contradict. In other words, n should equal N unless N is Dynamic.

Example:

Array44i a = Array44i::Random();
cout << "Here is the array a:" << endl << a << endl;
cout << "Here is a.rightCols<2>():" << endl;
cout << a.rightCols<2>() << endl;
a.rightCols<2>().setZero();
cout << "Now the array a is:" << endl << a << endl;

Output:

block(Index,Index,NRowsType,NColsType), class Block

template<typename Derived> template<int N>

ConstNColsBlockXpr<N>::Type Eigen::DenseBase<Derived>::rightCols(Index n = N) const

This is the const version of rightCols<int>().

template<typename Derived>

RowXpr Eigen::DenseBase<Derived>::row(Index i)

Example:

Matrix3d m = Matrix3d::Identity();
m.row(1) = Vector3d(4,5,6);
cout << m << endl;

Output:

col(), class Block

template<typename Derived>

ConstRowXpr Eigen::DenseBase<Derived>::row(Index i) const

This is the const version of row(). */.

template<typename Derived>

ConstRowwiseReturnType Eigen::DenseBase<Derived>::rowwise() const

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:
  0.68  0.597  -0.33
-0.211  0.823  0.536
 0.566 -0.605 -0.444
Here is the sum of each row:
 0.948
  1.15
-0.483
Here is the maximum absolute value of each row:
 0.68
0.823
0.605

template<typename Derived>

RowwiseReturnType Eigen::DenseBase<Derived>::rowwise()

template<typename Derived> template<typename NType>

FixedSegmentReturnType<...>::Type Eigen::DenseBase<Derived>::segment(Index start, NType n)

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:

RowVector4i v = RowVector4i::Random();
cout << "Here is the vector v:" << endl << v << endl;
cout << "Here is v.segment(1, 2):" << endl << v.segment(1, 2) << endl;
v.segment(1, 2).setZero();
cout << "Now the vector v is:" << endl << v << endl;

Output:

Here is the vector v:
 7 -2  6  6
Here is v.segment(1, 2):
-2  6
Now the vector v is:
7 0 0 6

The number of coefficients n can also be specified at compile-time by passing Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See block() for the details.

template<typename Derived> template<typename NType>

const ConstFixedSegmentReturnType<...>::Type Eigen::DenseBase<Derived>::segment(Index start, NType n) const

This is the const version of segment(Index,NType).

template<typename Derived> template<int N>

FixedSegmentReturnType<N>::Type Eigen::DenseBase<Derived>::segment(Index start, Index n = N)

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.

The compile-time and run-time information should not contradict. In other words, n should equal N unless N is Dynamic.

Example:

RowVector4i v = RowVector4i::Random();
cout << "Here is the vector v:" << endl << v << endl;
cout << "Here is v.segment<2>(1):" << endl << v.segment<2>(1) << endl;
v.segment<2>(2).setZero();
cout << "Now the vector v is:" << endl << v << endl;

Output:

Here is the vector v:
 7 -2  6  6
Here is v.segment<2>(1):
-2  6
Now the vector v is:
 7 -2  0  0

template<typename Derived> template<int N>

ConstFixedSegmentReturnType<N>::Type Eigen::DenseBase<Derived>::segment(Index start, Index n = N) const

This is the const version of segment<int>(Index).

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

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;

Output:

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

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

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

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

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

template<typename Derived>

Derived& Eigen::DenseBase<Derived>::setConstant(const Scalar& value)

Sets all coefficients in this expression to value val.

template<typename Derived>

Derived& Eigen::DenseBase<Derived>::setLinSpaced(Index size, const Scalar& low, const Scalar& high)

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.

template<typename Derived>

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

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.

template<typename Derived>

Derived& Eigen::DenseBase<Derived>::setOnes()

Sets all coefficients in this expression to one.

Example:

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

Output:

 7  9 -5 -3
 1  1  1  1
 6 -3  0  9
 6  6  3  9

template<typename Derived>

Derived& Eigen::DenseBase<Derived>::setRandom()

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.

Example:

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

Output:

 0  7  0  0
 0 -2  0  0
 0  6  0  0
 0  6  0  0

template<typename Derived>

Derived& Eigen::DenseBase<Derived>::setZero()

Sets all coefficients in this expression to zero.

Example:

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

Output:

 7  9 -5 -3
 0  0  0  0
 6 -3  0  9
 6  6  3  9

template<typename Derived> template<DirectionType Direction>

internal::conditional<Direction==Vertical, ColXpr, RowXpr>::type Eigen::DenseBase<Derived>::subVector(Index i)