You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
126 lines
4.6 KiB
126 lines
4.6 KiB
// This file is part of Eigen, a lightweight C++ template library |
|
// for linear algebra. |
|
// |
|
// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr> |
|
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com> |
|
// |
|
// This Source Code Form is subject to the terms of the Mozilla |
|
// Public License v. 2.0. If a copy of the MPL was not distributed |
|
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/. |
|
|
|
#ifndef EIGEN_CWISE_UNARY_OP_H |
|
#define EIGEN_CWISE_UNARY_OP_H |
|
|
|
namespace Eigen { |
|
|
|
/** \class CwiseUnaryOp |
|
* \ingroup Core_Module |
|
* |
|
* \brief Generic expression where a coefficient-wise unary operator is applied to an expression |
|
* |
|
* \param UnaryOp template functor implementing the operator |
|
* \param XprType the type of the expression to which we are applying the unary operator |
|
* |
|
* This class represents an expression where a unary operator is applied to an expression. |
|
* It is the return type of all operations taking exactly 1 input expression, regardless of the |
|
* presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix |
|
* is considered unary, because only the right-hand side is an expression, and its |
|
* return type is a specialization of CwiseUnaryOp. |
|
* |
|
* Most of the time, this is the only way that it is used, so you typically don't have to name |
|
* CwiseUnaryOp types explicitly. |
|
* |
|
* \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp |
|
*/ |
|
|
|
namespace internal { |
|
template<typename UnaryOp, typename XprType> |
|
struct traits<CwiseUnaryOp<UnaryOp, XprType> > |
|
: traits<XprType> |
|
{ |
|
typedef typename result_of< |
|
UnaryOp(typename XprType::Scalar) |
|
>::type Scalar; |
|
typedef typename XprType::Nested XprTypeNested; |
|
typedef typename remove_reference<XprTypeNested>::type _XprTypeNested; |
|
enum { |
|
Flags = _XprTypeNested::Flags & ( |
|
HereditaryBits | LinearAccessBit | AlignedBit |
|
| (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)), |
|
CoeffReadCost = EIGEN_ADD_COST(_XprTypeNested::CoeffReadCost, functor_traits<UnaryOp>::Cost) |
|
}; |
|
}; |
|
} |
|
|
|
template<typename UnaryOp, typename XprType, typename StorageKind> |
|
class CwiseUnaryOpImpl; |
|
|
|
template<typename UnaryOp, typename XprType> |
|
class CwiseUnaryOp : internal::no_assignment_operator, |
|
public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind> |
|
{ |
|
public: |
|
|
|
typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base; |
|
EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp) |
|
|
|
inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp()) |
|
: m_xpr(xpr), m_functor(func) {} |
|
|
|
EIGEN_STRONG_INLINE Index rows() const { return m_xpr.rows(); } |
|
EIGEN_STRONG_INLINE Index cols() const { return m_xpr.cols(); } |
|
|
|
/** \returns the functor representing the unary operation */ |
|
const UnaryOp& functor() const { return m_functor; } |
|
|
|
/** \returns the nested expression */ |
|
const typename internal::remove_all<typename XprType::Nested>::type& |
|
nestedExpression() const { return m_xpr; } |
|
|
|
/** \returns the nested expression */ |
|
typename internal::remove_all<typename XprType::Nested>::type& |
|
nestedExpression() { return m_xpr.const_cast_derived(); } |
|
|
|
protected: |
|
typename XprType::Nested m_xpr; |
|
const UnaryOp m_functor; |
|
}; |
|
|
|
// This is the generic implementation for dense storage. |
|
// It can be used for any expression types implementing the dense concept. |
|
template<typename UnaryOp, typename XprType> |
|
class CwiseUnaryOpImpl<UnaryOp,XprType,Dense> |
|
: public internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type |
|
{ |
|
public: |
|
|
|
typedef CwiseUnaryOp<UnaryOp, XprType> Derived; |
|
typedef typename internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base; |
|
EIGEN_DENSE_PUBLIC_INTERFACE(Derived) |
|
|
|
EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const |
|
{ |
|
return derived().functor()(derived().nestedExpression().coeff(rowId, colId)); |
|
} |
|
|
|
template<int LoadMode> |
|
EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const |
|
{ |
|
return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(rowId, colId)); |
|
} |
|
|
|
EIGEN_STRONG_INLINE const Scalar coeff(Index index) const |
|
{ |
|
return derived().functor()(derived().nestedExpression().coeff(index)); |
|
} |
|
|
|
template<int LoadMode> |
|
EIGEN_STRONG_INLINE PacketScalar packet(Index index) const |
|
{ |
|
return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(index)); |
|
} |
|
}; |
|
|
|
} // end namespace Eigen |
|
|
|
#endif // EIGEN_CWISE_UNARY_OP_H
|
|
|