sequenzo 0.1.17__cp39-cp39-macosx_10_9_universal2.whl → 0.1.19__cp39-cp39-macosx_10_9_universal2.whl

sequenzo/dissimilarity_measures/src/eigen/Eigen/src/SparseCore/SparseAssign.h

@@ -1,270 +0,0 @@
-// 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 { 
-
-template<typename Derived>    
-template<typename OtherDerived>
-Derived& SparseMatrixBase<Derived>::operator=(const EigenBase<OtherDerived> &other)
-{
-  internal::call_assignment_no_alias(derived(), other.derived());
-  return derived();
-}
-
-template<typename Derived>
-template<typename OtherDerived>
-Derived& SparseMatrixBase<Derived>::operator=(const ReturnByValue<OtherDerived>& other)
-{
-  // TODO use the evaluator mechanism
-  other.evalTo(derived());
-  return derived();
-}
-
-template<typename Derived>
-template<typename OtherDerived>
-inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other)
-{
-  // by default sparse evaluation do not alias, so we can safely bypass the generic call_assignment routine
-  internal::Assignment<Derived,OtherDerived,internal::assign_op<Scalar,typename OtherDerived::Scalar> >
-          ::run(derived(), other.derived(), internal::assign_op<Scalar,typename OtherDerived::Scalar>());
-  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 {};
-struct Sparse2Dense  {};
-
-template<> struct AssignmentKind<SparseShape, SparseShape>           { typedef Sparse2Sparse Kind; };
-template<> struct AssignmentKind<SparseShape, SparseTriangularShape> { typedef Sparse2Sparse Kind; };
-template<> struct AssignmentKind<DenseShape,  SparseShape>           { typedef Sparse2Dense  Kind; };
-template<> struct AssignmentKind<DenseShape,  SparseTriangularShape> { typedef Sparse2Dense  Kind; };
-
-
-template<typename DstXprType, typename SrcXprType>
-void assign_sparse_to_sparse(DstXprType &dst, const SrcXprType &src)
-{
-  typedef typename DstXprType::Scalar Scalar;
-  typedef internal::evaluator<DstXprType> DstEvaluatorType;
-  typedef internal::evaluator<SrcXprType> SrcEvaluatorType;
-
-  SrcEvaluatorType srcEvaluator(src);
-
-  const bool transpose = (DstEvaluatorType::Flags & RowMajorBit) != (SrcEvaluatorType::Flags & RowMajorBit);
-  const Index outerEvaluationSize = (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::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
-    for (Index j=0; j<outerEvaluationSize; ++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) };
-
-    
-    DstXprType temp(src.rows(), src.cols());
-
-    temp.reserve((std::min)(src.rows()*src.cols(), (std::max)(src.rows(),src.cols())*2));
-    for (Index j=0; j<outerEvaluationSize; ++j)
-    {
-      temp.startVec(j);
-      for (typename SrcEvaluatorType::InnerIterator it(srcEvaluator, 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>
-struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Sparse>
-{
-  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
-  {
-    assign_sparse_to_sparse(dst.derived(), src.derived());
-  }
-};
-
-// Generic Sparse to Dense assignment
-template< typename DstXprType, typename SrcXprType, typename Functor, typename Weak>
-struct Assignment<DstXprType, SrcXprType, Functor, Sparse2Dense, Weak>
-{
-  static void run(DstXprType &dst, const SrcXprType &src, const Functor &func)
-  {
-    if(internal::is_same<Functor,internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> >::value)
-      dst.setZero();
-    
-    internal::evaluator<SrcXprType> srcEval(src);
-    resize_if_allowed(dst, src, func);
-    internal::evaluator<DstXprType> dstEval(dst);
-    
-    const Index outerEvaluationSize = (internal::evaluator<SrcXprType>::Flags&RowMajorBit) ? src.rows() : src.cols();
-    for (Index j=0; j<outerEvaluationSize; ++j)
-      for (typename internal::evaluator<SrcXprType>::InnerIterator i(srcEval,j); i; ++i)
-        func.assignCoeff(dstEval.coeffRef(i.row(),i.col()), i.value());
-  }
-};
-
-// Specialization for dense ?= dense +/- sparse and dense ?= sparse +/- dense
-template<typename DstXprType, typename Func1, typename Func2>
-struct assignment_from_dense_op_sparse
-{
-  template<typename SrcXprType, typename InitialFunc>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  void run(DstXprType &dst, const SrcXprType &src, const InitialFunc& /*func*/)
-  {
-    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_DENSE_OP_SPARSE_PLUGIN
-    EIGEN_SPARSE_ASSIGNMENT_FROM_DENSE_OP_SPARSE_PLUGIN
-    #endif
-
-    call_assignment_no_alias(dst, src.lhs(), Func1());
-    call_assignment_no_alias(dst, src.rhs(), Func2());
-  }
-
-  // Specialization for dense1 = sparse + dense2; -> dense1 = dense2; dense1 += sparse;
-  template<typename Lhs, typename Rhs, typename Scalar>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  typename internal::enable_if<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type
-  run(DstXprType &dst, const CwiseBinaryOp<internal::scalar_sum_op<Scalar,Scalar>, const Lhs, const Rhs> &src,
-      const internal::assign_op<typename DstXprType::Scalar,Scalar>& /*func*/)
-  {
-    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN
-    EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN
-    #endif
-
-    // Apply the dense matrix first, then the sparse one.
-    call_assignment_no_alias(dst, src.rhs(), Func1());
-    call_assignment_no_alias(dst, src.lhs(), Func2());
-  }
-
-  // Specialization for dense1 = sparse - dense2; -> dense1 = -dense2; dense1 += sparse;
-  template<typename Lhs, typename Rhs, typename Scalar>
-  static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-  typename internal::enable_if<internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type
-  run(DstXprType &dst, const CwiseBinaryOp<internal::scalar_difference_op<Scalar,Scalar>, const Lhs, const Rhs> &src,
-      const internal::assign_op<typename DstXprType::Scalar,Scalar>& /*func*/)
-  {
-    #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN
-    EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN
-    #endif
-
-    // Apply the dense matrix first, then the sparse one.
-    call_assignment_no_alias(dst, -src.rhs(), Func1());
-    call_assignment_no_alias(dst,  src.lhs(), add_assign_op<typename DstXprType::Scalar,typename Lhs::Scalar>());
-  }
-};
-
-#define EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(ASSIGN_OP,BINOP,ASSIGN_OP2) \
-  template< typename DstXprType, typename Lhs, typename Rhs, typename Scalar> \
-  struct Assignment<DstXprType, CwiseBinaryOp<internal::BINOP<Scalar,Scalar>, const Lhs, const Rhs>, internal::ASSIGN_OP<typename DstXprType::Scalar,Scalar>, \
-                    Sparse2Dense, \
-                    typename internal::enable_if<   internal::is_same<typename internal::evaluator_traits<Lhs>::Shape,DenseShape>::value \
-                                                 || internal::is_same<typename internal::evaluator_traits<Rhs>::Shape,DenseShape>::value>::type> \
-    : assignment_from_dense_op_sparse<DstXprType, internal::ASSIGN_OP<typename DstXprType::Scalar,typename Lhs::Scalar>, internal::ASSIGN_OP2<typename DstXprType::Scalar,typename Rhs::Scalar> > \
-  {}
-
-EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(assign_op,    scalar_sum_op,add_assign_op);
-EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(add_assign_op,scalar_sum_op,add_assign_op);
-EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(sub_assign_op,scalar_sum_op,sub_assign_op);
-
-EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(assign_op,    scalar_difference_op,sub_assign_op);
-EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(add_assign_op,scalar_difference_op,sub_assign_op);
-EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE(sub_assign_op,scalar_difference_op,add_assign_op);
-
-
-// Specialization for "dst = dec.solve(rhs)"
-// NOTE we need to specialize it for Sparse2Sparse to avoid ambiguous specialization error
-template<typename DstXprType, typename DecType, typename RhsType, typename Scalar>
-struct Assignment<DstXprType, Solve<DecType,RhsType>, internal::assign_op<Scalar,Scalar>, Sparse2Sparse>
-{
-  typedef Solve<DecType,RhsType> SrcXprType;
-  static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
-  {
-    Index dstRows = src.rows();
-    Index dstCols = src.cols();
-    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
-      dst.resize(dstRows, dstCols);
-
-    src.dec()._solve_impl(src.rhs(), dst);
-  }
-};
-
-struct Diagonal2Sparse {};
-
-template<> struct AssignmentKind<SparseShape,DiagonalShape> { typedef Diagonal2Sparse Kind; };
-
-template< typename DstXprType, typename SrcXprType, typename Functor>
-struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Sparse>
-{
-  typedef typename DstXprType::StorageIndex StorageIndex;
-  typedef typename DstXprType::Scalar Scalar;
-
-  template<int Options, typename AssignFunc>
-  static void run(SparseMatrix<Scalar,Options,StorageIndex> &dst, const SrcXprType &src, const AssignFunc &func)
-  { dst.assignDiagonal(src.diagonal(), func); }
-  
-  template<typename DstDerived>
-  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
-  { dst.derived().diagonal() = src.diagonal(); }
-  
-  template<typename DstDerived>
-  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
-  { dst.derived().diagonal() += src.diagonal(); }
-  
-  template<typename DstDerived>
-  static void run(SparseMatrixBase<DstDerived> &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
-  { dst.derived().diagonal() -= src.diagonal(); }
-};
-} // end namespace internal
-
-} // end namespace Eigen
-
-#endif // EIGEN_SPARSEASSIGN_H