Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / CwiseUnaryOp.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra. Eigen itself is part of the KDE project.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <g.gael@free.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   *
31   * \brief Generic expression of a coefficient-wise unary operator of a matrix or a vector
32   *
33   * \param UnaryOp template functor implementing the operator
34   * \param MatrixType the type of the matrix we are applying the unary operator
35   *
36   * This class represents an expression of a generic unary operator of a matrix or a vector.
37   * It is the return type of the unary operator-, of a matrix or a vector, and most
38   * of the time this is the only way it is used.
39   *
40   * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
41   */
42 template<typename UnaryOp, typename MatrixType>
43 struct ei_traits<CwiseUnaryOp<UnaryOp, MatrixType> >
44  : ei_traits<MatrixType>
45 {
46   typedef typename ei_result_of<
47                      UnaryOp(typename MatrixType::Scalar)
48                    >::type Scalar;
49   typedef typename MatrixType::Nested MatrixTypeNested;
50   typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
51   enum {
52     Flags = (_MatrixTypeNested::Flags & (
53       HereditaryBits | LinearAccessBit | AlignedBit
54       | (ei_functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0))),
55     CoeffReadCost = _MatrixTypeNested::CoeffReadCost + ei_functor_traits<UnaryOp>::Cost
56   };
57 };
58
59 template<typename UnaryOp, typename MatrixType>
60 class CwiseUnaryOp : ei_no_assignment_operator,
61   public MatrixBase<CwiseUnaryOp<UnaryOp, MatrixType> >
62 {
63   public:
64
65     EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
66
67     inline CwiseUnaryOp(const MatrixType& mat, const UnaryOp& func = UnaryOp())
68       : m_matrix(mat), m_functor(func) {}
69
70     EIGEN_STRONG_INLINE int rows() const { return m_matrix.rows(); }
71     EIGEN_STRONG_INLINE int cols() const { return m_matrix.cols(); }
72
73     EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const
74     {
75       return m_functor(m_matrix.coeff(row, col));
76     }
77
78     template<int LoadMode>
79     EIGEN_STRONG_INLINE PacketScalar packet(int row, int col) const
80     {
81       return m_functor.packetOp(m_matrix.template packet<LoadMode>(row, col));
82     }
83
84     EIGEN_STRONG_INLINE const Scalar coeff(int index) const
85     {
86       return m_functor(m_matrix.coeff(index));
87     }
88
89     template<int LoadMode>
90     EIGEN_STRONG_INLINE PacketScalar packet(int index) const
91     {
92       return m_functor.packetOp(m_matrix.template packet<LoadMode>(index));
93     }
94
95   protected:
96     const typename MatrixType::Nested m_matrix;
97     const UnaryOp m_functor;
98 };
99
100 /** \returns an expression of a custom coefficient-wise unary operator \a func of *this
101   *
102   * The template parameter \a CustomUnaryOp is the type of the functor
103   * of the custom unary operator.
104   *
105   * \addexample CustomCwiseUnaryFunctors \label How to use custom coeff wise unary functors
106   *
107   * Example:
108   * \include class_CwiseUnaryOp.cpp
109   * Output: \verbinclude class_CwiseUnaryOp.out
110   *
111   * \sa class CwiseUnaryOp, class CwiseBinarOp, MatrixBase::operator-, Cwise::abs
112   */
113 template<typename Derived>
114 template<typename CustomUnaryOp>
115 EIGEN_STRONG_INLINE const CwiseUnaryOp<CustomUnaryOp, Derived>
116 MatrixBase<Derived>::unaryExpr(const CustomUnaryOp& func) const
117 {
118   return CwiseUnaryOp<CustomUnaryOp, Derived>(derived(), func);
119 }
120
121 /** \returns an expression of the opposite of \c *this
122   */
123 template<typename Derived>
124 EIGEN_STRONG_INLINE const CwiseUnaryOp<ei_scalar_opposite_op<typename ei_traits<Derived>::Scalar>,Derived>
125 MatrixBase<Derived>::operator-() const
126 {
127   return derived();
128 }
129
130 /** \returns an expression of the coefficient-wise absolute value of \c *this
131   *
132   * Example: \include Cwise_abs.cpp
133   * Output: \verbinclude Cwise_abs.out
134   *
135   * \sa abs2()
136   */
137 template<typename ExpressionType>
138 EIGEN_STRONG_INLINE const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs_op)
139 Cwise<ExpressionType>::abs() const
140 {
141   return _expression();
142 }
143
144 /** \returns an expression of the coefficient-wise squared absolute value of \c *this
145   *
146   * Example: \include Cwise_abs2.cpp
147   * Output: \verbinclude Cwise_abs2.out
148   *
149   * \sa abs(), square()
150   */
151 template<typename ExpressionType>
152 EIGEN_STRONG_INLINE const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs2_op)
153 Cwise<ExpressionType>::abs2() const
154 {
155   return _expression();
156 }
157
158 /** \returns an expression of the complex conjugate of \c *this.
159   *
160   * \sa adjoint() */
161 template<typename Derived>
162 EIGEN_STRONG_INLINE typename MatrixBase<Derived>::ConjugateReturnType
163 MatrixBase<Derived>::conjugate() const
164 {
165   return ConjugateReturnType(derived());
166 }
167
168 /** \returns an expression of the real part of \c *this.
169   *
170   * \sa imag() */
171 template<typename Derived>
172 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::RealReturnType
173 MatrixBase<Derived>::real() const { return derived(); }
174
175 /** \returns an expression of the imaginary part of \c *this.
176   *
177   * \sa real() */
178 template<typename Derived>
179 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ImagReturnType
180 MatrixBase<Derived>::imag() const { return derived(); }
181
182 /** \returns an expression of *this with the \a Scalar type casted to
183   * \a NewScalar.
184   *
185   * The template parameter \a NewScalar is the type we are casting the scalars to.
186   *
187   * \sa class CwiseUnaryOp
188   */
189 template<typename Derived>
190 template<typename NewType>
191 EIGEN_STRONG_INLINE const CwiseUnaryOp<ei_scalar_cast_op<typename ei_traits<Derived>::Scalar, NewType>, Derived>
192 MatrixBase<Derived>::cast() const
193 {
194   return derived();
195 }
196
197 /** \relates MatrixBase */
198 template<typename Derived>
199 EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ScalarMultipleReturnType
200 MatrixBase<Derived>::operator*(const Scalar& scalar) const
201 {
202   return CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived>
203     (derived(), ei_scalar_multiple_op<Scalar>(scalar));
204 }
205
206 /** \relates MatrixBase */
207 template<typename Derived>
208 EIGEN_STRONG_INLINE const CwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<Derived>::Scalar>, Derived>
209 MatrixBase<Derived>::operator/(const Scalar& scalar) const
210 {
211   return CwiseUnaryOp<ei_scalar_quotient1_op<Scalar>, Derived>
212     (derived(), ei_scalar_quotient1_op<Scalar>(scalar));
213 }
214
215 template<typename Derived>
216 EIGEN_STRONG_INLINE Derived&
217 MatrixBase<Derived>::operator*=(const Scalar& other)
218 {
219   return *this = *this * other;
220 }
221
222 template<typename Derived>
223 EIGEN_STRONG_INLINE Derived&
224 MatrixBase<Derived>::operator/=(const Scalar& other)
225 {
226   return *this = *this / other;
227 }
228
229 #endif // EIGEN_CWISE_UNARY_OP_H