template<typename Derived>

Eigen::SparseMatrixBase class

template<typename Derived>

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

template<typename Derived>

typedef internal::conditional<NumTraits<Scalar>::IsComplex, CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, Eigen::Transpose<const Derived>>, Transpose<const Derived>>::type Eigen::SparseMatrixBase<Derived>::AdjointReturnType

template<typename Derived>

typedef internal::add_const<Transpose<const Derived>>::type Eigen::SparseMatrixBase<Derived>::ConstTransposeReturnType

template<typename Derived>

typedef CwiseUnaryOp<internal::scalar_abs2_op<Scalar>, const Derived> Eigen::SparseMatrixBase<Derived>::CwiseAbs2ReturnType

template<typename Derived>

typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> Eigen::SparseMatrixBase<Derived>::CwiseAbsReturnType

template<typename Derived>

typedef CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const Derived> Eigen::SparseMatrixBase<Derived>::CwiseInverseReturnType

template<typename Derived>

typedef CwiseBinaryOp<internal::scalar_cmp_op<Scalar, Scalar, internal::cmp_EQ>, const Derived, const ConstantReturnType> Eigen::SparseMatrixBase<Derived>::CwiseScalarEqualReturnType

template<typename Derived>

typedef CwiseUnaryOp<internal::scalar_sign_op<Scalar>, const Derived> Eigen::SparseMatrixBase<Derived>::CwiseSignReturnType

template<typename Derived>

typedef CwiseUnaryOp<internal::scalar_sqrt_op<Scalar>, const Derived> Eigen::SparseMatrixBase<Derived>::CwiseSqrtReturnType

template<typename Derived>

typedef Matrix<StorageIndex, Dynamic, 1> Eigen::SparseMatrixBase<Derived>::IndexVector

template<typename Derived>

typedef internal::add_const_on_value_type_if_arithmetic<typename internal::packet_traits<Scalar>::type>::type Eigen::SparseMatrixBase<Derived>::PacketReturnType

template<typename Derived>

typedef internal::packet_traits<Scalar>::type Eigen::SparseMatrixBase<Derived>::PacketScalar

template<typename Derived>

typedef SparseMatrix<Scalar, Flags&RowMajorBit ? RowMajor :ColMajor, StorageIndex> Eigen::SparseMatrixBase<Derived>::PlainObject

template<typename Derived>

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

template<typename Derived>

typedef Matrix<Scalar, Dynamic, 1> Eigen::SparseMatrixBase<Derived>::ScalarVector

template<typename Derived>

typedef SparseMatrixBase Eigen::SparseMatrixBase<Derived>::StorageBaseType

template<typename Derived>

typedef internal::traits<Derived>::StorageIndex Eigen::SparseMatrixBase<Derived>::StorageIndex

The integer type used to store indices within a SparseMatrix. For a SparseMatrix<Scalar,Options,IndexType> it an alias of the third template parameter IndexType.

template<typename Derived>

typedef internal::traits<Derived>::StorageKind Eigen::SparseMatrixBase<Derived>::StorageKind

template<typename Derived>

typedef Transpose<Derived> Eigen::SparseMatrixBase<Derived>::TransposeReturnType

template<typename Derived>

typedef Scalar Eigen::SparseMatrixBase<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>

Eigen::SparseMatrixBase<Derived>::SparseMatrixBase()

template<typename Derived>

const AdjointReturnType Eigen::SparseMatrixBase<Derived>::adjoint() const

template<typename Derived> template<typename CustomBinaryOp, typename OtherDerived>

const CwiseBinaryOp<CustomBinaryOp, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::binaryExpr(const Eigen::SparseMatrixBase<OtherDerived>& other, const CustomBinaryOp& func = CustomBinaryOp()) const

The template parameter CustomBinaryOp is the type of the functor of the custom operator (see class CwiseBinaryOp for an example)

Here is an example illustrating the use of custom functors:

#include <Eigen/Core>
#include <iostream>
using namespace Eigen;
using namespace std;

// define a custom template binary functor
template<typename Scalar> struct MakeComplexOp {
  EIGEN_EMPTY_STRUCT_CTOR(MakeComplexOp)
  typedef complex<Scalar> result_type;
  complex<Scalar> operator()(const Scalar& a, const Scalar& b) const { return complex<Scalar>(a,b); }
};

int main(int, char**)
{
  Matrix4d m1 = Matrix4d::Random(), m2 = Matrix4d::Random();
  cout << m1.binaryExpr(m2, MakeComplexOp<double>()) << endl;
  return 0;
}

Output:

   (0.68,0.271)  (0.823,-0.967) (-0.444,-0.687)   (-0.27,0.998)
 (-0.211,0.435) (-0.605,-0.514)  (0.108,-0.198) (0.0268,-0.563)
 (0.566,-0.717)  (-0.33,-0.726) (-0.0452,-0.74)  (0.904,0.0259)
  (0.597,0.214)   (0.536,0.608)  (0.258,-0.782)   (0.832,0.678)

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

FixedBlockXpr<...,...>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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>

RealScalar Eigen::SparseMatrixBase<Derived>::blueNorm() const

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

FixedBlockXpr<...,...>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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:

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

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

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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:

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,Dynamic>(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

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

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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:

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

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

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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:

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,Dynamic>(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

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

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<Derived>::bottomRows(NRowsType n) const

This is the const version of bottomRows(NRowsType).

template<typename Derived> template<int N>

NRowsBlockXpr<N>::Type Eigen::SparseMatrixBase<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:

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

template<typename Derived> template<int N>

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

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

template<typename Derived> template<typename NewType>

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

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

This method does not change the sparsity of *this: the conversion function is applied to explicitly stored coefficients only.

template<typename Derived>

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

Example:

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

Output:

1 4 0
0 5 0
0 6 1

template<typename Derived>

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

This is the const version of col().

template<typename Derived>

Index Eigen::SparseMatrixBase<Derived>::cols() const

template<typename Derived>

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

This method does not change the sparsity of *this: the complex conjugate is applied to explicitly stored coefficients only.

template<typename Derived> template<bool Cond>

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

This method does not change the sparsity of *this: the complex conjugate is applied to explicitly stored coefficients only.

template<typename Derived>

const CwiseAbsReturnType Eigen::SparseMatrixBase<Derived>::cwiseAbs() const

Example:

MatrixXd m(2,3);
m << 2, -4, 6,   
     -5, 1, 0;
cout << m.cwiseAbs() << endl;

Output:

2 4 6
5 1 0

This method does not change the sparsity of *this: the absolute value is applied to explicitly stored coefficients only.

template<typename Derived>

const CwiseAbs2ReturnType Eigen::SparseMatrixBase<Derived>::cwiseAbs2() const

Example:

MatrixXd m(2,3);
m << 2, -4, 6,   
     -5, 1, 0;
cout << m.cwiseAbs2() << endl;

Output:

 4 16 36
25  1  0

This method does not change the sparsity of *this: the squared absolute value is applied to explicitly stored coefficients only.

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<std::equal_to<Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::cwiseEqual(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

MatrixXi m(2,2);
m << 1, 0,
     1, 1;
cout << "Comparing m with identity matrix:" << endl;
cout << m.cwiseEqual(MatrixXi::Identity(2,2)) << endl;
Index count = m.cwiseEqual(MatrixXi::Identity(2,2)).count();
cout << "Number of coefficients that are equal: " << count << endl;

Output:

Comparing m with identity matrix:
1 1
0 1
Number of coefficients that are equal: 3

template<typename Derived>

const CwiseScalarEqualReturnType Eigen::SparseMatrixBase<Derived>::cwiseEqual(const Scalar& s) const

template<typename Derived>

const CwiseInverseReturnType Eigen::SparseMatrixBase<Derived>::cwiseInverse() const

Example:

MatrixXd m(2,3);
m << 2, 0.5, 1,   
     3, 0.25, 1;
cout << m.cwiseInverse() << endl;

Output:

  0.5     2     1
0.333     4     1

This method does not change the sparsity of *this: the inverse is applied to explicitly stored coefficients only.

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<internal::scalar_max_op<Scalar, Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::cwiseMax(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

Vector3d v(2,3,4), w(4,2,3);
cout << v.cwiseMax(w) << endl;

Output:

4
3
4

template<typename Derived>

const CwiseBinaryOp<internal::scalar_max_op<Scalar, Scalar>, const Derived, const ConstantReturnType> Eigen::SparseMatrixBase<Derived>::cwiseMax(const Scalar& other) const

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<internal::scalar_min_op<Scalar, Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::cwiseMin(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

Vector3d v(2,3,4), w(4,2,3);
cout << v.cwiseMin(w) << endl;

Output:

2
2
3

template<typename Derived>

const CwiseBinaryOp<internal::scalar_min_op<Scalar, Scalar>, const Derived, const ConstantReturnType> Eigen::SparseMatrixBase<Derived>::cwiseMin(const Scalar& other) const

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<std::not_equal_to<Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::cwiseNotEqual(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

MatrixXi m(2,2);
m << 1, 0,
     1, 1;
cout << "Comparing m with identity matrix:" << endl;
cout << m.cwiseNotEqual(MatrixXi::Identity(2,2)) << endl;
Index count = m.cwiseNotEqual(MatrixXi::Identity(2,2)).count();
cout << "Number of coefficients that are not equal: " << count << endl;

Output:

Comparing m with identity matrix:
0 0
1 0
Number of coefficients that are not equal: 1

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<internal::scalar_product_op<Derived ::Scalar, OtherDerived ::Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::cwiseProduct(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

Matrix3i a = Matrix3i::Random(), b = Matrix3i::Random();
Matrix3i c = a.cwiseProduct(b);
cout << "a:\n" << a << "\nb:\n" << b << "\nc:\n" << c << endl;

Output:

a:
 7  6 -3
-2  9  6
 6 -6 -5
b:
 1 -3  9
 0  0  3
 3  9  5
c:
  7 -18 -27
  0   0  18
 18 -54 -25

template<typename Derived> template<typename OtherDerived>

const CwiseProductDenseReturnType<OtherDerived>::Type Eigen::SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived>& other) const

template<typename Derived> template<typename OtherDerived>

const SparseMatrixBase<Derived>::template CwiseProductDenseReturnType<OtherDerived>::Type Eigen::SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived>& other) const

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::cwiseQuotient(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

Vector3d v(2,3,4), w(4,2,3);
cout << v.cwiseQuotient(w) << endl;

Output:

 0.5
 1.5
1.33

template<typename Derived>

const CwiseSignReturnType Eigen::SparseMatrixBase<Derived>::cwiseSign() const

Example:

MatrixXd m(2,3);
m <<  2, -4, 6,
     -5,  1, 0;
cout << m.cwiseSign() << endl;

Output:

 1 -1  1
-1  1  0

This method does not change the sparsity of *this: the sign function is applied to explicitly stored coefficients only.

template<typename Derived>

const CwiseSqrtReturnType Eigen::SparseMatrixBase<Derived>::cwiseSqrt() const

Example:

Vector3d v(1,2,4);
cout << v.cwiseSqrt() << endl;

Output:

   1
1.41
   2

This method does not change the sparsity of *this: the square-root is applied to explicitly stored coefficients only.

template<typename Derived> template<typename OtherDerived>

internal::traits<Derived>::Scalar Eigen::SparseMatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const

template<typename Derived> template<typename OtherDerived>

internal::traits<Derived>::Scalar Eigen::SparseMatrixBase<Derived>::dot(const SparseMatrixBase<OtherDerived>& other) const

template<typename Derived> template<typename OtherDerived>

Scalar Eigen::SparseMatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const

template<typename Derived> template<typename OtherDerived>

Scalar Eigen::SparseMatrixBase<Derived>::dot(const SparseMatrixBase<OtherDerived>& other) const

template<typename Derived>

const internal::eval<Derived>::type Eigen::SparseMatrixBase<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> template<typename NType>

FixedSegmentReturnType<...>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<Derived>::head(NType n) const

This is the const version of head(NType).

template<typename Derived> template<int N>

FixedSegmentReturnType<N>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<Derived>::head(Index n = N) const

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

template<typename Derived>

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

This method does not change the sparsity of *this: the imaginary part function is applied to explicitly stored coefficients only.

template<typename Derived>

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

This method does not change the sparsity of *this: the imaginary part function is applied to explicitly stored coefficients only.

template<typename Derived>

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

template<typename Derived>

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

template<typename Derived>

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

template<typename Derived>

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

template<typename Derived>

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

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived>

bool Eigen::SparseMatrixBase<Derived>::isRValue() const

template<typename Derived>

bool Eigen::SparseMatrixBase<Derived>::isVector() const

template<typename Derived> template<typename NColsType>

NColsBlockXpr<...>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<Derived>::leftCols(NColsType n) const

This is the const version of leftCols(NColsType).

template<typename Derived> template<int N>

NColsBlockXpr<N>::Type Eigen::SparseMatrixBase<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:

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

template<typename Derived> template<int N>

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

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

template<typename Derived>

Derived& Eigen::SparseMatrixBase<Derived>::markAsRValue()

template<typename Derived> template<typename NColsType>

NColsBlockXpr<...>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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:

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

template<typename Derived> template<int N>

ConstNColsBlockXpr<N>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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:

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,:) =
-2 -3  3  3 -5
 6  6 -3  5 -8
 6 -5  0 -8  6

template<typename Derived> template<int N>

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

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

template<typename Derived>

RealScalar Eigen::SparseMatrixBase<Derived>::norm() const

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<internal::scalar_boolean_and_op, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::operator&&(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

Array3d v(-1,2,1), w(-3,2,3);
cout << ((v<w) && (v<0)) << endl;

Output:

0
0
0

template<typename Derived> template<typename T>

const CwiseBinaryOp<internal::scalar_product_op<Scalar, T>, Derived, Constant<T>> Eigen::SparseMatrixBase<Derived>::operator*(const T& scalar) const

template<typename Derived> template<typename OtherDerived>

const Product<Derived, OtherDerived> Eigen::SparseMatrixBase<Derived>::operator*(const DiagonalBase<OtherDerived>& other) const

template<typename Derived> template<typename OtherDerived>

const Product<Derived, OtherDerived, AliasFreeProduct> Eigen::SparseMatrixBase<Derived>::operator*(const SparseMatrixBase<OtherDerived>& other) const

C = (A*B).pruned();             // suppress numerical zeros (exact)
C = (A*B).pruned(ref);
C = (A*B).pruned(ref,epsilon);

template<typename Derived> template<typename OtherDerived>

const Product<Derived, OtherDerived> Eigen::SparseMatrixBase<Derived>::operator*(const MatrixBase<OtherDerived>& other) const

template<typename Derived>

Derived& Eigen::SparseMatrixBase<Derived>::operator*=(const Scalar& other)

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<sum<Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::operator+(const Eigen::SparseMatrixBase<OtherDerived>& other) const

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived> template<typename OtherDerived>

Derived& Eigen::SparseMatrixBase<Derived>::operator+=(const DiagonalBase<OtherDerived>& other)

template<typename Derived> template<typename OtherDerived>

Derived& Eigen::SparseMatrixBase<Derived>::operator+=(const EigenBase<OtherDerived>& other)

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<difference<Scalar>, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::operator-(const Eigen::SparseMatrixBase<OtherDerived>& other) const

template<typename Derived>

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

This method does not change the sparsity of *this: the opposite is applied to explicitly stored coefficients only.

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived> template<typename OtherDerived>

Derived& Eigen::SparseMatrixBase<Derived>::operator-=(const DiagonalBase<OtherDerived>& other)

template<typename Derived> template<typename OtherDerived>

Derived& Eigen::SparseMatrixBase<Derived>::operator-=(const EigenBase<OtherDerived>& other)

template<typename Derived> template<typename T>

const CwiseBinaryOp<internal::scalar_quotient_op<Scalar, T>, Derived, Constant<T>> Eigen::SparseMatrixBase<Derived>::operator/(const T& scalar) const

template<typename Derived>

Derived& Eigen::SparseMatrixBase<Derived>::operator/=(const Scalar& other)

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived> template<typename OtherDerived>

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

template<typename Derived>

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

template<typename Derived> template<typename OtherDerived>

const CwiseBinaryOp<internal::scalar_boolean_or_op, const Derived, const OtherDerived> Eigen::SparseMatrixBase<Derived>::operator||(const Eigen::SparseMatrixBase<OtherDerived>& other) const

Example:

Array3d v(-1,2,1), w(-3,2,3);
cout << ((v<w) || (v<0)) << endl;

Output:

1
0
1

template<typename Derived>

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

template<typename Derived>

const SparseView<Derived> Eigen::SparseMatrixBase<Derived>::pruned(const Scalar& reference = Scalar(0), const RealScalar& epsilon = NumTraits<Scalar>::dummy_precision()) const

This method is typically used in conjunction with the product of two sparse matrices to automatically prune the smallest values as follows:

C = (A*B).pruned();             // suppress numerical zeros (exact)
C = (A*B).pruned(ref);
C = (A*B).pruned(ref,epsilon);

where ref is a meaningful non zero reference value.

template<typename Derived>

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

This method does not change the sparsity of *this: the real part function is applied to explicitly stored coefficients only.

template<typename Derived>

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

This method does not change the sparsity of *this: the real part function is applied to explicitly stored coefficients only.

template<typename Derived> template<typename NColsType>

NColsBlockXpr<...>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<Derived>::rightCols(NColsType n) const

This is the const version of rightCols(NColsType).

template<typename Derived> template<int N>

NColsBlockXpr<N>::Type Eigen::SparseMatrixBase<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:

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

template<typename Derived> template<int N>

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

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

template<typename Derived>

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

Example:

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

Output:

1 0 0
4 5 6
0 0 1

template<typename Derived>

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

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

template<typename Derived>

Index Eigen::SparseMatrixBase<Derived>::rows() const

template<typename Derived> template<typename NType>

FixedSegmentReturnType<...>::Type Eigen::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<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::SparseMatrixBase<Derived>::segment(Index start, Index n = N) const

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

template<typename Derived> template<unsigned int UpLo>

SparseMatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type Eigen::SparseMatrixBase<Derived>::selfadjointView() const

template<typename Derived> template<unsigned int UpLo>

SparseMatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type Eigen::SparseMatrixBase<Derived>::selfadjointView()

template<typename Derived> template<unsigned int UpLo>

ConstSelfAdjointViewReturnType<UpLo>::Type Eigen::SparseMatrixBase<Derived>::selfadjointView() const

template<typename Derived> template<unsigned int UpLo>

SelfAdjointViewReturnType<UpLo>::Type Eigen::SparseMatrixBase<Derived>::selfadjointView()

template<typename Derived>

Index Eigen::SparseMatrixBase<Derived>::size() const

template<typename Derived>

RealScalar Eigen::SparseMatrixBase<Derived>::squaredNorm() const

template<typename Derived> template<DirectionType Direction>

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

template<typename Derived> template<DirectionType Direction>

internal::conditional<Direction==Vertical, ConstColXpr, ConstRowXpr>::type Eigen::SparseMatrixBase<Derived>::subVector(Index i) const

This is the const version of subVector(Index)

template<typename Derived> template<DirectionType Direction>

Index Eigen::SparseMatrixBase<Derived>::subVectors() const

template<typename Derived>

Scalar Eigen::SparseMatrixBase<Derived>::sum() const

template<typename Derived> template<typename NType>

FixedSegmentReturnType<...>::Type Eigen::SparseMatrixBase<Derived>::tail(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.tail(2):" << endl << v.tail(2) << endl;
v.tail(2).setZero();
cout << "Now the vector v is:" << endl << v << endl;

Output:

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

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::SparseMatrixBase<Derived>::tail(NType n) const

This is the const version of tail(Index).

template<typename Derived> template<int N>

FixedSegmentReturnType<N>::Type Eigen::SparseMatrixBase<Derived>::tail(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.tail(2):" << endl << v.tail<2>() << endl;
v.tail<2>().setZero();
cout << "Now the vector v is:" << endl << v << endl;

Output:

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

template<typename Derived> template<int N>

ConstFixedSegmentReturnType<N>::Type Eigen::SparseMatrixBase<Derived>::tail(Index n = N) const

This is the const version of tail<int>.

template<typename Derived>

DenseMatrixType Eigen::SparseMatrixBase<Derived>::toDense() const

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

FixedBlockXpr<...,...>::Type Eigen::SparseMatrixBase<Derived>::topLeftCorner(NRowsType cRows, NColsType cCols)

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.topLeftCorner(2, 2):" << endl;
cout << m.topLeftCorner(2, 2) << endl;
m.topLeftCorner(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.topLeftCorner(2, 2):
 7  9
-2 -6
Now the matrix m is:
 0  0 -5 -3
 0  0  1  0
 6 -3  0  9
 6  6  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>

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

This is the const version of topLeftCorner(Index, Index).

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

FixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<Derived>::topLeftCorner()

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.topLeftCorner<2,2>():" << endl;
cout << m.topLeftCorner<2,2>() << endl;
m.topLeftCorner<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.topLeftCorner<2,2>():
 7  9
-2 -6
Now the matrix m is:
 0  0 -5 -3
 0  0  1  0
 6 -3  0  9
 6  6  3  9

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

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<Derived>::topLeftCorner() const

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

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

FixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<Derived>::topLeftCorner(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.topLeftCorner<2,Dynamic>(2,2):" << endl;
cout << m.topLeftCorner<2,Dynamic>(2,2) << endl;
m.topLeftCorner<2,Dynamic>(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.topLeftCorner<2,Dynamic>(2,2):
 7  9
-2 -6
Now the matrix m is:
 0  0 -5 -3
 0  0  1  0
 6 -3  0  9
 6  6  3  9

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

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

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

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

FixedBlockXpr<...,...>::Type Eigen::SparseMatrixBase<Derived>::topRightCorner(NRowsType cRows, NColsType cCols)

Example with dynamic sizes:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.topRightCorner(2, 2):" << endl;
cout << m.topRightCorner(2, 2) << endl;
m.topRightCorner(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.topRightCorner(2, 2):
-5 -3
 1  0
Now the matrix m is:
 7  9  0  0
-2 -6  0  0
 6 -3  0  9
 6  6  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>

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

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

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

FixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<Derived>::topRightCorner()

Example:

Matrix4i m = Matrix4i::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is m.topRightCorner<2,2>():" << endl;
cout << m.topRightCorner<2,2>() << endl;
m.topRightCorner<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.topRightCorner<2,2>():
-5 -3
 1  0
Now the matrix m is:
 7  9  0  0
-2 -6  0  0
 6 -3  0  9
 6  6  3  9

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

const ConstFixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<Derived>::topRightCorner() const

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

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

FixedBlockXpr<CRows, CCols>::Type Eigen::SparseMatrixBase<Derived>::topRightCorner(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.topRightCorner<2,Dynamic>(2,2):" << endl;
cout << m.topRightCorner<2,Dynamic>(2,2) << endl;
m.topRightCorner<2,Dynamic>(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.topRightCorner<2,Dynamic>(2,2):
-5 -3
 1  0
Now the matrix m is:
 7  9  0  0
-2 -6  0  0
 6 -3  0  9
 6  6  3  9

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

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

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

template<typename Derived> template<typename NRowsType>

NRowsBlockXpr<...>::Type Eigen::SparseMatrixBase<Derived>::topRows(NRowsType n)

Example:

Array44i a = Array44i::Random();
cout << "Here is the array a:" << endl << a << endl;
cout << "Here is a.topRows(2):" << endl;
cout << a.topRows(2) << endl;
a.topRows(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.topRows(2):
 7  9 -5 -3
-2 -6  1  0
Now the array a is:
 0  0  0  0
 0  0  0  0
 6 -3  0  9
 6  6  3  9

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::SparseMatrixBase<Derived>::topRows(NRowsType n) const

This is the const version of topRows(NRowsType).

template<typename Derived> template<int N>

NRowsBlockXpr<N>::Type Eigen::SparseMatrixBase<Derived>::topRows(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.topRows<2>():" << endl;
cout << a.topRows<2>() << endl;
a.topRows<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.topRows<2>():
 7  9 -5 -3
-2 -6  1  0
Now the array a is:
 0  0  0  0
 0  0  0  0
 6 -3  0  9
 6  6  3  9

template<typename Derived> template<int N>

ConstNRowsBlockXpr<N>::Type Eigen::SparseMatrixBase<Derived>::topRows(Index n = N) const

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

template<typename Derived>

TransposeReturnType Eigen::SparseMatrixBase<Derived>::transpose()

template<typename Derived>

const ConstTransposeReturnType Eigen::SparseMatrixBase<Derived>::transpose() const

template<typename Derived> template<int Mode>

const TriangularView<const Derived, Mode> Eigen::SparseMatrixBase<Derived>::triangularView() const

template<typename Derived>

SparseSymmetricPermutationProduct<Derived, Upper|Lower> Eigen::SparseMatrixBase<Derived>::twistedBy(const PermutationMatrix<Dynamic, Dynamic, StorageIndex>& perm) const

template<typename Derived> template<typename CustomUnaryOp>

const CwiseUnaryOp<CustomUnaryOp, const Derived> Eigen::SparseMatrixBase<Derived>::unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const

Apply a unary operator coefficient-wise.

The function ptr_fun() from the C++ standard library can be used to make functors out of normal functions.

Example:

#include <Eigen/Core>
#include <iostream>
using namespace Eigen;
using namespace std;

// define function to be applied coefficient-wise
double ramp(double x)
{
  if (x > 0)
    return x;
  else 
    return 0;
}

int main(int, char**)
{
  Matrix4d m1 = Matrix4d::Random();
  cout << m1 << endl << "becomes: " << endl << m1.unaryExpr(ptr_fun(ramp)) << endl;
  return 0;
}

Output:

   0.68   0.823  -0.444   -0.27
 -0.211  -0.605   0.108  0.0268
  0.566   -0.33 -0.0452   0.904
  0.597   0.536   0.258   0.832
becomes: 
  0.68  0.823      0      0
     0      0  0.108 0.0268
 0.566      0      0  0.904
 0.597  0.536  0.258  0.832

Genuine functors allow for more possibilities, for instance it may contain a state.

Example:

#include <Eigen/Core>
#include <iostream>
using namespace Eigen;
using namespace std;

// define a custom template unary functor
template<typename Scalar>
struct CwiseClampOp {
  CwiseClampOp(const Scalar& inf, const Scalar& sup) : m_inf(inf), m_sup(sup) {}
  const Scalar operator()(const Scalar& x) const { return x<m_inf ? m_inf : (x>m_sup ? m_sup : x); }
  Scalar m_inf, m_sup;
};

int main(int, char**)
{
  Matrix4d m1 = Matrix4d::Random();
  cout << m1 << endl << "becomes: " << endl << m1.unaryExpr(CwiseClampOp<double>(-0.5,0.5)) << endl;
  return 0;
}

Output:

   0.68   0.823  -0.444   -0.27
 -0.211  -0.605   0.108  0.0268
  0.566   -0.33 -0.0452   0.904
  0.597   0.536   0.258   0.832
becomes: 
    0.5     0.5  -0.444   -0.27
 -0.211    -0.5   0.108  0.0268
    0.5   -0.33 -0.0452     0.5
    0.5     0.5   0.258     0.5

This method does not change the sparsity of *this: the unary function is applied to explicitly stored coefficients only.

template<typename Derived> template<typename CustomViewOp>

const CwiseUnaryView<CustomViewOp, const Derived> Eigen::SparseMatrixBase<Derived>::unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const

The template parameter CustomUnaryOp is the type of the functor of the custom unary operator.

Example:

#include <Eigen/Core>
#include <iostream>
using namespace Eigen;
using namespace std;

// define a custom template unary functor
template<typename Scalar>
struct CwiseClampOp {
  CwiseClampOp(const Scalar& inf, const Scalar& sup) : m_inf(inf), m_sup(sup) {}
  const Scalar operator()(const Scalar& x) const { return x<m_inf ? m_inf : (x>m_sup ? m_sup : x); }
  Scalar m_inf, m_sup;
};

int main(int, char**)
{
  Matrix4d m1 = Matrix4d::Random();
  cout << m1 << endl << "becomes: " << endl << m1.unaryExpr(CwiseClampOp<double>(-0.5,0.5)) << endl;
  return 0;
}