| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| |
|
| | #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) |
| | { |
| | |
| | other.evalTo(derived()); |
| | return derived(); |
| | } |
| |
|
| | template<typename Derived> |
| | template<typename OtherDerived> |
| | inline Derived& SparseMatrixBase<Derived>::operator=(const SparseMatrixBase<OtherDerived>& other) |
| | { |
| | |
| | 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()) |
| | { |
| | |
| | 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 |
| | { |
| | |
| | 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(); |
| | } |
| | } |
| |
|
| | |
| | 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> &) |
| | { |
| | assign_sparse_to_sparse(dst.derived(), src.derived()); |
| | } |
| | }; |
| |
|
| | |
| | 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()); |
| | } |
| | }; |
| |
|
| | |
| | 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& ) |
| | { |
| | #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()); |
| | } |
| |
|
| | |
| | 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>& ) |
| | { |
| | #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN |
| | EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN |
| | #endif |
| |
|
| | |
| | call_assignment_no_alias(dst, src.rhs(), Func1()); |
| | call_assignment_no_alias(dst, src.lhs(), Func2()); |
| | } |
| |
|
| | |
| | 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>& ) |
| | { |
| | #ifdef EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN |
| | EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN |
| | #endif |
| |
|
| | |
| | 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); |
| |
|
| |
|
| | |
| | |
| | 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> &) |
| | { 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> &) |
| | { 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> &) |
| | { dst.derived().diagonal() -= src.diagonal(); } |
| | }; |
| | } |
| |
|
| | } |
| |
|
| | #endif |
| |
|