Cycles: svn merge -r41225:41232 ^/trunk/blender
[blender.git] / extern / Eigen2 / Eigen / src / Array / PartialRedux.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_PARTIAL_REDUX_H
27 #define EIGEN_PARTIAL_REDUX_H
28
29 /** \array_module \ingroup Array
30   *
31   * \class PartialReduxExpr
32   *
33   * \brief Generic expression of a partially reduxed matrix
34   *
35   * \param MatrixType the type of the matrix we are applying the redux operation
36   * \param MemberOp type of the member functor
37   * \param Direction indicates the direction of the redux (Vertical or Horizontal)
38   *
39   * This class represents an expression of a partial redux operator of a matrix.
40   * It is the return type of PartialRedux functions,
41   * and most of the time this is the only way it is used.
42   *
43   * \sa class PartialRedux
44   */
45
46 template< typename MatrixType, typename MemberOp, int Direction>
47 class PartialReduxExpr;
48
49 template<typename MatrixType, typename MemberOp, int Direction>
50 struct ei_traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
51 {
52   typedef typename MemberOp::result_type Scalar;
53   typedef typename MatrixType::Scalar InputScalar;
54   typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
55   typedef typename ei_cleantype<MatrixTypeNested>::type _MatrixTypeNested;
56   enum {
57     RowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::RowsAtCompileTime,
58     ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime,
59     MaxRowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::MaxRowsAtCompileTime,
60     MaxColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::MaxColsAtCompileTime,
61     Flags = (unsigned int)_MatrixTypeNested::Flags & HereditaryBits,
62     TraversalSize = Direction==Vertical ? RowsAtCompileTime : ColsAtCompileTime
63   };
64   #if EIGEN_GNUC_AT_LEAST(3,4)
65   typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
66   #else
67   typedef typename MemberOp::template Cost<InputScalar,TraversalSize> CostOpType;
68   #endif
69   enum {
70     CoeffReadCost = TraversalSize * ei_traits<_MatrixTypeNested>::CoeffReadCost + int(CostOpType::value)
71   };
72 };
73
74 template< typename MatrixType, typename MemberOp, int Direction>
75 class PartialReduxExpr : ei_no_assignment_operator,
76   public MatrixBase<PartialReduxExpr<MatrixType, MemberOp, Direction> >
77 {
78   public:
79
80     EIGEN_GENERIC_PUBLIC_INTERFACE(PartialReduxExpr)
81     typedef typename ei_traits<PartialReduxExpr>::MatrixTypeNested MatrixTypeNested;
82     typedef typename ei_traits<PartialReduxExpr>::_MatrixTypeNested _MatrixTypeNested;
83
84     PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp())
85       : m_matrix(mat), m_functor(func) {}
86
87     int rows() const { return (Direction==Vertical   ? 1 : m_matrix.rows()); }
88     int cols() const { return (Direction==Horizontal ? 1 : m_matrix.cols()); }
89
90     const Scalar coeff(int i, int j) const
91     {
92       if (Direction==Vertical)
93         return m_functor(m_matrix.col(j));
94       else
95         return m_functor(m_matrix.row(i));
96     }
97
98   protected:
99     const MatrixTypeNested m_matrix;
100     const MemberOp m_functor;
101 };
102
103 #define EIGEN_MEMBER_FUNCTOR(MEMBER,COST)                           \
104   template <typename ResultType>                                    \
105   struct ei_member_##MEMBER EIGEN_EMPTY_STRUCT {                    \
106     typedef ResultType result_type;                                 \
107     template<typename Scalar, int Size> struct Cost                 \
108     { enum { value = COST }; };                                     \
109     template<typename Derived>                                      \
110     inline ResultType operator()(const MatrixBase<Derived>& mat) const     \
111     { return mat.MEMBER(); } \
112   }
113
114 EIGEN_MEMBER_FUNCTOR(squaredNorm, Size * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
115 EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
116 EIGEN_MEMBER_FUNCTOR(sum, (Size-1)*NumTraits<Scalar>::AddCost);
117 EIGEN_MEMBER_FUNCTOR(minCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
118 EIGEN_MEMBER_FUNCTOR(maxCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
119 EIGEN_MEMBER_FUNCTOR(all, (Size-1)*NumTraits<Scalar>::AddCost);
120 EIGEN_MEMBER_FUNCTOR(any, (Size-1)*NumTraits<Scalar>::AddCost);
121 EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits<Scalar>::AddCost);
122
123 /** \internal */
124 template <typename BinaryOp, typename Scalar>
125 struct ei_member_redux {
126   typedef typename ei_result_of<
127                      BinaryOp(Scalar)
128                    >::type  result_type;
129   template<typename _Scalar, int Size> struct Cost
130   { enum { value = (Size-1) * ei_functor_traits<BinaryOp>::Cost }; };
131   ei_member_redux(const BinaryOp func) : m_functor(func) {}
132   template<typename Derived>
133   inline result_type operator()(const MatrixBase<Derived>& mat) const
134   { return mat.redux(m_functor); }
135   const BinaryOp m_functor;
136 private:
137   ei_member_redux& operator=(const ei_member_redux&);
138 };
139
140 /** \array_module \ingroup Array
141   *
142   * \class PartialRedux
143   *
144   * \brief Pseudo expression providing partial reduction operations
145   *
146   * \param ExpressionType the type of the object on which to do partial reductions
147   * \param Direction indicates the direction of the redux (Vertical or Horizontal)
148   *
149   * This class represents a pseudo expression with partial reduction features.
150   * It is the return type of MatrixBase::colwise() and MatrixBase::rowwise()
151   * and most of the time this is the only way it is used.
152   *
153   * Example: \include MatrixBase_colwise.cpp
154   * Output: \verbinclude MatrixBase_colwise.out
155   *
156   * \sa MatrixBase::colwise(), MatrixBase::rowwise(), class PartialReduxExpr
157   */
158 template<typename ExpressionType, int Direction> class PartialRedux
159 {
160   public:
161
162     typedef typename ei_traits<ExpressionType>::Scalar Scalar;
163     typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret,
164         ExpressionType, const ExpressionType&>::ret ExpressionTypeNested;
165
166     template<template<typename _Scalar> class Functor> struct ReturnType
167     {
168       typedef PartialReduxExpr<ExpressionType,
169                                Functor<typename ei_traits<ExpressionType>::Scalar>,
170                                Direction
171                               > Type;
172     };
173
174     template<typename BinaryOp> struct ReduxReturnType
175     {
176       typedef PartialReduxExpr<ExpressionType,
177                                ei_member_redux<BinaryOp,typename ei_traits<ExpressionType>::Scalar>,
178                                Direction
179                               > Type;
180     };
181
182     typedef typename ExpressionType::PlainMatrixType CrossReturnType;
183     
184     inline PartialRedux(const ExpressionType& matrix) : m_matrix(matrix) {}
185
186     /** \internal */
187     inline const ExpressionType& _expression() const { return m_matrix; }
188
189     template<typename BinaryOp>
190     const typename ReduxReturnType<BinaryOp>::Type
191     redux(const BinaryOp& func = BinaryOp()) const;
192
193     /** \returns a row (or column) vector expression of the smallest coefficient
194       * of each column (or row) of the referenced expression.
195       *
196       * Example: \include PartialRedux_minCoeff.cpp
197       * Output: \verbinclude PartialRedux_minCoeff.out
198       *
199       * \sa MatrixBase::minCoeff() */
200     const typename ReturnType<ei_member_minCoeff>::Type minCoeff() const
201     { return _expression(); }
202
203     /** \returns a row (or column) vector expression of the largest coefficient
204       * of each column (or row) of the referenced expression.
205       *
206       * Example: \include PartialRedux_maxCoeff.cpp
207       * Output: \verbinclude PartialRedux_maxCoeff.out
208       *
209       * \sa MatrixBase::maxCoeff() */
210     const typename ReturnType<ei_member_maxCoeff>::Type maxCoeff() const
211     { return _expression(); }
212
213     /** \returns a row (or column) vector expression of the squared norm
214       * of each column (or row) of the referenced expression.
215       *
216       * Example: \include PartialRedux_squaredNorm.cpp
217       * Output: \verbinclude PartialRedux_squaredNorm.out
218       *
219       * \sa MatrixBase::squaredNorm() */
220     const typename ReturnType<ei_member_squaredNorm>::Type squaredNorm() const
221     { return _expression(); }
222
223     /** \returns a row (or column) vector expression of the norm
224       * of each column (or row) of the referenced expression.
225       *
226       * Example: \include PartialRedux_norm.cpp
227       * Output: \verbinclude PartialRedux_norm.out
228       *
229       * \sa MatrixBase::norm() */
230     const typename ReturnType<ei_member_norm>::Type norm() const
231     { return _expression(); }
232
233     /** \returns a row (or column) vector expression of the sum
234       * of each column (or row) of the referenced expression.
235       *
236       * Example: \include PartialRedux_sum.cpp
237       * Output: \verbinclude PartialRedux_sum.out
238       *
239       * \sa MatrixBase::sum() */
240     const typename ReturnType<ei_member_sum>::Type sum() const
241     { return _expression(); }
242
243     /** \returns a row (or column) vector expression representing
244       * whether \b all coefficients of each respective column (or row) are \c true.
245       *
246       * \sa MatrixBase::all() */
247     const typename ReturnType<ei_member_all>::Type all() const
248     { return _expression(); }
249
250     /** \returns a row (or column) vector expression representing
251       * whether \b at \b least one coefficient of each respective column (or row) is \c true.
252       *
253       * \sa MatrixBase::any() */
254     const typename ReturnType<ei_member_any>::Type any() const
255     { return _expression(); }
256     
257     /** \returns a row (or column) vector expression representing
258       * the number of \c true coefficients of each respective column (or row).
259       *
260       * Example: \include PartialRedux_count.cpp
261       * Output: \verbinclude PartialRedux_count.out
262       *
263       * \sa MatrixBase::count() */
264     const PartialReduxExpr<ExpressionType, ei_member_count<int>, Direction> count() const
265     { return _expression(); }
266
267     /** \returns a 3x3 matrix expression of the cross product
268       * of each column or row of the referenced expression with the \a other vector.
269       *
270       * \geometry_module
271       *
272       * \sa MatrixBase::cross() */
273     template<typename OtherDerived>
274     const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const
275     {
276       EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(CrossReturnType,3,3)
277       EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
278       EIGEN_STATIC_ASSERT((ei_is_same_type<Scalar, typename OtherDerived::Scalar>::ret),
279         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
280
281       if(Direction==Vertical)
282         return (CrossReturnType()
283                                  << _expression().col(0).cross(other),
284                                     _expression().col(1).cross(other),
285                                     _expression().col(2).cross(other)).finished();
286       else
287         return (CrossReturnType() 
288                                  << _expression().row(0).cross(other),
289                                     _expression().row(1).cross(other),
290                                     _expression().row(2).cross(other)).finished();
291     }
292
293   protected:
294     ExpressionTypeNested m_matrix;
295
296   private:
297     PartialRedux& operator=(const PartialRedux&);
298 };
299
300 /** \array_module
301   *
302   * \returns a PartialRedux wrapper of *this providing additional partial reduction operations
303   *
304   * Example: \include MatrixBase_colwise.cpp
305   * Output: \verbinclude MatrixBase_colwise.out
306   *
307   * \sa rowwise(), class PartialRedux
308   */
309 template<typename Derived>
310 inline const PartialRedux<Derived,Vertical>
311 MatrixBase<Derived>::colwise() const
312 {
313   return derived();
314 }
315
316 /** \array_module
317   *
318   * \returns a PartialRedux wrapper of *this providing additional partial reduction operations
319   *
320   * Example: \include MatrixBase_rowwise.cpp
321   * Output: \verbinclude MatrixBase_rowwise.out
322   *
323   * \sa colwise(), class PartialRedux
324   */
325 template<typename Derived>
326 inline const PartialRedux<Derived,Horizontal>
327 MatrixBase<Derived>::rowwise() const
328 {
329   return derived();
330 }
331
332 /** \returns a row or column vector expression of \c *this reduxed by \a func
333   *
334   * The template parameter \a BinaryOp is the type of the functor
335   * of the custom redux operator. Note that func must be an associative operator.
336   *
337   * \sa class PartialRedux, MatrixBase::colwise(), MatrixBase::rowwise()
338   */
339 template<typename ExpressionType, int Direction>
340 template<typename BinaryOp>
341 const typename PartialRedux<ExpressionType,Direction>::template ReduxReturnType<BinaryOp>::Type
342 PartialRedux<ExpressionType,Direction>::redux(const BinaryOp& func) const
343 {
344   return typename ReduxReturnType<BinaryOp>::Type(_expression(), func);
345 }
346
347 #endif // EIGEN_PARTIAL_REDUX_H