Pseudo expression providing partial reduction operations. More...

#include <VectorwiseOp.h>

Collaboration diagram for Eigen::VectorwiseOp< ExpressionType, Direction >:

Classes
struct	ExtendedType

struct	OppositeExtendedType

struct	ReduxReturnType

struct	ReturnType

Public Types
enum	{ IsVertical = (Direction==Vertical) ? 1 : 0, IsHorizontal = (Direction==Horizontal) ? 1 : 0 }

enum	{ HNormalized_Size, HNormalized_SizeMinusOne = HNormalized_Size==Dynamic ? Dynamic : HNormalized_Size-1 }

typedef ExpressionType::Scalar	Scalar

typedef ExpressionType::RealScalar	RealScalar

typedef ExpressionType::Index	Index

typedef internal::conditional< internal::must_nest_by_value< ExpressionType >::ret, ExpressionType, ExpressionType & >::type	ExpressionTypeNested

typedef internal::remove_all< ExpressionTypeNested >::type	ExpressionTypeNestedCleaned

typedef Replicate< ExpressionType, Direction==Vertical?Dynamic:1, Direction==Horizontal?Dynamic:1 >	ReplicateReturnType

typedef ExpressionType::PlainObject	CrossReturnType

typedef Block< const ExpressionType, Direction==Vertical?int(HNormalized_SizeMinusOne):int(internal::traits< ExpressionType >::RowsAtCompileTime), Direction==Horizontal?int(HNormalized_SizeMinusOne):int(internal::traits< ExpressionType >::ColsAtCompileTime)>	HNormalized_Block

typedef Block< const ExpressionType, Direction==Vertical?1:int(internal::traits< ExpressionType >::RowsAtCompileTime), Direction==Horizontal?1:int(internal::traits< ExpressionType >::ColsAtCompileTime)>	HNormalized_Factors

typedef CwiseBinaryOp< internal::scalar_quotient_op< typename internal::traits< ExpressionType >::Scalar >, const HNormalized_Block, const Replicate< HNormalized_Factors, Direction==Vertical?HNormalized_SizeMinusOne:1, Direction==Horizontal?HNormalized_SizeMinusOne:1 > >	HNormalizedReturnType

Public Member Functions
	VectorwiseOp (ExpressionType &matrix)

const ExpressionType &	_expression () const

template<typename BinaryOp >
const ReduxReturnType< BinaryOp >::Type	redux (const BinaryOp &func=BinaryOp()) const

const ReturnType< internal::member_minCoeff >::Type	minCoeff () const

const ReturnType< internal::member_maxCoeff >::Type	maxCoeff () const

const ReturnType< internal::member_squaredNorm, RealScalar >::Type	squaredNorm () const

const ReturnType< internal::member_norm, RealScalar >::Type	norm () const

const ReturnType< internal::member_blueNorm, RealScalar >::Type	blueNorm () const

const ReturnType< internal::member_stableNorm, RealScalar >::Type	stableNorm () const

const ReturnType< internal::member_hypotNorm, RealScalar >::Type	hypotNorm () const

const ReturnType< internal::member_sum >::Type	sum () const

const ReturnType< internal::member_mean >::Type	mean () const

const ReturnType< internal::member_all >::Type	all () const

const ReturnType< internal::member_any >::Type	any () const

const PartialReduxExpr< ExpressionType, internal::member_count< Index >, Direction >	count () const

const ReturnType< internal::member_prod >::Type	prod () const

const Reverse< ExpressionType, Direction >	reverse () const

const ReplicateReturnType	replicate (Index factor) const

template<int Factor>
const Replicate< ExpressionType,(IsVertical?Factor:1),(IsHorizontal?Factor:1)>	replicate (Index factor=Factor) const

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

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

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

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

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

template<typename OtherDerived >
EIGEN_STRONG_INLINE CwiseBinaryOp< internal::scalar_sum_op< Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type >	operator+ (const DenseBase< OtherDerived > &other) const

template<typename OtherDerived >
CwiseBinaryOp< internal::scalar_difference_op< Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type >	operator- (const DenseBase< OtherDerived > &other) const

template<typename OtherDerived >
EIGEN_STRONG_INLINE CwiseBinaryOp< internal::scalar_product_op< Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type >	operator* (const DenseBase< OtherDerived > &other) const

template<typename OtherDerived >
CwiseBinaryOp< internal::scalar_quotient_op< Scalar >, const ExpressionTypeNestedCleaned, const typename ExtendedType< OtherDerived >::Type >	operator/ (const DenseBase< OtherDerived > &other) const

CwiseBinaryOp< internal::scalar_quotient_op< Scalar >, const ExpressionTypeNestedCleaned, const typename OppositeExtendedType< typename ReturnType< internal::member_norm, RealScalar >::Type >::Type >	normalized () const

void	normalize ()

template<typename OtherDerived >
const CrossReturnType	cross (const MatrixBase< OtherDerived > &other) const

const HNormalizedReturnType	hnormalized () const

Protected Types
typedef internal::conditional< Direction==Vertical, typename ExpressionType::ColXpr, typename ExpressionType::RowXpr >::type	SubVector

Protected Member Functions
SubVector	subVector (Index i)

Index	subVectors () const

template<typename OtherDerived >
ExtendedType< OtherDerived >::Type	extendedTo (const DenseBase< OtherDerived > &other) const

template<typename OtherDerived >
OppositeExtendedType< OtherDerived >::Type	extendedToOpposite (const DenseBase< OtherDerived > &other) const

Protected Attributes
ExpressionTypeNested	m_matrix

Detailed Description

template<typename ExpressionType, int Direction>
class Eigen::VectorwiseOp< ExpressionType, Direction >

Pseudo expression providing partial reduction operations.

Parameters

ExpressionType	the type of the object on which to do partial reductions
Direction	indicates the direction of the redux (#Vertical or #Horizontal)

This class represents a pseudo expression with 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 used.

Example:

Output:

See also: DenseBase::colwise(), DenseBase::rowwise(), class PartialReduxExpr

Definition at line 212 of file ForwardDeclarations.h.

Member Function Documentation

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_all>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::all ( void ) const

inline

Returns: a row (or column) vector expression representing whether all coefficients of each respective column (or row) are true.

See also: DenseBase::all()

Definition at line 370 of file VectorwiseOp.h.

371 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_any>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::any ( void ) const

inline

Returns: a row (or column) vector expression representing whether at least one coefficient of each respective column (or row) is true.

See also: DenseBase::any()

Definition at line 377 of file VectorwiseOp.h.

378 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_blueNorm,RealScalar>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::blueNorm ( ) const

inline

Returns: a row (or column) vector expression of the norm of each column (or row) of the referenced expression, using blue's algorithm.

See also: DenseBase::blueNorm()

Definition at line 328 of file VectorwiseOp.h.

329 { return _expression(); }

template<typename ExpressionType, int Direction>

const PartialReduxExpr<ExpressionType, internal::member_count<Index>, Direction> Eigen::VectorwiseOp< ExpressionType, Direction >::count ( ) const

inline

Returns: a row (or column) vector expression representing the number of true coefficients of each respective column (or row).

Example:

Output:

See also: DenseBase::count()

Definition at line 387 of file VectorwiseOp.h.

388 { return _expression(); }

template<typename ExpressionType , int Direction>

template<typename OtherDerived >

const VectorwiseOp< ExpressionType, Direction >::CrossReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::cross ( const MatrixBase< OtherDerived > & other ) const

Returns: a matrix expression of the cross product of each column or row of the referenced expression with the other vector.

The referenced matrix must have one dimension equal to 3. The result matrix has the same dimensions than the referenced one.

See also: MatrixBase::cross()

Definition at line 101 of file OrthoMethods.h.

 {
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
   EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
     YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
 
   CrossReturnType res(_expression().rows(),_expression().cols());
   if(Direction==Vertical)
   {
     eigen_assert(CrossReturnType::RowsAtCompileTime==3 && "the matrix must have exactly 3 rows");
     res.row(0) = (_expression().row(1) * other.coeff(2) - _expression().row(2) * other.coeff(1)).conjugate();
     res.row(1) = (_expression().row(2) * other.coeff(0) - _expression().row(0) * other.coeff(2)).conjugate();
     res.row(2) = (_expression().row(0) * other.coeff(1) - _expression().row(1) * other.coeff(0)).conjugate();
   }
   else
   {
     eigen_assert(CrossReturnType::ColsAtCompileTime==3 && "the matrix must have exactly 3 columns");
     res.col(0) = (_expression().col(1) * other.coeff(2) - _expression().col(2) * other.coeff(1)).conjugate();
     res.col(1) = (_expression().col(2) * other.coeff(0) - _expression().col(0) * other.coeff(2)).conjugate();
     res.col(2) = (_expression().col(0) * other.coeff(1) - _expression().col(1) * other.coeff(0)).conjugate();
   }
   return res;
 }

template<typename ExpressionType , int Direction>

const VectorwiseOp< ExpressionType, Direction >::HNormalizedReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::hnormalized ( ) const

inline

Returns: an expression of the homogeneous normalized vector of *this

Example:

Output:

See also: MatrixBase::hnormalized()

Definition at line 176 of file Homogeneous.h.

 {
   return HNormalized_Block(_expression(),0,0,
       Direction==Vertical   ? _expression().rows()-1 : _expression().rows(),
       Direction==Horizontal ? _expression().cols()-1 : _expression().cols()).cwiseQuotient(
       Replicate<HNormalized_Factors,
                 Direction==Vertical   ? HNormalized_SizeMinusOne : 1,
                 Direction==Horizontal ? HNormalized_SizeMinusOne : 1>
         (HNormalized_Factors(_expression(),
           Direction==Vertical    ? _expression().rows()-1:0,
           Direction==Horizontal  ? _expression().cols()-1:0,
           Direction==Vertical    ? 1 : _expression().rows(),
           Direction==Horizontal  ? 1 : _expression().cols()),
          Direction==Vertical   ? _expression().rows()-1 : 1,
          Direction==Horizontal ? _expression().cols()-1 : 1));
 }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_hypotNorm,RealScalar>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::hypotNorm ( ) const

inline

Returns: a row (or column) vector expression of the norm of each column (or row) of the referenced expression, avoiding underflow and overflow using a concatenation of hypot() calls.

See also: DenseBase::hypotNorm()

Definition at line 346 of file VectorwiseOp.h.

347 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_maxCoeff>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::maxCoeff ( ) const

inline

Returns: a row (or column) vector expression of the largest coefficient of each column (or row) of the referenced expression.

Warning: the result is undefined if *this contains NaN.

Example:

Output:

See also: DenseBase::maxCoeff()

Definition at line 299 of file VectorwiseOp.h.

300 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_mean>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::mean ( ) const

inline

Returns: a row (or column) vector expression of the mean of each column (or row) of the referenced expression.

See also: DenseBase::mean()

Definition at line 363 of file VectorwiseOp.h.

364 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_minCoeff>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::minCoeff ( ) const

inline

Returns: a row (or column) vector expression of the smallest coefficient of each column (or row) of the referenced expression.

Warning: the result is undefined if *this contains NaN.

Example:

Output:

See also: DenseBase::minCoeff()

Definition at line 287 of file VectorwiseOp.h.

288 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_norm,RealScalar>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::norm ( ) const

inline

Returns: a row (or column) vector expression of the norm of each column (or row) of the referenced expression.

Example:

Output:

See also: DenseBase::norm()

Definition at line 319 of file VectorwiseOp.h.

320 { return _expression(); }

template<typename ExpressionType, int Direction>

void Eigen::VectorwiseOp< ExpressionType, Direction >::normalize ( )

inline

Normalize in-place each row or columns of the referenced matrix.

See also: MatrixBase::normalize(), normalized()

Definition at line 547 of file VectorwiseOp.h.

                      {
       m_matrix = this->normalized();
     }

template<typename ExpressionType, int Direction>

CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const ExpressionTypeNestedCleaned, const typename OppositeExtendedType<typename ReturnType<internal::member_norm,RealScalar>::Type>::Type> Eigen::VectorwiseOp< ExpressionType, Direction >::normalized ( ) const

inline

Returns: an expression where each column of row of the referenced matrix are normalized. The referenced matrix is not modified.

See also: MatrixBase::normalized(), normalize()

Definition at line 541 of file VectorwiseOp.h.

541 { return m_matrix.cwiseQuotient(extendedToOpposite(this->norm())); }

Eigen::VectorwiseOp::norm

const ReturnType< internal::member_norm, RealScalar >::Type norm() const

Definition: VectorwiseOp.h:319

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

EIGEN_STRONG_INLINE CwiseBinaryOp<internal::scalar_product_op<Scalar>, const ExpressionTypeNestedCleaned, const typename ExtendedType<OtherDerived>::Type> Eigen::VectorwiseOp< ExpressionType, Direction >::operator* ( const DenseBase< OtherDerived > & other ) const

inline

Returns the expression where each subvector is the product of the vector other by the corresponding subvector of *this

Definition at line 512 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       return m_matrix * extendedTo(other.derived());
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

ExpressionType& Eigen::VectorwiseOp< ExpressionType, Direction >::operator*= ( const DenseBase< OtherDerived > & other )

inline

Multiples each subvector of *this by the vector other

Definition at line 462 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       m_matrix *= extendedTo(other.derived());
       return const_cast<ExpressionType&>(m_matrix);
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

EIGEN_STRONG_INLINE CwiseBinaryOp<internal::scalar_sum_op<Scalar>, const ExpressionTypeNestedCleaned, const typename ExtendedType<OtherDerived>::Type> Eigen::VectorwiseOp< ExpressionType, Direction >::operator+ ( const DenseBase< OtherDerived > & other ) const

inline

Returns the expression of the sum of the vector other to each subvector of *this

Definition at line 487 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       return m_matrix + extendedTo(other.derived());
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

ExpressionType& Eigen::VectorwiseOp< ExpressionType, Direction >::operator+= ( const DenseBase< OtherDerived > & other )

inline

Adds the vector other to each subvector of *this

Definition at line 444 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       return const_cast<ExpressionType&>(m_matrix += extendedTo(other.derived()));
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

CwiseBinaryOp<internal::scalar_difference_op<Scalar>, const ExpressionTypeNestedCleaned, const typename ExtendedType<OtherDerived>::Type> Eigen::VectorwiseOp< ExpressionType, Direction >::operator- ( const DenseBase< OtherDerived > & other ) const

inline

Returns the expression of the difference between each subvector of *this and the vector other

Definition at line 499 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       return m_matrix - extendedTo(other.derived());
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

ExpressionType& Eigen::VectorwiseOp< ExpressionType, Direction >::operator-= ( const DenseBase< OtherDerived > & other )

inline

Substracts the vector other to each subvector of *this

Definition at line 453 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       return const_cast<ExpressionType&>(m_matrix -= extendedTo(other.derived()));
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

CwiseBinaryOp<internal::scalar_quotient_op<Scalar>, const ExpressionTypeNestedCleaned, const typename ExtendedType<OtherDerived>::Type> Eigen::VectorwiseOp< ExpressionType, Direction >::operator/ ( const DenseBase< OtherDerived > & other ) const

inline

Returns the expression where each subvector is the quotient of the corresponding subvector of *this by the vector other

Definition at line 526 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       return m_matrix / extendedTo(other.derived());
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

ExpressionType& Eigen::VectorwiseOp< ExpressionType, Direction >::operator/= ( const DenseBase< OtherDerived > & other )

inline

Divides each subvector of *this by the vector other

Definition at line 473 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_ARRAYXPR(ExpressionType)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       m_matrix /= extendedTo(other.derived());
       return const_cast<ExpressionType&>(m_matrix);
     }

template<typename ExpressionType, int Direction>

template<typename OtherDerived >

ExpressionType& Eigen::VectorwiseOp< ExpressionType, Direction >::operator= ( const DenseBase< OtherDerived > & other )

inline

Copies the vector other to each subvector of *this

Definition at line 434 of file VectorwiseOp.h.

     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
       EIGEN_STATIC_ASSERT_SAME_XPR_KIND(ExpressionType, OtherDerived)
       //eigen_assert((m_matrix.isNull()) == (other.isNull())); FIXME
       return const_cast<ExpressionType&>(m_matrix = extendedTo(other.derived()));
     }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_prod>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::prod ( ) const

inline

Returns: a row (or column) vector expression of the product of each column (or row) of the referenced expression.

Example:

Output:

See also: DenseBase::prod()

Definition at line 397 of file VectorwiseOp.h.

398 { return _expression(); }

template<typename ExpressionType, int Direction>

template<typename BinaryOp >

const ReduxReturnType<BinaryOp>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::redux ( const BinaryOp & func = BinaryOp() ) const

inline

Returns: a row or column vector expression of *this reduxed by func

The template parameter BinaryOp is the type of the functor of the custom redux operator. Note that func must be an associative operator.

See also: class VectorwiseOp, DenseBase::colwise(), DenseBase::rowwise()

Definition at line 275 of file VectorwiseOp.h.

276 { return typename ReduxReturnType<BinaryOp>::Type(_expression(), func); }

template<typename ExpressionType , int Direction>

const VectorwiseOp< ExpressionType, Direction >::ReplicateReturnType Eigen::VectorwiseOp< ExpressionType, Direction >::replicate ( Index factor ) const

Returns: an expression of the replication of each column (or row) of *this

Example:

Output:

See also: VectorwiseOp::replicate(), DenseBase::replicate(), class Replicate

Definition at line 169 of file Replicate.h.

 {
   return typename VectorwiseOp<ExpressionType,Direction>::ReplicateReturnType
           (_expression(),Direction==Vertical?factor:1,Direction==Horizontal?factor:1);
 }

template<typename ExpressionType, int Direction>

template<int Factor>

const Replicate<ExpressionType,(IsVertical?Factor:1),(IsHorizontal?Factor:1)> Eigen::VectorwiseOp< ExpressionType, Direction >::replicate ( Index factor = Factor ) const

inline

Returns: an expression of the replication of each column (or row) of *this

Example:

Output:

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

Definition at line 424 of file VectorwiseOp.h.

     {
       return Replicate<ExpressionType,Direction==Vertical?Factor:1,Direction==Horizontal?Factor:1>
           (_expression(),Direction==Vertical?factor:1,Direction==Horizontal?factor:1);
     }

template<typename ExpressionType, int Direction>

const Reverse<ExpressionType, Direction> Eigen::VectorwiseOp< ExpressionType, Direction >::reverse ( ) const

inline

Returns: a matrix expression where each column (or row) are reversed.

Example:

Output:

See also: DenseBase::reverse()

Definition at line 408 of file VectorwiseOp.h.

409 { return Reverse<ExpressionType, Direction>( _expression() ); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_squaredNorm,RealScalar>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::squaredNorm ( ) const

inline

Returns: a row (or column) vector expression of the squared norm of each column (or row) of the referenced expression.

Example:

Output:

See also: DenseBase::squaredNorm()

Definition at line 309 of file VectorwiseOp.h.

310 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_stableNorm,RealScalar>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::stableNorm ( ) const

inline

Returns: a row (or column) vector expression of the norm of each column (or row) of the referenced expression, avoiding underflow and overflow.

See also: DenseBase::stableNorm()

Definition at line 337 of file VectorwiseOp.h.

338 { return _expression(); }

template<typename ExpressionType, int Direction>

const ReturnType<internal::member_sum>::Type Eigen::VectorwiseOp< ExpressionType, Direction >::sum ( ) const

inline

Returns: a row (or column) vector expression of the sum of each column (or row) of the referenced expression.

Example:

Output:

See also: DenseBase::sum()

Definition at line 356 of file VectorwiseOp.h.

357 { return _expression(); }

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

C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/Core/util/ForwardDeclarations.h
C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/Core/VectorwiseOp.h
C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/Core/Replicate.h
C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/Geometry/Homogeneous.h
C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/Geometry/OrthoMethods.h

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

template<typename ExpressionType, int Direction> class Eigen::VectorwiseOp< ExpressionType, Direction >

Member Function Documentation

template<typename ExpressionType, int Direction>
class Eigen::VectorwiseOp< ExpressionType, Direction >