Eigen  3.3.2
SparseCwiseBinaryOp.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_SPARSE_CWISE_BINARY_OP_H
11 #define EIGEN_SPARSE_CWISE_BINARY_OP_H
12 
13 namespace Eigen {
14 
15 // Here we have to handle 3 cases:
16 // 1 - sparse op dense
17 // 2 - dense op sparse
18 // 3 - sparse op sparse
19 // We also need to implement a 4th iterator for:
20 // 4 - dense op dense
21 // Finally, we also need to distinguish between the product and other operations :
22 // configuration returned mode
23 // 1 - sparse op dense product sparse
24 // generic dense
25 // 2 - dense op sparse product sparse
26 // generic dense
27 // 3 - sparse op sparse product sparse
28 // generic sparse
29 // 4 - dense op dense product dense
30 // generic dense
31 //
32 // TODO to ease compiler job, we could specialize product/quotient with a scalar
33 // and fallback to cwise-unary evaluator using bind1st_op and bind2nd_op.
34 
35 template<typename BinaryOp, typename Lhs, typename Rhs>
36 class CwiseBinaryOpImpl<BinaryOp, Lhs, Rhs, Sparse>
37  : public SparseMatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
38 {
39  public:
40  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> Derived;
41  typedef SparseMatrixBase<Derived> Base;
42  EIGEN_SPARSE_PUBLIC_INTERFACE(Derived)
43  CwiseBinaryOpImpl()
44  {
45  EIGEN_STATIC_ASSERT((
46  (!internal::is_same<typename internal::traits<Lhs>::StorageKind,
47  typename internal::traits<Rhs>::StorageKind>::value)
48  || ((internal::evaluator<Lhs>::Flags&RowMajorBit) == (internal::evaluator<Rhs>::Flags&RowMajorBit))),
49  THE_STORAGE_ORDER_OF_BOTH_SIDES_MUST_MATCH);
50  }
51 };
52 
53 namespace internal {
54 
55 
56 // Generic "sparse OP sparse"
57 template<typename XprType> struct binary_sparse_evaluator;
58 
59 template<typename BinaryOp, typename Lhs, typename Rhs>
60 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IteratorBased>
61  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
62 {
63 protected:
64  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
65  typedef typename evaluator<Rhs>::InnerIterator RhsIterator;
66  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
67  typedef typename traits<XprType>::Scalar Scalar;
68  typedef typename XprType::StorageIndex StorageIndex;
69 public:
70 
71  class InnerIterator
72  {
73  public:
74 
75  EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
76  : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
77  {
78  this->operator++();
79  }
80 
81  EIGEN_STRONG_INLINE InnerIterator& operator++()
82  {
83  if (m_lhsIter && m_rhsIter && (m_lhsIter.index() == m_rhsIter.index()))
84  {
85  m_id = m_lhsIter.index();
86  m_value = m_functor(m_lhsIter.value(), m_rhsIter.value());
87  ++m_lhsIter;
88  ++m_rhsIter;
89  }
90  else if (m_lhsIter && (!m_rhsIter || (m_lhsIter.index() < m_rhsIter.index())))
91  {
92  m_id = m_lhsIter.index();
93  m_value = m_functor(m_lhsIter.value(), Scalar(0));
94  ++m_lhsIter;
95  }
96  else if (m_rhsIter && (!m_lhsIter || (m_lhsIter.index() > m_rhsIter.index())))
97  {
98  m_id = m_rhsIter.index();
99  m_value = m_functor(Scalar(0), m_rhsIter.value());
100  ++m_rhsIter;
101  }
102  else
103  {
104  m_value = 0; // this is to avoid a compilation warning
105  m_id = -1;
106  }
107  return *this;
108  }
109 
110  EIGEN_STRONG_INLINE Scalar value() const { return m_value; }
111 
112  EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
113  EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
114  EIGEN_STRONG_INLINE Index row() const { return Lhs::IsRowMajor ? m_lhsIter.row() : index(); }
115  EIGEN_STRONG_INLINE Index col() const { return Lhs::IsRowMajor ? index() : m_lhsIter.col(); }
116 
117  EIGEN_STRONG_INLINE operator bool() const { return m_id>=0; }
118 
119  protected:
120  LhsIterator m_lhsIter;
121  RhsIterator m_rhsIter;
122  const BinaryOp& m_functor;
123  Scalar m_value;
124  StorageIndex m_id;
125  };
126 
127 
128  enum {
129  CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
130  Flags = XprType::Flags
131  };
132 
133  explicit binary_evaluator(const XprType& xpr)
134  : m_functor(xpr.functor()),
135  m_lhsImpl(xpr.lhs()),
136  m_rhsImpl(xpr.rhs())
137  {
138  EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
139  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
140  }
141 
142  inline Index nonZerosEstimate() const {
143  return m_lhsImpl.nonZerosEstimate() + m_rhsImpl.nonZerosEstimate();
144  }
145 
146 protected:
147  const BinaryOp m_functor;
148  evaluator<Lhs> m_lhsImpl;
149  evaluator<Rhs> m_rhsImpl;
150 };
151 
152 // dense op sparse
153 template<typename BinaryOp, typename Lhs, typename Rhs>
154 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IteratorBased>
155  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
156 {
157 protected:
158  typedef typename evaluator<Rhs>::InnerIterator RhsIterator;
159  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
160  typedef typename traits<XprType>::Scalar Scalar;
161  typedef typename XprType::StorageIndex StorageIndex;
162 public:
163 
164  class InnerIterator
165  {
166  enum { IsRowMajor = (int(Rhs::Flags)&RowMajorBit)==RowMajorBit };
167  public:
168 
169  EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
170  : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.rhs().innerSize())
171  {
172  this->operator++();
173  }
174 
175  EIGEN_STRONG_INLINE InnerIterator& operator++()
176  {
177  ++m_id;
178  if(m_id<m_innerSize)
179  {
180  Scalar lhsVal = m_lhsEval.coeff(IsRowMajor?m_rhsIter.outer():m_id,
181  IsRowMajor?m_id:m_rhsIter.outer());
182  if(m_rhsIter && m_rhsIter.index()==m_id)
183  {
184  m_value = m_functor(lhsVal, m_rhsIter.value());
185  ++m_rhsIter;
186  }
187  else
188  m_value = m_functor(lhsVal, Scalar(0));
189  }
190 
191  return *this;
192  }
193 
194  EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
195 
196  EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
197  EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
198  EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_rhsIter.outer() : m_id; }
199  EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_rhsIter.outer(); }
200 
201  EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
202 
203  protected:
204  const evaluator<Lhs> &m_lhsEval;
205  RhsIterator m_rhsIter;
206  const BinaryOp& m_functor;
207  Scalar m_value;
208  StorageIndex m_id;
209  StorageIndex m_innerSize;
210  };
211 
212 
213  enum {
214  CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
215  // Expose storage order of the sparse expression
216  Flags = (XprType::Flags & ~RowMajorBit) | (int(Rhs::Flags)&RowMajorBit)
217  };
218 
219  explicit binary_evaluator(const XprType& xpr)
220  : m_functor(xpr.functor()),
221  m_lhsImpl(xpr.lhs()),
222  m_rhsImpl(xpr.rhs()),
223  m_expr(xpr)
224  {
225  EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
226  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
227  }
228 
229  inline Index nonZerosEstimate() const {
230  return m_expr.size();
231  }
232 
233 protected:
234  const BinaryOp m_functor;
235  evaluator<Lhs> m_lhsImpl;
236  evaluator<Rhs> m_rhsImpl;
237  const XprType &m_expr;
238 };
239 
240 // sparse op dense
241 template<typename BinaryOp, typename Lhs, typename Rhs>
242 struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IteratorBased, IndexBased>
243  : evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
244 {
245 protected:
246  typedef typename evaluator<Lhs>::InnerIterator LhsIterator;
247  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
248  typedef typename traits<XprType>::Scalar Scalar;
249  typedef typename XprType::StorageIndex StorageIndex;
250 public:
251 
252  class InnerIterator
253  {
254  enum { IsRowMajor = (int(Lhs::Flags)&RowMajorBit)==RowMajorBit };
255  public:
256 
257  EIGEN_STRONG_INLINE InnerIterator(const binary_evaluator& aEval, Index outer)
258  : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_value(0), m_id(-1), m_innerSize(aEval.m_expr.lhs().innerSize())
259  {
260  this->operator++();
261  }
262 
263  EIGEN_STRONG_INLINE InnerIterator& operator++()
264  {
265  ++m_id;
266  if(m_id<m_innerSize)
267  {
268  Scalar rhsVal = m_rhsEval.coeff(IsRowMajor?m_lhsIter.outer():m_id,
269  IsRowMajor?m_id:m_lhsIter.outer());
270  if(m_lhsIter && m_lhsIter.index()==m_id)
271  {
272  m_value = m_functor(m_lhsIter.value(), rhsVal);
273  ++m_lhsIter;
274  }
275  else
276  m_value = m_functor(Scalar(0),rhsVal);
277  }
278 
279  return *this;
280  }
281 
282  EIGEN_STRONG_INLINE Scalar value() const { eigen_internal_assert(m_id<m_innerSize); return m_value; }
283 
284  EIGEN_STRONG_INLINE StorageIndex index() const { return m_id; }
285  EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
286  EIGEN_STRONG_INLINE Index row() const { return IsRowMajor ? m_lhsIter.outer() : m_id; }
287  EIGEN_STRONG_INLINE Index col() const { return IsRowMajor ? m_id : m_lhsIter.outer(); }
288 
289  EIGEN_STRONG_INLINE operator bool() const { return m_id<m_innerSize; }
290 
291  protected:
292  LhsIterator m_lhsIter;
293  const evaluator<Rhs> &m_rhsEval;
294  const BinaryOp& m_functor;
295  Scalar m_value;
296  StorageIndex m_id;
297  StorageIndex m_innerSize;
298  };
299 
300 
301  enum {
302  CoeffReadCost = evaluator<Lhs>::CoeffReadCost + evaluator<Rhs>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
303  // Expose storage order of the sparse expression
304  Flags = (XprType::Flags & ~RowMajorBit) | (int(Lhs::Flags)&RowMajorBit)
305  };
306 
307  explicit binary_evaluator(const XprType& xpr)
308  : m_functor(xpr.functor()),
309  m_lhsImpl(xpr.lhs()),
310  m_rhsImpl(xpr.rhs()),
311  m_expr(xpr)
312  {
313  EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
314  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
315  }
316 
317  inline Index nonZerosEstimate() const {
318  return m_expr.size();
319  }
320 
321 protected:
322  const BinaryOp m_functor;
323  evaluator<Lhs> m_lhsImpl;
324  evaluator<Rhs> m_rhsImpl;
325  const XprType &m_expr;
326 };
327 
328 template<typename T,
329  typename LhsKind = typename evaluator_traits<typename T::Lhs>::Kind,
330  typename RhsKind = typename evaluator_traits<typename T::Rhs>::Kind,
331  typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
332  typename RhsScalar = typename traits<typename T::Rhs>::Scalar> struct sparse_conjunction_evaluator;
333 
334 // "sparse .* sparse"
335 template<typename T1, typename T2, typename Lhs, typename Rhs>
336 struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IteratorBased>
337  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
338 {
339  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
340  typedef sparse_conjunction_evaluator<XprType> Base;
341  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
342 };
343 // "dense .* sparse"
344 template<typename T1, typename T2, typename Lhs, typename Rhs>
345 struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IndexBased, IteratorBased>
346  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
347 {
348  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
349  typedef sparse_conjunction_evaluator<XprType> Base;
350  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
351 };
352 // "sparse .* dense"
353 template<typename T1, typename T2, typename Lhs, typename Rhs>
354 struct binary_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs>, IteratorBased, IndexBased>
355  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> >
356 {
357  typedef CwiseBinaryOp<scalar_product_op<T1,T2>, Lhs, Rhs> XprType;
358  typedef sparse_conjunction_evaluator<XprType> Base;
359  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
360 };
361 
362 // "sparse && sparse"
363 template<typename Lhs, typename Rhs>
364 struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IteratorBased>
365  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
366 {
367  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
368  typedef sparse_conjunction_evaluator<XprType> Base;
369  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
370 };
371 // "dense && sparse"
372 template<typename Lhs, typename Rhs>
373 struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IndexBased, IteratorBased>
374  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
375 {
376  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
377  typedef sparse_conjunction_evaluator<XprType> Base;
378  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
379 };
380 // "sparse && dense"
381 template<typename Lhs, typename Rhs>
382 struct binary_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs>, IteratorBased, IndexBased>
383  : sparse_conjunction_evaluator<CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> >
384 {
385  typedef CwiseBinaryOp<scalar_boolean_and_op, Lhs, Rhs> XprType;
386  typedef sparse_conjunction_evaluator<XprType> Base;
387  explicit binary_evaluator(const XprType& xpr) : Base(xpr) {}
388 };
389 
390 // "sparse ^ sparse"
391 template<typename XprType>
392 struct sparse_conjunction_evaluator<XprType, IteratorBased, IteratorBased>
393  : evaluator_base<XprType>
394 {
395 protected:
396  typedef typename XprType::Functor BinaryOp;
397  typedef typename XprType::Lhs LhsArg;
398  typedef typename XprType::Rhs RhsArg;
399  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
400  typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
401  typedef typename XprType::StorageIndex StorageIndex;
402  typedef typename traits<XprType>::Scalar Scalar;
403 public:
404 
405  class InnerIterator
406  {
407  public:
408 
409  EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
410  : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor)
411  {
412  while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
413  {
414  if (m_lhsIter.index() < m_rhsIter.index())
415  ++m_lhsIter;
416  else
417  ++m_rhsIter;
418  }
419  }
420 
421  EIGEN_STRONG_INLINE InnerIterator& operator++()
422  {
423  ++m_lhsIter;
424  ++m_rhsIter;
425  while (m_lhsIter && m_rhsIter && (m_lhsIter.index() != m_rhsIter.index()))
426  {
427  if (m_lhsIter.index() < m_rhsIter.index())
428  ++m_lhsIter;
429  else
430  ++m_rhsIter;
431  }
432  return *this;
433  }
434 
435  EIGEN_STRONG_INLINE Scalar value() const { return m_functor(m_lhsIter.value(), m_rhsIter.value()); }
436 
437  EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
438  EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
439  EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
440  EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
441 
442  EIGEN_STRONG_INLINE operator bool() const { return (m_lhsIter && m_rhsIter); }
443 
444  protected:
445  LhsIterator m_lhsIter;
446  RhsIterator m_rhsIter;
447  const BinaryOp& m_functor;
448  };
449 
450 
451  enum {
452  CoeffReadCost = evaluator<LhsArg>::CoeffReadCost + evaluator<RhsArg>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
453  Flags = XprType::Flags
454  };
455 
456  explicit sparse_conjunction_evaluator(const XprType& xpr)
457  : m_functor(xpr.functor()),
458  m_lhsImpl(xpr.lhs()),
459  m_rhsImpl(xpr.rhs())
460  {
461  EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
462  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
463  }
464 
465  inline Index nonZerosEstimate() const {
466  return (std::min)(m_lhsImpl.nonZerosEstimate(), m_rhsImpl.nonZerosEstimate());
467  }
468 
469 protected:
470  const BinaryOp m_functor;
471  evaluator<LhsArg> m_lhsImpl;
472  evaluator<RhsArg> m_rhsImpl;
473 };
474 
475 // "dense ^ sparse"
476 template<typename XprType>
477 struct sparse_conjunction_evaluator<XprType, IndexBased, IteratorBased>
478  : evaluator_base<XprType>
479 {
480 protected:
481  typedef typename XprType::Functor BinaryOp;
482  typedef typename XprType::Lhs LhsArg;
483  typedef typename XprType::Rhs RhsArg;
484  typedef evaluator<LhsArg> LhsEvaluator;
485  typedef typename evaluator<RhsArg>::InnerIterator RhsIterator;
486  typedef typename XprType::StorageIndex StorageIndex;
487  typedef typename traits<XprType>::Scalar Scalar;
488 public:
489 
490  class InnerIterator
491  {
492  enum { IsRowMajor = (int(RhsArg::Flags)&RowMajorBit)==RowMajorBit };
493 
494  public:
495 
496  EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
497  : m_lhsEval(aEval.m_lhsImpl), m_rhsIter(aEval.m_rhsImpl,outer), m_functor(aEval.m_functor), m_outer(outer)
498  {}
499 
500  EIGEN_STRONG_INLINE InnerIterator& operator++()
501  {
502  ++m_rhsIter;
503  return *this;
504  }
505 
506  EIGEN_STRONG_INLINE Scalar value() const
507  { return m_functor(m_lhsEval.coeff(IsRowMajor?m_outer:m_rhsIter.index(),IsRowMajor?m_rhsIter.index():m_outer), m_rhsIter.value()); }
508 
509  EIGEN_STRONG_INLINE StorageIndex index() const { return m_rhsIter.index(); }
510  EIGEN_STRONG_INLINE Index outer() const { return m_rhsIter.outer(); }
511  EIGEN_STRONG_INLINE Index row() const { return m_rhsIter.row(); }
512  EIGEN_STRONG_INLINE Index col() const { return m_rhsIter.col(); }
513 
514  EIGEN_STRONG_INLINE operator bool() const { return m_rhsIter; }
515 
516  protected:
517  const LhsEvaluator &m_lhsEval;
518  RhsIterator m_rhsIter;
519  const BinaryOp& m_functor;
520  const Index m_outer;
521  };
522 
523 
524  enum {
525  CoeffReadCost = evaluator<LhsArg>::CoeffReadCost + evaluator<RhsArg>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
526  // Expose storage order of the sparse expression
527  Flags = (XprType::Flags & ~RowMajorBit) | (int(RhsArg::Flags)&RowMajorBit)
528  };
529 
530  explicit sparse_conjunction_evaluator(const XprType& xpr)
531  : m_functor(xpr.functor()),
532  m_lhsImpl(xpr.lhs()),
533  m_rhsImpl(xpr.rhs())
534  {
535  EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
536  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
537  }
538 
539  inline Index nonZerosEstimate() const {
540  return m_rhsImpl.nonZerosEstimate();
541  }
542 
543 protected:
544  const BinaryOp m_functor;
545  evaluator<LhsArg> m_lhsImpl;
546  evaluator<RhsArg> m_rhsImpl;
547 };
548 
549 // "sparse ^ dense"
550 template<typename XprType>
551 struct sparse_conjunction_evaluator<XprType, IteratorBased, IndexBased>
552  : evaluator_base<XprType>
553 {
554 protected:
555  typedef typename XprType::Functor BinaryOp;
556  typedef typename XprType::Lhs LhsArg;
557  typedef typename XprType::Rhs RhsArg;
558  typedef typename evaluator<LhsArg>::InnerIterator LhsIterator;
559  typedef evaluator<RhsArg> RhsEvaluator;
560  typedef typename XprType::StorageIndex StorageIndex;
561  typedef typename traits<XprType>::Scalar Scalar;
562 public:
563 
564  class InnerIterator
565  {
566  enum { IsRowMajor = (int(LhsArg::Flags)&RowMajorBit)==RowMajorBit };
567 
568  public:
569 
570  EIGEN_STRONG_INLINE InnerIterator(const sparse_conjunction_evaluator& aEval, Index outer)
571  : m_lhsIter(aEval.m_lhsImpl,outer), m_rhsEval(aEval.m_rhsImpl), m_functor(aEval.m_functor), m_outer(outer)
572  {}
573 
574  EIGEN_STRONG_INLINE InnerIterator& operator++()
575  {
576  ++m_lhsIter;
577  return *this;
578  }
579 
580  EIGEN_STRONG_INLINE Scalar value() const
581  { return m_functor(m_lhsIter.value(),
582  m_rhsEval.coeff(IsRowMajor?m_outer:m_lhsIter.index(),IsRowMajor?m_lhsIter.index():m_outer)); }
583 
584  EIGEN_STRONG_INLINE StorageIndex index() const { return m_lhsIter.index(); }
585  EIGEN_STRONG_INLINE Index outer() const { return m_lhsIter.outer(); }
586  EIGEN_STRONG_INLINE Index row() const { return m_lhsIter.row(); }
587  EIGEN_STRONG_INLINE Index col() const { return m_lhsIter.col(); }
588 
589  EIGEN_STRONG_INLINE operator bool() const { return m_lhsIter; }
590 
591  protected:
592  LhsIterator m_lhsIter;
593  const evaluator<RhsArg> &m_rhsEval;
594  const BinaryOp& m_functor;
595  const Index m_outer;
596  };
597 
598 
599  enum {
600  CoeffReadCost = evaluator<LhsArg>::CoeffReadCost + evaluator<RhsArg>::CoeffReadCost + functor_traits<BinaryOp>::Cost,
601  // Expose storage order of the sparse expression
602  Flags = (XprType::Flags & ~RowMajorBit) | (int(LhsArg::Flags)&RowMajorBit)
603  };
604 
605  explicit sparse_conjunction_evaluator(const XprType& xpr)
606  : m_functor(xpr.functor()),
607  m_lhsImpl(xpr.lhs()),
608  m_rhsImpl(xpr.rhs())
609  {
610  EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
611  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
612  }
613 
614  inline Index nonZerosEstimate() const {
615  return m_lhsImpl.nonZerosEstimate();
616  }
617 
618 protected:
619  const BinaryOp m_functor;
620  evaluator<LhsArg> m_lhsImpl;
621  evaluator<RhsArg> m_rhsImpl;
622 };
623 
624 }
625 
626 /***************************************************************************
627 * Implementation of SparseMatrixBase and SparseCwise functions/operators
628 ***************************************************************************/
629 
630 template<typename Derived>
631 template<typename OtherDerived>
632 Derived& SparseMatrixBase<Derived>::operator+=(const EigenBase<OtherDerived> &other)
633 {
634  call_assignment(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
635  return derived();
636 }
637 
638 template<typename Derived>
639 template<typename OtherDerived>
640 Derived& SparseMatrixBase<Derived>::operator-=(const EigenBase<OtherDerived> &other)
641 {
642  call_assignment(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
643  return derived();
644 }
645 
646 template<typename Derived>
647 template<typename OtherDerived>
648 EIGEN_STRONG_INLINE Derived &
649 SparseMatrixBase<Derived>::operator-=(const SparseMatrixBase<OtherDerived> &other)
650 {
651  return derived() = derived() - other.derived();
652 }
653 
654 template<typename Derived>
655 template<typename OtherDerived>
656 EIGEN_STRONG_INLINE Derived &
657 SparseMatrixBase<Derived>::operator+=(const SparseMatrixBase<OtherDerived>& other)
658 {
659  return derived() = derived() + other.derived();
660 }
661 
662 template<typename Derived>
663 template<typename OtherDerived>
664 Derived& SparseMatrixBase<Derived>::operator+=(const DiagonalBase<OtherDerived>& other)
665 {
666  call_assignment_no_alias(derived(), other.derived(), internal::add_assign_op<Scalar,typename OtherDerived::Scalar>());
667  return derived();
668 }
669 
670 template<typename Derived>
671 template<typename OtherDerived>
672 Derived& SparseMatrixBase<Derived>::operator-=(const DiagonalBase<OtherDerived>& other)
673 {
674  call_assignment_no_alias(derived(), other.derived(), internal::sub_assign_op<Scalar,typename OtherDerived::Scalar>());
675  return derived();
676 }
677 
678 template<typename Derived>
679 template<typename OtherDerived>
680 EIGEN_STRONG_INLINE const typename SparseMatrixBase<Derived>::template CwiseProductDenseReturnType<OtherDerived>::Type
681 SparseMatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) const
682 {
683  return typename CwiseProductDenseReturnType<OtherDerived>::Type(derived(), other.derived());
684 }
685 
686 template<typename DenseDerived, typename SparseDerived>
687 EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
688 operator+(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
689 {
690  return CwiseBinaryOp<internal::scalar_sum_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
691 }
692 
693 template<typename SparseDerived, typename DenseDerived>
694 EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
695 operator+(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
696 {
697  return CwiseBinaryOp<internal::scalar_sum_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
698 }
699 
700 template<typename DenseDerived, typename SparseDerived>
701 EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>
702 operator-(const MatrixBase<DenseDerived> &a, const SparseMatrixBase<SparseDerived> &b)
703 {
704  return CwiseBinaryOp<internal::scalar_difference_op<typename DenseDerived::Scalar,typename SparseDerived::Scalar>, const DenseDerived, const SparseDerived>(a.derived(), b.derived());
705 }
706 
707 template<typename SparseDerived, typename DenseDerived>
708 EIGEN_STRONG_INLINE const CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>
709 operator-(const SparseMatrixBase<SparseDerived> &a, const MatrixBase<DenseDerived> &b)
710 {
711  return CwiseBinaryOp<internal::scalar_difference_op<typename SparseDerived::Scalar,typename DenseDerived::Scalar>, const SparseDerived, const DenseDerived>(a.derived(), b.derived());
712 }
713 
714 } // end namespace Eigen
715 
716 #endif // EIGEN_SPARSE_CWISE_BINARY_OP_H
const CwiseBinaryOp< internal::scalar_product_op< Derived ::Scalar, OtherDerived ::Scalar >, const Derived, const OtherDerived > cwiseProduct(const Eigen::SparseMatrixBase< OtherDerived > &other) const
Definition: SparseMatrixBase.h:24
Namespace containing all symbols from the Eigen library.
Definition: Core:287
const unsigned int RowMajorBit
Definition: Constants.h:61
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
Definition: Eigen_Colamd.h:50