Started to move the SparseCore module to evaluators: implemented assignment and cwise-unary evaluator

1 files changed, 252 insertions, 0 deletions

diff --git a/Eigen/src/SparseCore/SparseAssign.h b/Eigen/src/SparseCore/SparseAssign.h
new file mode 100644
index 000000000..99a1a8712
--- /dev/null
+++ b/Eigen/src/SparseCore/SparseAssign.h
@@ -0,0 +1,252 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_SPARSEASSIGN_H
+#define EIGEN_SPARSEASSIGN_H
+
+namespace Eigen { 
+
+#ifndef EIGEN_TEST_EVALUATORS
+
+template<typename Derived>    
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  other.derived().evalTo(derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.evalTo(derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  return assign(other.derived());
+}
+
+template<typename Derived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const Derived& other)
+{
+//   if (other.isRValue())
+//     derived().swap(other.const_cast_derived());
+//   else
+  return assign(other.derived());
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived& SparseMatrixBase<Derived>::assign(const OtherDerived& other)
+{
+  const bool transpose = (Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit);
+  const Index outerSize = (int(OtherDerived::Flags) & RowMajorBit) ? other.rows() : other.cols();
+  if ((!transpose) && other.isRValue())
+  {
+    // eval without temporary
+    derived().resize(other.rows(), other.cols());
+    derived().setZero();
+    derived().reserve((std::max)(this->rows(),this->cols())*2);
+    for (Index j=0; j<outerSize; ++j)
+    {
+      derived().startVec(j);
+      for (typename OtherDerived::InnerIterator it(other, j); it; ++it)
+      {
+        Scalar v = it.value();
+        derived().insertBackByOuterInner(j,it.index()) = v;
+      }
+    }
+    derived().finalize();
+  }
+  else
+  {
+    assignGeneric(other);
+  }
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+inline void SparseMatrixBase<Derived>::assignGeneric(const OtherDerived& other)
+{
+  //const bool transpose = (Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit);
+  eigen_assert(( ((internal::traits<Derived>::SupportedAccessPatterns&OuterRandomAccessPattern)==OuterRandomAccessPattern) ||
+              (!((Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit)))) &&
+              "the transpose operation is supposed to be handled in SparseMatrix::operator=");
+
+  enum { Flip = (Flags & RowMajorBit) != (OtherDerived::Flags & RowMajorBit) };
+
+  const Index outerSize = other.outerSize();
+  //typedef typename internal::conditional<transpose, LinkedVectorMatrix<Scalar,Flags&RowMajorBit>, Derived>::type TempType;
+  // thanks to shallow copies, we always eval to a tempary
+  Derived temp(other.rows(), other.cols());
+
+  temp.reserve((std::max)(this->rows(),this->cols())*2);
+  for (Index j=0; j<outerSize; ++j)
+  {
+    temp.startVec(j);
+    for (typename OtherDerived::InnerIterator it(other.derived(), j); it; ++it)
+    {
+      Scalar v = it.value();
+      temp.insertBackByOuterInner(Flip?it.index():j,Flip?j:it.index()) = v;
+    }
+  }
+  temp.finalize();
+
+  derived() = temp.markAsRValue();
+}
+
+// template<typename Lhs, typename Rhs>
+// inline Derived& operator=(const SparseSparseProduct<Lhs,Rhs>& product);
+// 
+// template<typename OtherDerived>
+// Derived& operator+=(const SparseMatrixBase<OtherDerived>& other);
+// template<typename OtherDerived>
+// Derived& operator-=(const SparseMatrixBase<OtherDerived>& other);
+// 
+// Derived& operator*=(const Scalar& other);
+// Derived& operator/=(const Scalar& other);
+// 
+// template<typename OtherDerived>
+// Derived& operator*=(const SparseMatrixBase<OtherDerived>& other);
+
+#else // EIGEN_TEST_EVALUATORS
+
+template<typename Derived>    
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
+{
+  other.derived().evalTo(derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+Derived& SparseMatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
+{
+  other.evalTo(derived());
+  return derived();
+}
+
+template<typename Derived>
+template<typename OtherDerived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+template<typename Derived>
+inline Derived& SparseMatrixBase<Derived>::operator=(const Derived& other)
+{
+  internal::call_assignment_no_alias(derived(), other.derived());
+  return derived();
+}
+
+namespace internal {
+
+template<>
+struct storage_kind_to_evaluator_kind<Sparse> {
+  typedef IteratorBased Kind;
+};
+
+template<>
+struct storage_kind_to_shape<Sparse> {
+  typedef SparseShape Shape;
+};
+
+struct Sparse2Sparse {};
+
+template<> struct AssignmentKind<SparseShape,SparseShape> { typedef Sparse2Sparse Kind; };
+
+
+template<typename DstXprType, typename SrcXprType>
+void assign_sparse_to_sparse(DstXprType &dst, const SrcXprType &src)
+{
+  eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+  
+  typedef typename DstXprType::Index Index;
+  typedef typename DstXprType::Scalar Scalar;
+  typedef typename internal::evaluator<DstXprType>::type DstEvaluatorType;
+  typedef typename internal::evaluator<SrcXprType>::type SrcEvaluatorType;
+
+  DstEvaluatorType dstEvaluator(dst);
+  SrcEvaluatorType srcEvaluator(src);
+    
+  const bool transpose = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit);
+  const Index outerSize = (int(SrcEvaluatorType::Flags) & RowMajorBit) ? src.rows() : src.cols();
+  if ((!transpose) && src.isRValue())
+  {
+    // eval without temporary
+    dst.resize(src.rows(), src.cols());
+    dst.setZero();
+    dst.reserve((std::max)(src.rows(),src.cols())*2);
+    for (Index j=0; j<outerSize; ++j)
+    {
+      dst.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, j); it; ++it)
+      {
+        Scalar v = it.value();
+        dst.insertBackByOuterInner(j,it.index()) = v;
+      }
+    }
+    dst.finalize();
+  }
+  else
+  {
+    // eval through a temporary
+    eigen_assert(( ((internal::traits<DstXprType>::SupportedAccessPatterns & OuterRandomAccessPattern)==OuterRandomAccessPattern) ||
+              (!((DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit)))) &&
+              "the transpose operation is supposed to be handled in SparseMatrix::operator=");
+
+    enum { Flip = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit) };
+
+    const Index outerSize = src.outerSize();
+    DstXprType temp(src.rows(), src.cols());
+
+    temp.reserve((std::max)(src.rows(),src.cols())*2);
+    for (Index j=0; j<outerSize; ++j)
+    {
+      temp.startVec(j);
+      for (typename SrcEvaluatorType::InnerIterator it(src, j); it; ++it)
+      {
+        Scalar v = it.value();
+        temp.insertBackByOuterInner(Flip?it.index():j,Flip?j:it.index()) = v;
+      }
+    }
+    temp.finalize();
+
+    dst = temp.markAsRValue();
+  }
+}
+
+// Generic Sparse to Sparse assignment
+template< typename DstXprType, typename SrcXprType, typename Functor, typename Scalar>
+struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Sparse, Scalar>
+{
+  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar> &/*func*/)
+  {
+    eigen_assert(dst.rows() == src.rows() && dst.cols() == src.cols());
+    
+    assign_sparse_to_sparse(dst.derived(), src.derived());
+  }
+};
+
+} // end namespace internal
+
+#endif // EIGEN_TEST_EVALUATORS
+
+} // end namespace Eigen
+
+#endif // EIGEN_SPARSEASSIGN_H