Cycles: svn merge -r41225:41232 ^/trunk/blender
[blender.git] / extern / Eigen2 / Eigen / src / Core / CwiseBinaryOp.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_BINARY_OP_H
27 #define EIGEN_CWISE_BINARY_OP_H
28
29 /** \class CwiseBinaryOp
30   *
31   * \brief Generic expression of a coefficient-wise operator between two matrices or vectors
32   *
33   * \param BinaryOp template functor implementing the operator
34   * \param Lhs the type of the left-hand side
35   * \param Rhs the type of the right-hand side
36   *
37   * This class represents an expression of a generic binary operator of two matrices or vectors.
38   * It is the return type of the operator+, operator-, and the Cwise methods, and most
39   * of the time this is the only way it is used.
40   *
41   * However, if you want to write a function returning such an expression, you
42   * will need to use this class.
43   *
44   * \sa MatrixBase::binaryExpr(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
45   */
46 template<typename BinaryOp, typename Lhs, typename Rhs>
47 struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
48 {
49   // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
50   // we still want to handle the case when the result type is different.
51   typedef typename ei_result_of<
52                      BinaryOp(
53                        typename Lhs::Scalar,
54                        typename Rhs::Scalar
55                      )
56                    >::type Scalar;
57   typedef typename Lhs::Nested LhsNested;
58   typedef typename Rhs::Nested RhsNested;
59   typedef typename ei_unref<LhsNested>::type _LhsNested;
60   typedef typename ei_unref<RhsNested>::type _RhsNested;
61   enum {
62     LhsCoeffReadCost = _LhsNested::CoeffReadCost,
63     RhsCoeffReadCost = _RhsNested::CoeffReadCost,
64     LhsFlags = _LhsNested::Flags,
65     RhsFlags = _RhsNested::Flags,
66     RowsAtCompileTime = Lhs::RowsAtCompileTime,
67     ColsAtCompileTime = Lhs::ColsAtCompileTime,
68     MaxRowsAtCompileTime = Lhs::MaxRowsAtCompileTime,
69     MaxColsAtCompileTime = Lhs::MaxColsAtCompileTime,
70     Flags = (int(LhsFlags) | int(RhsFlags)) & (
71         HereditaryBits
72       | (int(LhsFlags) & int(RhsFlags) & (LinearAccessBit | AlignedBit))
73       | (ei_functor_traits<BinaryOp>::PacketAccess && ((int(LhsFlags) & RowMajorBit)==(int(RhsFlags) & RowMajorBit))
74         ? (int(LhsFlags) & int(RhsFlags) & PacketAccessBit) : 0)),
75     CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + ei_functor_traits<BinaryOp>::Cost
76   };
77 };
78
79 template<typename BinaryOp, typename Lhs, typename Rhs>
80 class CwiseBinaryOp : ei_no_assignment_operator,
81   public MatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
82 {
83   public:
84
85     EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
86     typedef typename ei_traits<CwiseBinaryOp>::LhsNested LhsNested;
87     typedef typename ei_traits<CwiseBinaryOp>::RhsNested RhsNested;
88
89     EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& lhs, const Rhs& rhs, const BinaryOp& func = BinaryOp())
90       : m_lhs(lhs), m_rhs(rhs), m_functor(func)
91     {
92       // we require Lhs and Rhs to have the same scalar type. Currently there is no example of a binary functor
93       // that would take two operands of different types. If there were such an example, then this check should be
94       // moved to the BinaryOp functors, on a per-case basis. This would however require a change in the BinaryOp functors, as
95       // currently they take only one typename Scalar template parameter.
96       // It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
97       // So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
98       // add together a float matrix and a double matrix.
99       EIGEN_STATIC_ASSERT((ei_functor_allows_mixing_real_and_complex<BinaryOp>::ret
100                            ? int(ei_is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::ret)
101                            : int(ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret)),
102         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
103       // require the sizes to match
104       EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
105       ei_assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols());
106     }
107
108     EIGEN_STRONG_INLINE int rows() const { return m_lhs.rows(); }
109     EIGEN_STRONG_INLINE int cols() const { return m_lhs.cols(); }
110
111     EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const
112     {
113       return m_functor(m_lhs.coeff(row, col), m_rhs.coeff(row, col));
114     }
115
116     template<int LoadMode>
117     EIGEN_STRONG_INLINE PacketScalar packet(int row, int col) const
118     {
119       return m_functor.packetOp(m_lhs.template packet<LoadMode>(row, col), m_rhs.template packet<LoadMode>(row, col));
120     }
121
122     EIGEN_STRONG_INLINE const Scalar coeff(int index) const
123     {
124       return m_functor(m_lhs.coeff(index), m_rhs.coeff(index));
125     }
126
127     template<int LoadMode>
128     EIGEN_STRONG_INLINE PacketScalar packet(int index) const
129     {
130       return m_functor.packetOp(m_lhs.template packet<LoadMode>(index), m_rhs.template packet<LoadMode>(index));
131     }
132
133   protected:
134     const LhsNested m_lhs;
135     const RhsNested m_rhs;
136     const BinaryOp m_functor;
137 };
138
139 /**\returns an expression of the difference of \c *this and \a other
140   *
141   * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-().
142   *
143   * \sa class CwiseBinaryOp, MatrixBase::operator-=(), Cwise::operator-()
144   */
145 template<typename Derived>
146 template<typename OtherDerived>
147 EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_difference_op<typename ei_traits<Derived>::Scalar>,
148                                  Derived, OtherDerived>
149 MatrixBase<Derived>::operator-(const MatrixBase<OtherDerived> &other) const
150 {
151   return CwiseBinaryOp<ei_scalar_difference_op<Scalar>,
152                        Derived, OtherDerived>(derived(), other.derived());
153 }
154
155 /** replaces \c *this by \c *this - \a other.
156   *
157   * \returns a reference to \c *this
158   */
159 template<typename Derived>
160 template<typename OtherDerived>
161 EIGEN_STRONG_INLINE Derived &
162 MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
163 {
164   return *this = *this - other;
165 }
166
167 /** \relates MatrixBase
168   *
169   * \returns an expression of the sum of \c *this and \a other
170   *
171   * \note If you want to add a given scalar to all coefficients, see Cwise::operator+().
172   *
173   * \sa class CwiseBinaryOp, MatrixBase::operator+=(), Cwise::operator+()
174   */
175 template<typename Derived>
176 template<typename OtherDerived>
177 EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived>
178 MatrixBase<Derived>::operator+(const MatrixBase<OtherDerived> &other) const
179 {
180   return CwiseBinaryOp<ei_scalar_sum_op<Scalar>, Derived, OtherDerived>(derived(), other.derived());
181 }
182
183 /** replaces \c *this by \c *this + \a other.
184   *
185   * \returns a reference to \c *this
186   */
187 template<typename Derived>
188 template<typename OtherDerived>
189 EIGEN_STRONG_INLINE Derived &
190 MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
191 {
192   return *this = *this + other;
193 }
194
195 /** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
196   *
197   * Example: \include Cwise_product.cpp
198   * Output: \verbinclude Cwise_product.out
199   *
200   * \sa class CwiseBinaryOp, operator/(), square()
201   */
202 template<typename ExpressionType>
203 template<typename OtherDerived>
204 EIGEN_STRONG_INLINE const EIGEN_CWISE_PRODUCT_RETURN_TYPE
205 Cwise<ExpressionType>::operator*(const MatrixBase<OtherDerived> &other) const
206 {
207   return EIGEN_CWISE_PRODUCT_RETURN_TYPE(_expression(), other.derived());
208 }
209
210 /** \returns an expression of the coefficient-wise quotient of *this and \a other
211   *
212   * Example: \include Cwise_quotient.cpp
213   * Output: \verbinclude Cwise_quotient.out
214   *
215   * \sa class CwiseBinaryOp, operator*(), inverse()
216   */
217 template<typename ExpressionType>
218 template<typename OtherDerived>
219 EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)
220 Cwise<ExpressionType>::operator/(const MatrixBase<OtherDerived> &other) const
221 {
222   return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)(_expression(), other.derived());
223 }
224
225 /** Replaces this expression by its coefficient-wise product with \a other.
226   *
227   * Example: \include Cwise_times_equal.cpp
228   * Output: \verbinclude Cwise_times_equal.out
229   *
230   * \sa operator*(), operator/=()
231   */
232 template<typename ExpressionType>
233 template<typename OtherDerived>
234 inline ExpressionType& Cwise<ExpressionType>::operator*=(const MatrixBase<OtherDerived> &other)
235 {
236   return m_matrix.const_cast_derived() = *this * other;
237 }
238
239 /** Replaces this expression by its coefficient-wise quotient by \a other.
240   *
241   * Example: \include Cwise_slash_equal.cpp
242   * Output: \verbinclude Cwise_slash_equal.out
243   *
244   * \sa operator/(), operator*=()
245   */
246 template<typename ExpressionType>
247 template<typename OtherDerived>
248 inline ExpressionType& Cwise<ExpressionType>::operator/=(const MatrixBase<OtherDerived> &other)
249 {
250   return m_matrix.const_cast_derived() = *this / other;
251 }
252
253 /** \returns an expression of the coefficient-wise min of *this and \a other
254   *
255   * Example: \include Cwise_min.cpp
256   * Output: \verbinclude Cwise_min.out
257   *
258   * \sa class CwiseBinaryOp
259   */
260 template<typename ExpressionType>
261 template<typename OtherDerived>
262 EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)
263 Cwise<ExpressionType>::min(const MatrixBase<OtherDerived> &other) const
264 {
265   return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)(_expression(), other.derived());
266 }
267
268 /** \returns an expression of the coefficient-wise max of *this and \a other
269   *
270   * Example: \include Cwise_max.cpp
271   * Output: \verbinclude Cwise_max.out
272   *
273   * \sa class CwiseBinaryOp
274   */
275 template<typename ExpressionType>
276 template<typename OtherDerived>
277 EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)
278 Cwise<ExpressionType>::max(const MatrixBase<OtherDerived> &other) const
279 {
280   return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)(_expression(), other.derived());
281 }
282
283 /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
284   *
285   * The template parameter \a CustomBinaryOp is the type of the functor
286   * of the custom operator (see class CwiseBinaryOp for an example)
287   *
288   * \addexample CustomCwiseBinaryFunctors \label How to use custom coeff wise binary functors
289   *
290   * Here is an example illustrating the use of custom functors:
291   * \include class_CwiseBinaryOp.cpp
292   * Output: \verbinclude class_CwiseBinaryOp.out
293   *
294   * \sa class CwiseBinaryOp, MatrixBase::operator+, MatrixBase::operator-, Cwise::operator*, Cwise::operator/
295   */
296 template<typename Derived>
297 template<typename CustomBinaryOp, typename OtherDerived>
298 EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, Derived, OtherDerived>
299 MatrixBase<Derived>::binaryExpr(const MatrixBase<OtherDerived> &other, const CustomBinaryOp& func) const
300 {
301   return CwiseBinaryOp<CustomBinaryOp, Derived, OtherDerived>(derived(), other.derived(), func);
302 }
303
304 #endif // EIGEN_CWISE_BINARY_OP_H