blob: f2de749f92b3c7da7f9883c6122513a6a97ddedc [file] [log] [blame]
Narayan Kamathc981c482012-11-02 10:59:05 +00001// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
5// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
6//
7// This Source Code Form is subject to the terms of the Mozilla
8// Public License v. 2.0. If a copy of the MPL was not distributed
9// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10
11#ifndef EIGEN_CWISE_UNARY_OP_H
12#define EIGEN_CWISE_UNARY_OP_H
13
14namespace Eigen {
15
16/** \class CwiseUnaryOp
17 * \ingroup Core_Module
18 *
19 * \brief Generic expression where a coefficient-wise unary operator is applied to an expression
20 *
21 * \param UnaryOp template functor implementing the operator
22 * \param XprType the type of the expression to which we are applying the unary operator
23 *
24 * This class represents an expression where a unary operator is applied to an expression.
25 * It is the return type of all operations taking exactly 1 input expression, regardless of the
26 * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
27 * is considered unary, because only the right-hand side is an expression, and its
28 * return type is a specialization of CwiseUnaryOp.
29 *
30 * Most of the time, this is the only way that it is used, so you typically don't have to name
31 * CwiseUnaryOp types explicitly.
32 *
33 * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
34 */
35
36namespace internal {
37template<typename UnaryOp, typename XprType>
38struct traits<CwiseUnaryOp<UnaryOp, XprType> >
39 : traits<XprType>
40{
41 typedef typename result_of<
42 UnaryOp(typename XprType::Scalar)
43 >::type Scalar;
44 typedef typename XprType::Nested XprTypeNested;
45 typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
46 enum {
47 Flags = _XprTypeNested::Flags & (
48 HereditaryBits | LinearAccessBit | AlignedBit
49 | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
50 CoeffReadCost = _XprTypeNested::CoeffReadCost + functor_traits<UnaryOp>::Cost
51 };
52};
53}
54
55template<typename UnaryOp, typename XprType, typename StorageKind>
56class CwiseUnaryOpImpl;
57
58template<typename UnaryOp, typename XprType>
59class CwiseUnaryOp : internal::no_assignment_operator,
60 public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>
61{
62 public:
63
64 typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base;
65 EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
66
67 inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
68 : m_xpr(xpr), m_functor(func) {}
69
70 EIGEN_STRONG_INLINE Index rows() const { return m_xpr.rows(); }
71 EIGEN_STRONG_INLINE Index cols() const { return m_xpr.cols(); }
72
73 /** \returns the functor representing the unary operation */
74 const UnaryOp& functor() const { return m_functor; }
75
76 /** \returns the nested expression */
77 const typename internal::remove_all<typename XprType::Nested>::type&
78 nestedExpression() const { return m_xpr; }
79
80 /** \returns the nested expression */
81 typename internal::remove_all<typename XprType::Nested>::type&
82 nestedExpression() { return m_xpr.const_cast_derived(); }
83
84 protected:
85 typename XprType::Nested m_xpr;
86 const UnaryOp m_functor;
87};
88
89// This is the generic implementation for dense storage.
90// It can be used for any expression types implementing the dense concept.
91template<typename UnaryOp, typename XprType>
92class CwiseUnaryOpImpl<UnaryOp,XprType,Dense>
93 : public internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type
94{
95 public:
96
97 typedef CwiseUnaryOp<UnaryOp, XprType> Derived;
98 typedef typename internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
99 EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
100
Carlos Hernandez7faaa9f2014-08-05 17:53:32 -0700101 EIGEN_STRONG_INLINE const Scalar coeff(Index rowId, Index colId) const
Narayan Kamathc981c482012-11-02 10:59:05 +0000102 {
Carlos Hernandez7faaa9f2014-08-05 17:53:32 -0700103 return derived().functor()(derived().nestedExpression().coeff(rowId, colId));
Narayan Kamathc981c482012-11-02 10:59:05 +0000104 }
105
106 template<int LoadMode>
Carlos Hernandez7faaa9f2014-08-05 17:53:32 -0700107 EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
Narayan Kamathc981c482012-11-02 10:59:05 +0000108 {
Carlos Hernandez7faaa9f2014-08-05 17:53:32 -0700109 return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(rowId, colId));
Narayan Kamathc981c482012-11-02 10:59:05 +0000110 }
111
112 EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
113 {
114 return derived().functor()(derived().nestedExpression().coeff(index));
115 }
116
117 template<int LoadMode>
118 EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
119 {
120 return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(index));
121 }
122};
123
124} // end namespace Eigen
125
126#endif // EIGEN_CWISE_UNARY_OP_H