Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
[blender.git] / extern / Eigen2 / Eigen / src / Core / Product.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) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
5 // Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
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_PRODUCT_H
27 #define EIGEN_PRODUCT_H
28
29 /***************************
30 *** Forward declarations ***
31 ***************************/
32
33 template<int VectorizationMode, int Index, typename Lhs, typename Rhs, typename RetScalar>
34 struct ei_product_coeff_impl;
35
36 template<int StorageOrder, int Index, typename Lhs, typename Rhs, typename PacketScalar, int LoadMode>
37 struct ei_product_packet_impl;
38
39 /** \class ProductReturnType
40   *
41   * \brief Helper class to get the correct and optimized returned type of operator*
42   *
43   * \param Lhs the type of the left-hand side
44   * \param Rhs the type of the right-hand side
45   * \param ProductMode the type of the product (determined automatically by ei_product_mode)
46   *
47   * This class defines the typename Type representing the optimized product expression
48   * between two matrix expressions. In practice, using ProductReturnType<Lhs,Rhs>::Type
49   * is the recommended way to define the result type of a function returning an expression
50   * which involve a matrix product. The class Product or DiagonalProduct should never be
51   * used directly.
52   *
53   * \sa class Product, class DiagonalProduct, MatrixBase::operator*(const MatrixBase<OtherDerived>&)
54   */
55 template<typename Lhs, typename Rhs, int ProductMode>
56 struct ProductReturnType
57 {
58   typedef typename ei_nested<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
59   typedef typename ei_nested<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
60
61   typedef Product<LhsNested, RhsNested, ProductMode> Type;
62 };
63
64 // cache friendly specialization
65 // note that there is a DiagonalProduct specialization in DiagonalProduct.h
66 template<typename Lhs, typename Rhs>
67 struct ProductReturnType<Lhs,Rhs,CacheFriendlyProduct>
68 {
69   typedef typename ei_nested<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
70
71   typedef typename ei_nested<Rhs,Lhs::RowsAtCompileTime,
72                              typename ei_plain_matrix_type_column_major<Rhs>::type
73                    >::type RhsNested;
74
75   typedef Product<LhsNested, RhsNested, CacheFriendlyProduct> Type;
76 };
77
78 /*  Helper class to determine the type of the product, can be either:
79  *    - NormalProduct
80  *    - CacheFriendlyProduct
81  *    - DiagonalProduct
82  */
83 template<typename Lhs, typename Rhs> struct ei_product_mode
84 {
85   enum{
86
87     value = ((Rhs::Flags&Diagonal)==Diagonal) || ((Lhs::Flags&Diagonal)==Diagonal)
88           ? DiagonalProduct
89           : Lhs::MaxColsAtCompileTime == Dynamic
90             && ( Lhs::MaxRowsAtCompileTime == Dynamic
91               || Rhs::MaxColsAtCompileTime == Dynamic )
92             && (!(Rhs::IsVectorAtCompileTime && (Lhs::Flags&RowMajorBit)  && (!(Lhs::Flags&DirectAccessBit))))
93             && (!(Lhs::IsVectorAtCompileTime && (!(Rhs::Flags&RowMajorBit)) && (!(Rhs::Flags&DirectAccessBit))))
94             && (ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret)
95           ? CacheFriendlyProduct
96           : NormalProduct };
97 };
98
99 /** \class Product
100   *
101   * \brief Expression of the product of two matrices
102   *
103   * \param LhsNested the type used to store the left-hand side
104   * \param RhsNested the type used to store the right-hand side
105   * \param ProductMode the type of the product
106   *
107   * This class represents an expression of the product of two matrices.
108   * It is the return type of the operator* between matrices. Its template
109   * arguments are determined automatically by ProductReturnType. Therefore,
110   * Product should never be used direclty. To determine the result type of a
111   * function which involves a matrix product, use ProductReturnType::Type.
112   *
113   * \sa ProductReturnType, MatrixBase::operator*(const MatrixBase<OtherDerived>&)
114   */
115 template<typename LhsNested, typename RhsNested, int ProductMode>
116 struct ei_traits<Product<LhsNested, RhsNested, ProductMode> >
117 {
118   // clean the nested types:
119   typedef typename ei_cleantype<LhsNested>::type _LhsNested;
120   typedef typename ei_cleantype<RhsNested>::type _RhsNested;
121   typedef typename ei_scalar_product_traits<typename _LhsNested::Scalar, typename _RhsNested::Scalar>::ReturnType Scalar;
122
123   enum {
124     LhsCoeffReadCost = _LhsNested::CoeffReadCost,
125     RhsCoeffReadCost = _RhsNested::CoeffReadCost,
126     LhsFlags = _LhsNested::Flags,
127     RhsFlags = _RhsNested::Flags,
128
129     RowsAtCompileTime = _LhsNested::RowsAtCompileTime,
130     ColsAtCompileTime = _RhsNested::ColsAtCompileTime,
131     InnerSize = EIGEN_ENUM_MIN(_LhsNested::ColsAtCompileTime, _RhsNested::RowsAtCompileTime),
132
133     MaxRowsAtCompileTime = _LhsNested::MaxRowsAtCompileTime,
134     MaxColsAtCompileTime = _RhsNested::MaxColsAtCompileTime,
135
136     LhsRowMajor = LhsFlags & RowMajorBit,
137     RhsRowMajor = RhsFlags & RowMajorBit,
138
139     CanVectorizeRhs = RhsRowMajor && (RhsFlags & PacketAccessBit)
140                     && (ColsAtCompileTime % ei_packet_traits<Scalar>::size == 0),
141
142     CanVectorizeLhs = (!LhsRowMajor) && (LhsFlags & PacketAccessBit)
143                     && (RowsAtCompileTime % ei_packet_traits<Scalar>::size == 0),
144
145     EvalToRowMajor = RhsRowMajor && (ProductMode==(int)CacheFriendlyProduct ? LhsRowMajor : (!CanVectorizeLhs)),
146
147     RemovedBits = ~(EvalToRowMajor ? 0 : RowMajorBit),
148
149     Flags = ((unsigned int)(LhsFlags | RhsFlags) & HereditaryBits & RemovedBits)
150           | EvalBeforeAssigningBit
151           | EvalBeforeNestingBit
152           | (CanVectorizeLhs || CanVectorizeRhs ? PacketAccessBit : 0)
153           | (LhsFlags & RhsFlags & AlignedBit),
154
155     CoeffReadCost = InnerSize == Dynamic ? Dynamic
156                   : InnerSize * (NumTraits<Scalar>::MulCost + LhsCoeffReadCost + RhsCoeffReadCost)
157                     + (InnerSize - 1) * NumTraits<Scalar>::AddCost,
158
159     /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside
160      * of Product. If the Product itself is not a packet-access expression, there is still a chance that the inner
161      * loop of the product might be vectorized. This is the meaning of CanVectorizeInner. Since it doesn't affect
162      * the Flags, it is safe to make this value depend on ActualPacketAccessBit, that doesn't affect the ABI.
163      */
164     CanVectorizeInner = LhsRowMajor && (!RhsRowMajor) && (LhsFlags & RhsFlags & ActualPacketAccessBit)
165                       && (InnerSize % ei_packet_traits<Scalar>::size == 0)
166   };
167 };
168
169 template<typename LhsNested, typename RhsNested, int ProductMode> class Product : ei_no_assignment_operator,
170   public MatrixBase<Product<LhsNested, RhsNested, ProductMode> >
171 {
172   public:
173
174     EIGEN_GENERIC_PUBLIC_INTERFACE(Product)
175
176   private:
177
178     typedef typename ei_traits<Product>::_LhsNested _LhsNested;
179     typedef typename ei_traits<Product>::_RhsNested _RhsNested;
180
181     enum {
182       PacketSize = ei_packet_traits<Scalar>::size,
183       InnerSize  = ei_traits<Product>::InnerSize,
184       Unroll = CoeffReadCost <= EIGEN_UNROLLING_LIMIT,
185       CanVectorizeInner = ei_traits<Product>::CanVectorizeInner
186     };
187
188     typedef ei_product_coeff_impl<CanVectorizeInner ? InnerVectorization : NoVectorization,
189                                   Unroll ? InnerSize-1 : Dynamic,
190                                   _LhsNested, _RhsNested, Scalar> ScalarCoeffImpl;
191
192   public:
193
194     template<typename Lhs, typename Rhs>
195     inline Product(const Lhs& lhs, const Rhs& rhs)
196       : m_lhs(lhs), m_rhs(rhs)
197     {
198       // we don't allow taking products of matrices of different real types, as that wouldn't be vectorizable.
199       // We still allow to mix T and complex<T>.
200       EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::ret),
201         YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
202       ei_assert(lhs.cols() == rhs.rows()
203         && "invalid matrix product"
204         && "if you wanted a coeff-wise or a dot product use the respective explicit functions");
205     }
206
207     /** \internal
208       * compute \a res += \c *this using the cache friendly product.
209       */
210     template<typename DestDerived>
211     void _cacheFriendlyEvalAndAdd(DestDerived& res) const;
212
213     /** \internal
214       * \returns whether it is worth it to use the cache friendly product.
215       */
216     EIGEN_STRONG_INLINE bool _useCacheFriendlyProduct() const
217     {
218       return  m_lhs.cols()>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
219               && (  rows()>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
220                  || cols()>=EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD);
221     }
222
223     EIGEN_STRONG_INLINE int rows() const { return m_lhs.rows(); }
224     EIGEN_STRONG_INLINE int cols() const { return m_rhs.cols(); }
225
226     EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const
227     {
228       Scalar res;
229       ScalarCoeffImpl::run(row, col, m_lhs, m_rhs, res);
230       return res;
231     }
232
233     /* Allow index-based non-packet access. It is impossible though to allow index-based packed access,
234      * which is why we don't set the LinearAccessBit.
235      */
236     EIGEN_STRONG_INLINE const Scalar coeff(int index) const
237     {
238       Scalar res;
239       const int row = RowsAtCompileTime == 1 ? 0 : index;
240       const int col = RowsAtCompileTime == 1 ? index : 0;
241       ScalarCoeffImpl::run(row, col, m_lhs, m_rhs, res);
242       return res;
243     }
244
245     template<int LoadMode>
246     EIGEN_STRONG_INLINE const PacketScalar packet(int row, int col) const
247     {
248       PacketScalar res;
249       ei_product_packet_impl<Flags&RowMajorBit ? RowMajor : ColMajor,
250                                    Unroll ? InnerSize-1 : Dynamic,
251                                    _LhsNested, _RhsNested, PacketScalar, LoadMode>
252         ::run(row, col, m_lhs, m_rhs, res);
253       return res;
254     }
255
256     EIGEN_STRONG_INLINE const _LhsNested& lhs() const { return m_lhs; }
257     EIGEN_STRONG_INLINE const _RhsNested& rhs() const { return m_rhs; }
258
259   protected:
260     const LhsNested m_lhs;
261     const RhsNested m_rhs;
262 };
263
264 /** \returns the matrix product of \c *this and \a other.
265   *
266   * \note If instead of the matrix product you want the coefficient-wise product, see Cwise::operator*().
267   *
268   * \sa lazy(), operator*=(const MatrixBase&), Cwise::operator*()
269   */
270 template<typename Derived>
271 template<typename OtherDerived>
272 inline const typename ProductReturnType<Derived,OtherDerived>::Type
273 MatrixBase<Derived>::operator*(const MatrixBase<OtherDerived> &other) const
274 {
275   enum {
276     ProductIsValid =  Derived::ColsAtCompileTime==Dynamic
277                    || OtherDerived::RowsAtCompileTime==Dynamic
278                    || int(Derived::ColsAtCompileTime)==int(OtherDerived::RowsAtCompileTime),
279     AreVectors = Derived::IsVectorAtCompileTime && OtherDerived::IsVectorAtCompileTime,
280     SameSizes = EIGEN_PREDICATE_SAME_MATRIX_SIZE(Derived,OtherDerived)
281   };
282   // note to the lost user:
283   //    * for a dot product use: v1.dot(v2)
284   //    * for a coeff-wise product use: v1.cwise()*v2
285   EIGEN_STATIC_ASSERT(ProductIsValid || !(AreVectors && SameSizes),
286     INVALID_VECTOR_VECTOR_PRODUCT__IF_YOU_WANTED_A_DOT_OR_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTIONS)
287   EIGEN_STATIC_ASSERT(ProductIsValid || !(SameSizes && !AreVectors),
288     INVALID_MATRIX_PRODUCT__IF_YOU_WANTED_A_COEFF_WISE_PRODUCT_YOU_MUST_USE_THE_EXPLICIT_FUNCTION)
289   EIGEN_STATIC_ASSERT(ProductIsValid || SameSizes, INVALID_MATRIX_PRODUCT)
290   return typename ProductReturnType<Derived,OtherDerived>::Type(derived(), other.derived());
291 }
292
293 /** replaces \c *this by \c *this * \a other.
294   *
295   * \returns a reference to \c *this
296   */
297 template<typename Derived>
298 template<typename OtherDerived>
299 inline Derived &
300 MatrixBase<Derived>::operator*=(const MatrixBase<OtherDerived> &other)
301 {
302   return derived() = derived() * other.derived();
303 }
304
305 /***************************************************************************
306 * Normal product .coeff() implementation (with meta-unrolling)
307 ***************************************************************************/
308
309 /**************************************
310 *** Scalar path  - no vectorization ***
311 **************************************/
312
313 template<int Index, typename Lhs, typename Rhs, typename RetScalar>
314 struct ei_product_coeff_impl<NoVectorization, Index, Lhs, Rhs, RetScalar>
315 {
316   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, RetScalar &res)
317   {
318     ei_product_coeff_impl<NoVectorization, Index-1, Lhs, Rhs, RetScalar>::run(row, col, lhs, rhs, res);
319     res += lhs.coeff(row, Index) * rhs.coeff(Index, col);
320   }
321 };
322
323 template<typename Lhs, typename Rhs, typename RetScalar>
324 struct ei_product_coeff_impl<NoVectorization, 0, Lhs, Rhs, RetScalar>
325 {
326   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, RetScalar &res)
327   {
328     res = lhs.coeff(row, 0) * rhs.coeff(0, col);
329   }
330 };
331
332 template<typename Lhs, typename Rhs, typename RetScalar>
333 struct ei_product_coeff_impl<NoVectorization, Dynamic, Lhs, Rhs, RetScalar>
334 {
335   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, RetScalar& res)
336   {
337     ei_assert(lhs.cols()>0 && "you are using a non initialized matrix");
338     res = lhs.coeff(row, 0) * rhs.coeff(0, col);
339       for(int i = 1; i < lhs.cols(); ++i)
340         res += lhs.coeff(row, i) * rhs.coeff(i, col);
341   }
342 };
343
344 // prevent buggy user code from causing an infinite recursion
345 template<typename Lhs, typename Rhs, typename RetScalar>
346 struct ei_product_coeff_impl<NoVectorization, -1, Lhs, Rhs, RetScalar>
347 {
348   EIGEN_STRONG_INLINE static void run(int, int, const Lhs&, const Rhs&, RetScalar&) {}
349 };
350
351 /*******************************************
352 *** Scalar path with inner vectorization ***
353 *******************************************/
354
355 template<int Index, typename Lhs, typename Rhs, typename PacketScalar>
356 struct ei_product_coeff_vectorized_unroller
357 {
358   enum { PacketSize = ei_packet_traits<typename Lhs::Scalar>::size };
359   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, typename Lhs::PacketScalar &pres)
360   {
361     ei_product_coeff_vectorized_unroller<Index-PacketSize, Lhs, Rhs, PacketScalar>::run(row, col, lhs, rhs, pres);
362     pres = ei_padd(pres, ei_pmul( lhs.template packet<Aligned>(row, Index) , rhs.template packet<Aligned>(Index, col) ));
363   }
364 };
365
366 template<typename Lhs, typename Rhs, typename PacketScalar>
367 struct ei_product_coeff_vectorized_unroller<0, Lhs, Rhs, PacketScalar>
368 {
369   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, typename Lhs::PacketScalar &pres)
370   {
371     pres = ei_pmul(lhs.template packet<Aligned>(row, 0) , rhs.template packet<Aligned>(0, col));
372   }
373 };
374
375 template<int Index, typename Lhs, typename Rhs, typename RetScalar>
376 struct ei_product_coeff_impl<InnerVectorization, Index, Lhs, Rhs, RetScalar>
377 {
378   typedef typename Lhs::PacketScalar PacketScalar;
379   enum { PacketSize = ei_packet_traits<typename Lhs::Scalar>::size };
380   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, RetScalar &res)
381   {
382     PacketScalar pres;
383     ei_product_coeff_vectorized_unroller<Index+1-PacketSize, Lhs, Rhs, PacketScalar>::run(row, col, lhs, rhs, pres);
384     ei_product_coeff_impl<NoVectorization,Index,Lhs,Rhs,RetScalar>::run(row, col, lhs, rhs, res);
385     res = ei_predux(pres);
386   }
387 };
388
389 template<typename Lhs, typename Rhs, int LhsRows = Lhs::RowsAtCompileTime, int RhsCols = Rhs::ColsAtCompileTime>
390 struct ei_product_coeff_vectorized_dyn_selector
391 {
392   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res)
393   {
394     res = ei_dot_impl<
395       Block<Lhs, 1, ei_traits<Lhs>::ColsAtCompileTime>,
396       Block<Rhs, ei_traits<Rhs>::RowsAtCompileTime, 1>,
397       LinearVectorization, NoUnrolling>::run(lhs.row(row), rhs.col(col));
398   }
399 };
400
401 // NOTE the 3 following specializations are because taking .col(0) on a vector is a bit slower
402 // NOTE maybe they are now useless since we have a specialization for Block<Matrix>
403 template<typename Lhs, typename Rhs, int RhsCols>
404 struct ei_product_coeff_vectorized_dyn_selector<Lhs,Rhs,1,RhsCols>
405 {
406   EIGEN_STRONG_INLINE static void run(int /*row*/, int col, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res)
407   {
408     res = ei_dot_impl<
409       Lhs,
410       Block<Rhs, ei_traits<Rhs>::RowsAtCompileTime, 1>,
411       LinearVectorization, NoUnrolling>::run(lhs, rhs.col(col));
412   }
413 };
414
415 template<typename Lhs, typename Rhs, int LhsRows>
416 struct ei_product_coeff_vectorized_dyn_selector<Lhs,Rhs,LhsRows,1>
417 {
418   EIGEN_STRONG_INLINE static void run(int row, int /*col*/, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res)
419   {
420     res = ei_dot_impl<
421       Block<Lhs, 1, ei_traits<Lhs>::ColsAtCompileTime>,
422       Rhs,
423       LinearVectorization, NoUnrolling>::run(lhs.row(row), rhs);
424   }
425 };
426
427 template<typename Lhs, typename Rhs>
428 struct ei_product_coeff_vectorized_dyn_selector<Lhs,Rhs,1,1>
429 {
430   EIGEN_STRONG_INLINE static void run(int /*row*/, int /*col*/, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res)
431   {
432     res = ei_dot_impl<
433       Lhs,
434       Rhs,
435       LinearVectorization, NoUnrolling>::run(lhs, rhs);
436   }
437 };
438
439 template<typename Lhs, typename Rhs, typename RetScalar>
440 struct ei_product_coeff_impl<InnerVectorization, Dynamic, Lhs, Rhs, RetScalar>
441 {
442   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, typename Lhs::Scalar &res)
443   {
444     ei_product_coeff_vectorized_dyn_selector<Lhs,Rhs>::run(row, col, lhs, rhs, res);
445   }
446 };
447
448 /*******************
449 *** Packet path  ***
450 *******************/
451
452 template<int Index, typename Lhs, typename Rhs, typename PacketScalar, int LoadMode>
453 struct ei_product_packet_impl<RowMajor, Index, Lhs, Rhs, PacketScalar, LoadMode>
454 {
455   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, PacketScalar &res)
456   {
457     ei_product_packet_impl<RowMajor, Index-1, Lhs, Rhs, PacketScalar, LoadMode>::run(row, col, lhs, rhs, res);
458     res =  ei_pmadd(ei_pset1(lhs.coeff(row, Index)), rhs.template packet<LoadMode>(Index, col), res);
459   }
460 };
461
462 template<int Index, typename Lhs, typename Rhs, typename PacketScalar, int LoadMode>
463 struct ei_product_packet_impl<ColMajor, Index, Lhs, Rhs, PacketScalar, LoadMode>
464 {
465   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, PacketScalar &res)
466   {
467     ei_product_packet_impl<ColMajor, Index-1, Lhs, Rhs, PacketScalar, LoadMode>::run(row, col, lhs, rhs, res);
468     res =  ei_pmadd(lhs.template packet<LoadMode>(row, Index), ei_pset1(rhs.coeff(Index, col)), res);
469   }
470 };
471
472 template<typename Lhs, typename Rhs, typename PacketScalar, int LoadMode>
473 struct ei_product_packet_impl<RowMajor, 0, Lhs, Rhs, PacketScalar, LoadMode>
474 {
475   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, PacketScalar &res)
476   {
477     res = ei_pmul(ei_pset1(lhs.coeff(row, 0)),rhs.template packet<LoadMode>(0, col));
478   }
479 };
480
481 template<typename Lhs, typename Rhs, typename PacketScalar, int LoadMode>
482 struct ei_product_packet_impl<ColMajor, 0, Lhs, Rhs, PacketScalar, LoadMode>
483 {
484   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, PacketScalar &res)
485   {
486     res = ei_pmul(lhs.template packet<LoadMode>(row, 0), ei_pset1(rhs.coeff(0, col)));
487   }
488 };
489
490 template<typename Lhs, typename Rhs, typename PacketScalar, int LoadMode>
491 struct ei_product_packet_impl<RowMajor, Dynamic, Lhs, Rhs, PacketScalar, LoadMode>
492 {
493   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, PacketScalar& res)
494   {
495     ei_assert(lhs.cols()>0 && "you are using a non initialized matrix");
496     res = ei_pmul(ei_pset1(lhs.coeff(row, 0)),rhs.template packet<LoadMode>(0, col));
497       for(int i = 1; i < lhs.cols(); ++i)
498         res =  ei_pmadd(ei_pset1(lhs.coeff(row, i)), rhs.template packet<LoadMode>(i, col), res);
499   }
500 };
501
502 template<typename Lhs, typename Rhs, typename PacketScalar, int LoadMode>
503 struct ei_product_packet_impl<ColMajor, Dynamic, Lhs, Rhs, PacketScalar, LoadMode>
504 {
505   EIGEN_STRONG_INLINE static void run(int row, int col, const Lhs& lhs, const Rhs& rhs, PacketScalar& res)
506   {
507     ei_assert(lhs.cols()>0 && "you are using a non initialized matrix");
508     res = ei_pmul(lhs.template packet<LoadMode>(row, 0), ei_pset1(rhs.coeff(0, col)));
509       for(int i = 1; i < lhs.cols(); ++i)
510         res =  ei_pmadd(lhs.template packet<LoadMode>(row, i), ei_pset1(rhs.coeff(i, col)), res);
511   }
512 };
513
514 /***************************************************************************
515 * Cache friendly product callers and specific nested evaluation strategies
516 ***************************************************************************/
517
518 template<typename Scalar, typename RhsType>
519 static void ei_cache_friendly_product_colmajor_times_vector(
520   int size, const Scalar* lhs, int lhsStride, const RhsType& rhs, Scalar* res);
521
522 template<typename Scalar, typename ResType>
523 static void ei_cache_friendly_product_rowmajor_times_vector(
524   const Scalar* lhs, int lhsStride, const Scalar* rhs, int rhsSize, ResType& res);
525
526 template<typename ProductType,
527   int LhsRows  = ei_traits<ProductType>::RowsAtCompileTime,
528   int LhsOrder = int(ei_traits<ProductType>::LhsFlags)&RowMajorBit ? RowMajor : ColMajor,
529   int LhsHasDirectAccess = int(ei_traits<ProductType>::LhsFlags)&DirectAccessBit? HasDirectAccess : NoDirectAccess,
530   int RhsCols  = ei_traits<ProductType>::ColsAtCompileTime,
531   int RhsOrder = int(ei_traits<ProductType>::RhsFlags)&RowMajorBit ? RowMajor : ColMajor,
532   int RhsHasDirectAccess = int(ei_traits<ProductType>::RhsFlags)&DirectAccessBit? HasDirectAccess : NoDirectAccess>
533 struct ei_cache_friendly_product_selector
534 {
535   template<typename DestDerived>
536   inline static void run(DestDerived& res, const ProductType& product)
537   {
538     product._cacheFriendlyEvalAndAdd(res);
539   }
540 };
541
542 // optimized colmajor * vector path
543 template<typename ProductType, int LhsRows, int RhsOrder, int RhsAccess>
544 struct ei_cache_friendly_product_selector<ProductType,LhsRows,ColMajor,NoDirectAccess,1,RhsOrder,RhsAccess>
545 {
546   template<typename DestDerived>
547   inline static void run(DestDerived& res, const ProductType& product)
548   {
549     const int size = product.rhs().rows();
550     for (int k=0; k<size; ++k)
551         res += product.rhs().coeff(k) * product.lhs().col(k);
552   }
553 };
554
555 // optimized cache friendly colmajor * vector path for matrix with direct access flag
556 // NOTE this path could also be enabled for expressions if we add runtime align queries
557 template<typename ProductType, int LhsRows, int RhsOrder, int RhsAccess>
558 struct ei_cache_friendly_product_selector<ProductType,LhsRows,ColMajor,HasDirectAccess,1,RhsOrder,RhsAccess>
559 {
560   typedef typename ProductType::Scalar Scalar;
561
562   template<typename DestDerived>
563   inline static void run(DestDerived& res, const ProductType& product)
564   {
565     enum {
566       EvalToRes = (ei_packet_traits<Scalar>::size==1)
567                 ||((DestDerived::Flags&ActualPacketAccessBit) && (!(DestDerived::Flags & RowMajorBit))) };
568     Scalar* EIGEN_RESTRICT _res;
569     if (EvalToRes)
570        _res = &res.coeffRef(0);
571     else
572     {
573       _res = ei_aligned_stack_new(Scalar,res.size());
574       Map<Matrix<Scalar,DestDerived::RowsAtCompileTime,1> >(_res, res.size()) = res;
575     }
576     ei_cache_friendly_product_colmajor_times_vector(res.size(),
577       &product.lhs().const_cast_derived().coeffRef(0,0), product.lhs().stride(),
578       product.rhs(), _res);
579
580     if (!EvalToRes)
581     {
582       res = Map<Matrix<Scalar,DestDerived::SizeAtCompileTime,1> >(_res, res.size());
583       ei_aligned_stack_delete(Scalar, _res, res.size());
584     }
585   }
586 };
587
588 // optimized vector * rowmajor path
589 template<typename ProductType, int LhsOrder, int LhsAccess, int RhsCols>
590 struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCols,RowMajor,NoDirectAccess>
591 {
592   template<typename DestDerived>
593   inline static void run(DestDerived& res, const ProductType& product)
594   {
595     const int cols = product.lhs().cols();
596     for (int j=0; j<cols; ++j)
597       res += product.lhs().coeff(j) * product.rhs().row(j);
598   }
599 };
600
601 // optimized cache friendly vector * rowmajor path for matrix with direct access flag
602 // NOTE this path coul also be enabled for expressions if we add runtime align queries
603 template<typename ProductType, int LhsOrder, int LhsAccess, int RhsCols>
604 struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCols,RowMajor,HasDirectAccess>
605 {
606   typedef typename ProductType::Scalar Scalar;
607
608   template<typename DestDerived>
609   inline static void run(DestDerived& res, const ProductType& product)
610   {
611     enum {
612       EvalToRes = (ei_packet_traits<Scalar>::size==1)
613                 ||((DestDerived::Flags & ActualPacketAccessBit) && (DestDerived::Flags & RowMajorBit)) };
614     Scalar* EIGEN_RESTRICT _res;
615     if (EvalToRes)
616        _res = &res.coeffRef(0);
617     else
618     {
619       _res = ei_aligned_stack_new(Scalar, res.size());
620       Map<Matrix<Scalar,DestDerived::SizeAtCompileTime,1> >(_res, res.size()) = res;
621     }
622     ei_cache_friendly_product_colmajor_times_vector(res.size(),
623       &product.rhs().const_cast_derived().coeffRef(0,0), product.rhs().stride(),
624       product.lhs().transpose(), _res);
625
626     if (!EvalToRes)
627     {
628       res = Map<Matrix<Scalar,DestDerived::SizeAtCompileTime,1> >(_res, res.size());
629       ei_aligned_stack_delete(Scalar, _res, res.size());
630     }
631   }
632 };
633
634 // optimized rowmajor - vector product
635 template<typename ProductType, int LhsRows, int RhsOrder, int RhsAccess>
636 struct ei_cache_friendly_product_selector<ProductType,LhsRows,RowMajor,HasDirectAccess,1,RhsOrder,RhsAccess>
637 {
638   typedef typename ProductType::Scalar Scalar;
639   typedef typename ei_traits<ProductType>::_RhsNested Rhs;
640   enum {
641       UseRhsDirectly = ((ei_packet_traits<Scalar>::size==1) || (Rhs::Flags&ActualPacketAccessBit))
642                      && (!(Rhs::Flags & RowMajorBit)) };
643
644   template<typename DestDerived>
645   inline static void run(DestDerived& res, const ProductType& product)
646   {
647     Scalar* EIGEN_RESTRICT _rhs;
648     if (UseRhsDirectly)
649        _rhs = &product.rhs().const_cast_derived().coeffRef(0);
650     else
651     {
652       _rhs = ei_aligned_stack_new(Scalar, product.rhs().size());
653       Map<Matrix<Scalar,Rhs::SizeAtCompileTime,1> >(_rhs, product.rhs().size()) = product.rhs();
654     }
655     ei_cache_friendly_product_rowmajor_times_vector(&product.lhs().const_cast_derived().coeffRef(0,0), product.lhs().stride(),
656                                                     _rhs, product.rhs().size(), res);
657
658     if (!UseRhsDirectly) ei_aligned_stack_delete(Scalar, _rhs, product.rhs().size());
659   }
660 };
661
662 // optimized vector - colmajor product
663 template<typename ProductType, int LhsOrder, int LhsAccess, int RhsCols>
664 struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCols,ColMajor,HasDirectAccess>
665 {
666   typedef typename ProductType::Scalar Scalar;
667   typedef typename ei_traits<ProductType>::_LhsNested Lhs;
668   enum {
669       UseLhsDirectly = ((ei_packet_traits<Scalar>::size==1) || (Lhs::Flags&ActualPacketAccessBit))
670                      && (Lhs::Flags & RowMajorBit) };
671
672   template<typename DestDerived>
673   inline static void run(DestDerived& res, const ProductType& product)
674   {
675     Scalar* EIGEN_RESTRICT _lhs;
676     if (UseLhsDirectly)
677        _lhs = &product.lhs().const_cast_derived().coeffRef(0);
678     else
679     {
680       _lhs = ei_aligned_stack_new(Scalar, product.lhs().size());
681       Map<Matrix<Scalar,Lhs::SizeAtCompileTime,1> >(_lhs, product.lhs().size()) = product.lhs();
682     }
683     ei_cache_friendly_product_rowmajor_times_vector(&product.rhs().const_cast_derived().coeffRef(0,0), product.rhs().stride(),
684                                                     _lhs, product.lhs().size(), res);
685
686     if(!UseLhsDirectly) ei_aligned_stack_delete(Scalar, _lhs, product.lhs().size());
687   }
688 };
689
690 // discard this case which has to be handled by the default path
691 // (we keep it to be sure to hit a compilation error if this is not the case)
692 template<typename ProductType, int LhsRows, int RhsOrder, int RhsAccess>
693 struct ei_cache_friendly_product_selector<ProductType,LhsRows,RowMajor,NoDirectAccess,1,RhsOrder,RhsAccess>
694 {};
695
696 // discard this case which has to be handled by the default path
697 // (we keep it to be sure to hit a compilation error if this is not the case)
698 template<typename ProductType, int LhsOrder, int LhsAccess, int RhsCols>
699 struct ei_cache_friendly_product_selector<ProductType,1,LhsOrder,LhsAccess,RhsCols,ColMajor,NoDirectAccess>
700 {};
701
702
703 /** \internal */
704 template<typename Derived>
705 template<typename Lhs,typename Rhs>
706 inline Derived&
707 MatrixBase<Derived>::operator+=(const Flagged<Product<Lhs,Rhs,CacheFriendlyProduct>, 0, EvalBeforeNestingBit | EvalBeforeAssigningBit>& other)
708 {
709   if (other._expression()._useCacheFriendlyProduct())
710     ei_cache_friendly_product_selector<Product<Lhs,Rhs,CacheFriendlyProduct> >::run(const_cast_derived(), other._expression());
711   else
712     lazyAssign(derived() + other._expression());
713   return derived();
714 }
715
716 template<typename Derived>
717 template<typename Lhs, typename Rhs>
718 inline Derived& MatrixBase<Derived>::lazyAssign(const Product<Lhs,Rhs,CacheFriendlyProduct>& product)
719 {
720   if (product._useCacheFriendlyProduct())
721   {
722     setZero();
723     ei_cache_friendly_product_selector<Product<Lhs,Rhs,CacheFriendlyProduct> >::run(const_cast_derived(), product);
724   }
725   else
726   {
727     lazyAssign<Product<Lhs,Rhs,CacheFriendlyProduct> >(product);
728   }
729   return derived();
730 }
731
732 template<typename T> struct ei_product_copy_rhs
733 {
734   typedef typename ei_meta_if<
735          (ei_traits<T>::Flags & RowMajorBit)
736       || (!(ei_traits<T>::Flags & DirectAccessBit)),
737       typename ei_plain_matrix_type_column_major<T>::type,
738       const T&
739     >::ret type;
740 };
741
742 template<typename T> struct ei_product_copy_lhs
743 {
744   typedef typename ei_meta_if<
745       (!(int(ei_traits<T>::Flags) & DirectAccessBit)),
746       typename ei_plain_matrix_type<T>::type,
747       const T&
748     >::ret type;
749 };
750
751 template<typename Lhs, typename Rhs, int ProductMode>
752 template<typename DestDerived>
753 inline void Product<Lhs,Rhs,ProductMode>::_cacheFriendlyEvalAndAdd(DestDerived& res) const
754 {
755   typedef typename ei_product_copy_lhs<_LhsNested>::type LhsCopy;
756   typedef typename ei_unref<LhsCopy>::type _LhsCopy;
757   typedef typename ei_product_copy_rhs<_RhsNested>::type RhsCopy;
758   typedef typename ei_unref<RhsCopy>::type _RhsCopy;
759   LhsCopy lhs(m_lhs);
760   RhsCopy rhs(m_rhs);
761   ei_cache_friendly_product<Scalar>(
762     rows(), cols(), lhs.cols(),
763     _LhsCopy::Flags&RowMajorBit, (const Scalar*)&(lhs.const_cast_derived().coeffRef(0,0)), lhs.stride(),
764     _RhsCopy::Flags&RowMajorBit, (const Scalar*)&(rhs.const_cast_derived().coeffRef(0,0)), rhs.stride(),
765     DestDerived::Flags&RowMajorBit, (Scalar*)&(res.coeffRef(0,0)), res.stride()
766   );
767 }
768
769 #endif // EIGEN_PRODUCT_H