Another set of UI messages fixes and tweaks! No functional changes.
[blender.git] / extern / Eigen3 / Eigen / src / Core / CwiseUnaryOp.h
1 // 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 // Eigen is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU Lesser General Public
9 // License as published by the Free Software Foundation; either
10 // version 3 of the License, or (at your option) any later version.
11 //
12 // Alternatively, you can redistribute it and/or
13 // modify it under the terms of the GNU General Public License as
14 // published by the Free Software Foundation; either version 2 of
15 // the License, or (at your option) any later version.
16 //
17 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
19 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
20 // GNU General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License and a copy of the GNU General Public License along with
24 // Eigen. If not, see <http://www.gnu.org/licenses/>.
25
26 #ifndef EIGEN_CWISE_UNARY_OP_H
27 #define EIGEN_CWISE_UNARY_OP_H
28
29 /** \class CwiseUnaryOp
30   * \ingroup Core_Module
31   *
32   * \brief Generic expression where a coefficient-wise unary operator is applied to an expression
33   *
34   * \param UnaryOp template functor implementing the operator
35   * \param XprType the type of the expression to which we are applying the unary operator
36   *
37   * This class represents an expression where a unary operator is applied to an expression.
38   * It is the return type of all operations taking exactly 1 input expression, regardless of the
39   * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix
40   * is considered unary, because only the right-hand side is an expression, and its
41   * return type is a specialization of CwiseUnaryOp.
42   *
43   * Most of the time, this is the only way that it is used, so you typically don't have to name
44   * CwiseUnaryOp types explicitly.
45   *
46   * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
47   */
48
49 namespace internal {
50 template<typename UnaryOp, typename XprType>
51 struct traits<CwiseUnaryOp<UnaryOp, XprType> >
52  : traits<XprType>
53 {
54   typedef typename result_of<
55                      UnaryOp(typename XprType::Scalar)
56                    >::type Scalar;
57   typedef typename XprType::Nested XprTypeNested;
58   typedef typename remove_reference<XprTypeNested>::type _XprTypeNested;
59   enum {
60     Flags = _XprTypeNested::Flags & (
61       HereditaryBits | LinearAccessBit | AlignedBit
62       | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
63     CoeffReadCost = _XprTypeNested::CoeffReadCost + functor_traits<UnaryOp>::Cost
64   };
65 };
66 }
67
68 template<typename UnaryOp, typename XprType, typename StorageKind>
69 class CwiseUnaryOpImpl;
70
71 template<typename UnaryOp, typename XprType>
72 class CwiseUnaryOp : internal::no_assignment_operator,
73   public CwiseUnaryOpImpl<UnaryOp, XprType, typename internal::traits<XprType>::StorageKind>
74 {
75   public:
76
77     typedef typename CwiseUnaryOpImpl<UnaryOp, XprType,typename internal::traits<XprType>::StorageKind>::Base Base;
78     EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
79
80     inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp())
81       : m_xpr(xpr), m_functor(func) {}
82
83     EIGEN_STRONG_INLINE Index rows() const { return m_xpr.rows(); }
84     EIGEN_STRONG_INLINE Index cols() const { return m_xpr.cols(); }
85
86     /** \returns the functor representing the unary operation */
87     const UnaryOp& functor() const { return m_functor; }
88
89     /** \returns the nested expression */
90     const typename internal::remove_all<typename XprType::Nested>::type&
91     nestedExpression() const { return m_xpr; }
92
93     /** \returns the nested expression */
94     typename internal::remove_all<typename XprType::Nested>::type&
95     nestedExpression() { return m_xpr.const_cast_derived(); }
96
97   protected:
98     const typename XprType::Nested m_xpr;
99     const UnaryOp m_functor;
100 };
101
102 // This is the generic implementation for dense storage.
103 // It can be used for any expression types implementing the dense concept.
104 template<typename UnaryOp, typename XprType>
105 class CwiseUnaryOpImpl<UnaryOp,XprType,Dense>
106   : public internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type
107 {
108   public:
109
110     typedef CwiseUnaryOp<UnaryOp, XprType> Derived;
111     typedef typename internal::dense_xpr_base<CwiseUnaryOp<UnaryOp, XprType> >::type Base;
112     EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
113
114     EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const
115     {
116       return derived().functor()(derived().nestedExpression().coeff(row, col));
117     }
118
119     template<int LoadMode>
120     EIGEN_STRONG_INLINE PacketScalar packet(Index row, Index col) const
121     {
122       return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(row, col));
123     }
124
125     EIGEN_STRONG_INLINE const Scalar coeff(Index index) const
126     {
127       return derived().functor()(derived().nestedExpression().coeff(index));
128     }
129
130     template<int LoadMode>
131     EIGEN_STRONG_INLINE PacketScalar packet(Index index) const
132     {
133       return derived().functor().packetOp(derived().nestedExpression().template packet<LoadMode>(index));
134     }
135 };
136
137 #endif // EIGEN_CWISE_UNARY_OP_H