template<typename ExpressionType, int Direction>
 class Eigen::VectorwiseOp< ExpressionType, Direction >
 Pseudo expression providing broadcasting and partial reduction operations. 
 
- Template Parameters
-   
| ExpressionType | the type of the object on which to do partial reductions |  
| Direction | indicates whether to operate on columns (Vertical) or rows (Horizontal) |  
 
This class represents a pseudo expression with broadcasting and partial reduction features. It is the return type of DenseBase::colwise() and DenseBase::rowwise() and most of the time this is the only way it is explicitly used.
 To understand the logic of rowwise/colwise expression, let's consider a generic case A.colwise().foo() where foo is any method of VectorwiseOp. This expression is equivalent to applying foo() to each column of A and then re-assemble the outputs in a matrix expression: 
[A.col(0).foo(), A.col(1).foo(), ..., A.col(A.cols()-1).foo()] 
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
The begin() and end() methods are obviously exceptions to the previous rule as they return STL-compatible begin/end iterators to the rows or columns of the nested expression. Typical use cases include for-range-loop and calls to STL algorithms:
 Example: 
Matrix3i m = Matrix3i::Random();
cout << "Here is the initial matrix m:" << endl << m << endl;
int i = -1;
for(auto c: m.colwise()) {
  c *= i;
  ++i;
}
cout << "Here is the matrix m after the for-range-loop:" << endl << m << endl;
auto cols = m.colwise();
auto it = std::find_if(cols.cbegin(), cols.cend(),
                       [](Matrix3i::ConstColXpr x) { return x.squaredNorm() == 0; });
cout << "The first empty column is: " << distance(cols.cbegin(),it) << endl;
 Output: 
Here is the initial matrix m:
 7  6 -3
-2  9  6
 6 -6 -5
Here is the matrix m after the for-range-loop:
-7  0 -3
 2  0  6
-6  0 -5
The first empty column is: 1
For a partial reduction on an empty input, some rules apply. For the sake of clarity, let's consider a vertical reduction:
 - If the number of columns is zero, then a 1x0 row-major vector expression is returned.
- Otherwise, if the number of rows is zero, then - a row vector of zeros is returned for sum-like reductions (sum, squaredNorm, norm, etc.)
- a row vector of ones is returned for a product reduction (e.g., MatrixXd(n,0).colwise().prod())
- an assert is triggered for all other reductions (minCoeff,maxCoeff,redux(bin_op))
 
- See also
- 
DenseBase::colwise(), DenseBase::rowwise(), class PartialReduxExpr 
 
 |  | 
 
| const AllReturnType | all () const | 
 |  | 
 
| const AnyReturnType | any () const | 
 |  | 
 
| iterator | begin () | 
 |  | 
 
| const_iterator | begin () const | 
 |  | 
 
| const BlueNormReturnType | blueNorm () const | 
 |  | 
 
| const_iterator | cbegin () const | 
 |  | 
 
| const_iterator | cend () const | 
 |  | 
 
| const CountReturnType | count () const | 
 |  | 
 
| const_reverse_iterator | crbegin () const | 
 |  | 
 
| const_reverse_iterator | crend () const | 
 |  | 
 | template<typename OtherDerived > | 
 
| const CrossReturnType | cross (const MatrixBase< OtherDerived > &other) const | 
 |  | 
 
| iterator | end () | 
 |  | 
 
| const_iterator | end () const | 
 |  | 
 
| const HNormalizedReturnType | hnormalized () const | 
 
|  | column or row-wise homogeneous normalization More... 
 | 
 |  | 
 
| HomogeneousReturnType | homogeneous () const | 
 |  | 
 
| const HypotNormReturnType | hypotNorm () const | 
 |  | 
 | template<int p> | 
 
| const LpNormReturnType< p >::Type | lpNorm () const | 
 |  | 
 
| const MaxCoeffReturnType | maxCoeff () const | 
 |  | 
 
| const MeanReturnType | mean () const | 
 |  | 
 
| const MinCoeffReturnType | minCoeff () const | 
 |  | 
 
| const NormReturnType | norm () const | 
 |  | 
 
| void | normalize () | 
 |  | 
 
| CwiseBinaryOp< internal::scalar_quotient_op< Scalar >, const ExpressionTypeNestedCleaned, const typename OppositeExtendedType< NormReturnType >::Type > | normalized () const | 
 |  | 
 | template<typename OtherDerived > | 
 
| CwiseBinaryOp< internal::scalar_product_op< Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type > | operator* (const DenseBase< OtherDerived > &other) const | 
 |  | 
 | template<typename OtherDerived > | 
 
| ExpressionType & | operator*= (const DenseBase< OtherDerived > &other) | 
 |  | 
 | template<typename OtherDerived > | 
 
| CwiseBinaryOp< internal::scalar_sum_op< Scalar, typename OtherDerived::Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type > | operator+ (const DenseBase< OtherDerived > &other) const | 
 |  | 
 | template<typename OtherDerived > | 
 
| ExpressionType & | operator+= (const DenseBase< OtherDerived > &other) | 
 |  | 
 | template<typename OtherDerived > | 
 
| CwiseBinaryOp< internal::scalar_difference_op< Scalar, typename OtherDerived::Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type > | operator- (const DenseBase< OtherDerived > &other) const | 
 |  | 
 | template<typename OtherDerived > | 
 
| ExpressionType & | operator-= (const DenseBase< OtherDerived > &other) | 
 |  | 
 | template<typename OtherDerived > | 
 
| CwiseBinaryOp< internal::scalar_quotient_op< Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type > | operator/ (const DenseBase< OtherDerived > &other) const | 
 |  | 
 | template<typename OtherDerived > | 
 
| ExpressionType & | operator/= (const DenseBase< OtherDerived > &other) | 
 |  | 
 | template<typename OtherDerived > | 
 
| ExpressionType & | operator= (const DenseBase< OtherDerived > &other) | 
 |  | 
 
| const ProdReturnType | prod () const | 
 |  | 
 
| reverse_iterator | rbegin () | 
 |  | 
 
| const_reverse_iterator | rbegin () const | 
 |  | 
 | template<typename BinaryOp > | 
 
| const ReduxReturnType< BinaryOp >::Type | redux (const BinaryOp &func=BinaryOp()) const | 
 |  | 
 
| reverse_iterator | rend () | 
 |  | 
 
| const_reverse_iterator | rend () const | 
 |  | 
 
| const ReplicateReturnType | replicate (Index factor) const | 
 |  | 
 | template<int Factor> | 
 
| const Replicate< ExpressionType, isVertical *Factor+isHorizontal, isHorizontal *Factor+isVertical > | replicate (Index factor=Factor) const | 
 |  | 
 
| ReverseReturnType | reverse () | 
 |  | 
 
| const ConstReverseReturnType | reverse () const | 
 |  | 
 
| void | reverseInPlace () | 
 |  | 
 
| const SquaredNormReturnType | squaredNorm () const | 
 |  | 
 
| const StableNormReturnType | stableNorm () const | 
 |  | 
 
| const SumReturnType | sum () const | 
 |  | 
 
   template<typename ExpressionType , int Direction> 
   
 
- Returns
- a row (or column) vector expression representing the number of truecoefficients of each respective column (or row). This expression can be assigned to a vector whose entries have the same type as is used to index entries of the original matrix; for dense matrices, this isstd::ptrdiff_t.
Example: 
Matrix3d m = Matrix3d::Random();
cout << "Here is the matrix m:" << endl << m << endl;
Matrix<ptrdiff_t, 3, 1> res = (m.array() >= 0.5).rowwise().count();
cout << "Here is the count of elements larger or equal than 0.5 of each row:" << endl;
cout << res << 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 count of elements larger or equal than 0.5 of each row:
2
2
1
- See also
- 
DenseBase::count() 
       template<typename ExpressionType , int Direction> 
   
 
- Returns
- a matrix expression where each column (or row) are reversed.
Example: 
MatrixXi m = MatrixXi::Random(3,4);
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the rowwise reverse of m:" << endl << m.rowwise().reverse() << endl;
cout << "Here is the colwise reverse of m:" << endl << m.colwise().reverse() << endl;
 
cout << "Here is the coefficient (1,0) in the rowise reverse of m:" << endl
<< m.rowwise().reverse()(1,0) << endl;
cout << "Let us overwrite this coefficient with the value 4." << endl;
//m.colwise().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 rowwise reverse of m:
 1 -3  6  7
 0  6  9 -2
 3 -5 -6  6
Here is the colwise reverse of m:
 6 -6 -5  3
-2  9  6  0
 7  6 -3  1
Here is the coefficient (1,0) in the rowise 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  0
 6 -6 -5  3
- See also
- 
DenseBase::reverse() 
       template<typename ExpressionType , int Direction> 
   
 This is the "in place" version of VectorwiseOp::reverse: it reverses each column or row of *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
- See also
- 
DenseBase::reverseInPlace(), reverse()