SparsePermutation.h
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2012 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_PERMUTATION_H
11 #define EIGEN_SPARSE_PERMUTATION_H
12 
13 // This file implements sparse * permutation products
14 
15 namespace Eigen {
16 
17 namespace internal {
18 
19 template<typename ExpressionType, int Side, bool Transposed>
20 struct permutation_matrix_product<ExpressionType, Side, Transposed, SparseShape>
21 {
24 
26  typedef typename MatrixTypeCleaned::StorageIndex StorageIndex;
27 
28  enum {
29  SrcStorageOrder = MatrixTypeCleaned::Flags&RowMajorBit ? RowMajor : ColMajor,
30  MoveOuter = SrcStorageOrder==RowMajor ? Side==OnTheLeft : Side==OnTheRight
31  };
32 
33  typedef typename internal::conditional<MoveOuter,
36 
37  template<typename Dest,typename PermutationType>
38  static inline void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
39  {
40  MatrixType mat(xpr);
41  if(MoveOuter)
42  {
43  SparseMatrix<Scalar,SrcStorageOrder,StorageIndex> tmp(mat.rows(), mat.cols());
44  Matrix<StorageIndex,Dynamic,1> sizes(mat.outerSize());
45  for(Index j=0; j<mat.outerSize(); ++j)
46  {
47  Index jp = perm.indices().coeff(j);
48  sizes[((Side==OnTheLeft) ^ Transposed) ? jp : j] = StorageIndex(mat.innerVector(((Side==OnTheRight) ^ Transposed) ? jp : j).nonZeros());
49  }
50  tmp.reserve(sizes);
51  for(Index j=0; j<mat.outerSize(); ++j)
52  {
53  Index jp = perm.indices().coeff(j);
54  Index jsrc = ((Side==OnTheRight) ^ Transposed) ? jp : j;
55  Index jdst = ((Side==OnTheLeft) ^ Transposed) ? jp : j;
56  for(typename MatrixTypeCleaned::InnerIterator it(mat,jsrc); it; ++it)
57  tmp.insertByOuterInner(jdst,it.index()) = it.value();
58  }
59  dst = tmp;
60  }
61  else
62  {
64  Matrix<StorageIndex,Dynamic,1> sizes(tmp.outerSize());
65  sizes.setZero();
67  if((Side==OnTheLeft) ^ Transposed)
68  perm_cpy = perm;
69  else
70  perm_cpy = perm.transpose();
71 
72  for(Index j=0; j<mat.outerSize(); ++j)
73  for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
74  sizes[perm_cpy.indices().coeff(it.index())]++;
75  tmp.reserve(sizes);
76  for(Index j=0; j<mat.outerSize(); ++j)
77  for(typename MatrixTypeCleaned::InnerIterator it(mat,j); it; ++it)
78  tmp.insertByOuterInner(perm_cpy.indices().coeff(it.index()),j) = it.value();
79  dst = tmp;
80  }
81  }
82 };
83 
84 }
85 
86 namespace internal {
87 
88 template <int ProductTag> struct product_promote_storage_type<Sparse, PermutationStorage, ProductTag> { typedef Sparse ret; };
89 template <int ProductTag> struct product_promote_storage_type<PermutationStorage, Sparse, ProductTag> { typedef Sparse ret; };
90 
91 // TODO, the following two overloads are only needed to define the right temporary type through
92 // typename traits<permutation_sparse_matrix_product<Rhs,Lhs,OnTheRight,false> >::ReturnType
93 // whereas it should be correctly handled by traits<Product<> >::PlainObject
94 
95 template<typename Lhs, typename Rhs, int ProductTag>
97  : public evaluator<typename permutation_matrix_product<Rhs,OnTheLeft,false,SparseShape>::ReturnType>
98 {
102 
103  enum {
104  Flags = Base::Flags | EvalBeforeNestingBit
105  };
106 
107  explicit product_evaluator(const XprType& xpr)
108  : m_result(xpr.rows(), xpr.cols())
109  {
110  ::new (static_cast<Base*>(this)) Base(m_result);
112  }
113 
114 protected:
115  PlainObject m_result;
116 };
117 
118 template<typename Lhs, typename Rhs, int ProductTag>
120  : public evaluator<typename permutation_matrix_product<Lhs,OnTheRight,false,SparseShape>::ReturnType>
121 {
125 
126  enum {
127  Flags = Base::Flags | EvalBeforeNestingBit
128  };
129 
130  explicit product_evaluator(const XprType& xpr)
131  : m_result(xpr.rows(), xpr.cols())
132  {
133  ::new (static_cast<Base*>(this)) Base(m_result);
135  }
136 
137 protected:
138  PlainObject m_result;
139 };
140 
141 } // end namespace internal
142 
145 template<typename SparseDerived, typename PermDerived>
149 
152 template<typename SparseDerived, typename PermDerived>
156 
157 
160 template<typename SparseDerived, typename PermutationType>
163 {
164  return Product<SparseDerived, Inverse<PermutationType>, AliasFreeProduct>(matrix.derived(), tperm.derived());
165 }
166 
169 template<typename SparseDerived, typename PermutationType>
170 inline const Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>
172 {
173  return Product<Inverse<PermutationType>, SparseDerived, AliasFreeProduct>(tperm.derived(), matrix.derived());
174 }
175 
176 } // end namespace Eigen
177 
178 #endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
static void run(Dest &dst, const PermutationType &perm, const ExpressionType &xpr)
SCALAR Scalar
Definition: bench_gemm.cpp:46
Expression of the product of two arbitrary matrices or vectors.
Definition: Product.h:71
A versatible sparse matrix representation.
Definition: SparseMatrix.h:96
internal::conditional< MoveOuter, SparseMatrix< Scalar, SrcStorageOrder, StorageIndex >, SparseMatrix< Scalar, int(SrcStorageOrder)==RowMajor?ColMajor:RowMajor, StorageIndex > >::type ReturnType
std::vector< Array2i > sizes
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
const unsigned int RowMajorBit
Definition: Constants.h:66
Base class for permutations.
Base class of any sparse matrices or sparse expressions.
const IndicesType & indices() const
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
idx_t idx_t idx_t idx_t idx_t * perm
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorUInt128< uint64_t, uint64_t > operator*(const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
InverseReturnType transpose() const
const Derived & derived() const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const LhsNestedCleaned & lhs() const
Definition: Product.h:107
const unsigned int EvalBeforeNestingBit
Definition: Constants.h:70
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: CwiseUnaryOp.h:69
Generic expression where a coefficient-wise unary operator is applied to an expression.
Definition: CwiseUnaryOp.h:55
Map< Matrix< T, Dynamic, Dynamic, ColMajor >, 0, OuterStride<> > matrix(T *data, int rows, int cols, int stride)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const RhsNestedCleaned & rhs() const
Definition: Product.h:109
EIGEN_DEVICE_FUNC Derived & derived()
Definition: EigenBase.h:46
std::ptrdiff_t j
Definition: pytypes.h:1370
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: CwiseUnaryOp.h:71


gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:36:07