SparseSelfAdjointView.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) 2009-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_SELFADJOINTVIEW_H
11 #define EIGEN_SPARSE_SELFADJOINTVIEW_H
12 
13 namespace Eigen {
14 
29 namespace internal {
30 
31 template<typename MatrixType, unsigned int Mode>
32 struct traits<SparseSelfAdjointView<MatrixType,Mode> > : traits<MatrixType> {
33 };
34 
35 template<int SrcMode,int DstMode,typename MatrixType,int DestOrder>
37 
38 template<int Mode,typename MatrixType,int DestOrder>
40 
41 }
42 
43 template<typename MatrixType, unsigned int _Mode> class SparseSelfAdjointView
44  : public EigenBase<SparseSelfAdjointView<MatrixType,_Mode> >
45 {
46  public:
47 
48  enum {
49  Mode = _Mode,
50  TransposeMode = ((Mode & Upper) ? Lower : 0) | ((Mode & Lower) ? Upper : 0),
53  };
54 
56  typedef typename MatrixType::Scalar Scalar;
57  typedef typename MatrixType::StorageIndex StorageIndex;
61 
62  explicit inline SparseSelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
63  {
64  eigen_assert(rows()==cols() && "SelfAdjointView is only for squared matrices");
65  }
66 
67  inline Index rows() const { return m_matrix.rows(); }
68  inline Index cols() const { return m_matrix.cols(); }
69 
71  const _MatrixTypeNested& matrix() const { return m_matrix; }
73 
79  template<typename OtherDerived>
82  {
84  }
85 
91  template<typename OtherDerived> friend
94  {
96  }
97 
99  template<typename OtherDerived>
102  {
103  return Product<SparseSelfAdjointView,OtherDerived>(*this, rhs.derived());
104  }
105 
107  template<typename OtherDerived> friend
110  {
111  return Product<OtherDerived,SparseSelfAdjointView>(lhs.derived(), rhs);
112  }
113 
122  template<typename DerivedU>
123  SparseSelfAdjointView& rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));
124 
126  // TODO implement twists in a more evaluator friendly fashion
128  {
130  }
131 
132  template<typename SrcMatrixType,int SrcMode>
134  {
136  return *this;
137  }
138 
140  {
142  return *this = src.twistedBy(pnull);
143  }
144 
145  template<typename SrcMatrixType,unsigned int SrcMode>
147  {
149  return *this = src.twistedBy(pnull);
150  }
151 
153  {
156  eigen_assert(rows == this->rows() && cols == this->cols()
157  && "SparseSelfadjointView::resize() does not actually allow to resize.");
158  }
159 
160  protected:
161 
162  MatrixTypeNested m_matrix;
163  //mutable VectorI m_countPerRow;
164  //mutable VectorI m_countPerCol;
165  private:
166  template<typename Dest> void evalTo(Dest &) const;
167 };
168 
169 /***************************************************************************
170 * Implementation of SparseMatrixBase methods
171 ***************************************************************************/
172 
173 template<typename Derived>
174 template<unsigned int UpLo>
176 {
178 }
179 
180 template<typename Derived>
181 template<unsigned int UpLo>
183 {
184  return SparseSelfAdjointView<Derived, UpLo>(derived());
185 }
186 
187 /***************************************************************************
188 * Implementation of SparseSelfAdjointView methods
189 ***************************************************************************/
190 
191 template<typename MatrixType, unsigned int Mode>
192 template<typename DerivedU>
195 {
197  if(alpha==Scalar(0))
198  m_matrix = tmp.template triangularView<Mode>();
199  else
200  m_matrix += alpha * tmp.template triangularView<Mode>();
201 
202  return *this;
203 }
204 
205 namespace internal {
206 
207 // TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
208 // in the future selfadjoint-ness should be defined by the expression traits
209 // such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
210 template<typename MatrixType, unsigned int Mode>
212 {
215 };
216 
218 
221 
222 template< typename DstXprType, typename SrcXprType, typename Functor>
223 struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse>
224 {
225  typedef typename DstXprType::StorageIndex StorageIndex;
227 
228  template<typename DestScalar,int StorageOrder>
229  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignOpType&/*func*/)
230  {
231  internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
232  }
233 
234  // FIXME: the handling of += and -= in sparse matrices should be cleanup so that next two overloads could be reduced to:
235  template<typename DestScalar,int StorageOrder,typename AssignFunc>
236  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src, const AssignFunc& func)
237  {
238  SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
239  run(tmp, src, AssignOpType());
241  }
242 
243  template<typename DestScalar,int StorageOrder>
244  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
246  {
247  SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
248  run(tmp, src, AssignOpType());
249  dst += tmp;
250  }
251 
252  template<typename DestScalar,int StorageOrder>
253  static void run(SparseMatrix<DestScalar,StorageOrder,StorageIndex> &dst, const SrcXprType &src,
255  {
256  SparseMatrix<DestScalar,StorageOrder,StorageIndex> tmp(src.rows(),src.cols());
257  run(tmp, src, AssignOpType());
258  dst -= tmp;
259  }
260 
261  template<typename DestScalar>
262  static void run(DynamicSparseMatrix<DestScalar,ColMajor,StorageIndex>& dst, const SrcXprType &src, const AssignOpType&/*func*/)
263  {
264  // TODO directly evaluate into dst;
266  internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), tmp);
267  dst = tmp;
268  }
269 };
270 
271 } // end namespace internal
272 
273 /***************************************************************************
274 * Implementation of sparse self-adjoint time dense matrix
275 ***************************************************************************/
276 
277 namespace internal {
278 
279 template<int Mode, typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
280 inline void sparse_selfadjoint_time_dense_product(const SparseLhsType& lhs, const DenseRhsType& rhs, DenseResType& res, const AlphaType& alpha)
281 {
283 
285  typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
287  typedef typename LhsEval::InnerIterator LhsIterator;
288  typedef typename SparseLhsType::Scalar LhsScalar;
289 
290  enum {
291  LhsIsRowMajor = (LhsEval::Flags&RowMajorBit)==RowMajorBit,
292  ProcessFirstHalf =
293  ((Mode&(Upper|Lower))==(Upper|Lower))
294  || ( (Mode&Upper) && !LhsIsRowMajor)
295  || ( (Mode&Lower) && LhsIsRowMajor),
296  ProcessSecondHalf = !ProcessFirstHalf
297  };
298 
299  SparseLhsTypeNested lhs_nested(lhs);
300  LhsEval lhsEval(lhs_nested);
301 
302  // work on one column at once
303  for (Index k=0; k<rhs.cols(); ++k)
304  {
305  for (Index j=0; j<lhs.outerSize(); ++j)
306  {
307  LhsIterator i(lhsEval,j);
308  // handle diagonal coeff
309  if (ProcessSecondHalf)
310  {
311  while (i && i.index()<j) ++i;
312  if(i && i.index()==j)
313  {
314  res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
315  ++i;
316  }
317  }
318 
319  // premultiplied rhs for scatters
321  // accumulator for partial scalar product
322  typename DenseResType::Scalar res_j(0);
323  for(; (ProcessFirstHalf ? i && i.index() < j : i) ; ++i)
324  {
325  LhsScalar lhs_ij = i.value();
326  if(!LhsIsRowMajor) lhs_ij = numext::conj(lhs_ij);
327  res_j += lhs_ij * rhs.coeff(i.index(),k);
328  res(i.index(),k) += numext::conj(lhs_ij) * rhs_j;
329  }
330  res.coeffRef(j,k) += alpha * res_j;
331 
332  // handle diagonal coeff
333  if (ProcessFirstHalf && i && (i.index()==j))
334  res.coeffRef(j,k) += alpha * i.value() * rhs.coeff(j,k);
335  }
336  }
337 }
338 
339 
340 template<typename LhsView, typename Rhs, int ProductType>
342 : generic_product_impl_base<LhsView, Rhs, generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType> >
343 {
344  template<typename Dest>
345  static void scaleAndAddTo(Dest& dst, const LhsView& lhsView, const Rhs& rhs, const typename Dest::Scalar& alpha)
346  {
347  typedef typename LhsView::_MatrixTypeNested Lhs;
348  typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
349  typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
350  LhsNested lhsNested(lhsView.matrix());
351  RhsNested rhsNested(rhs);
352 
353  internal::sparse_selfadjoint_time_dense_product<LhsView::Mode>(lhsNested, rhsNested, dst, alpha);
354  }
355 };
356 
357 template<typename Lhs, typename RhsView, int ProductType>
359 : generic_product_impl_base<Lhs, RhsView, generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType> >
360 {
361  template<typename Dest>
362  static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const RhsView& rhsView, const typename Dest::Scalar& alpha)
363  {
364  typedef typename RhsView::_MatrixTypeNested Rhs;
365  typedef typename nested_eval<Lhs,Dynamic>::type LhsNested;
366  typedef typename nested_eval<Rhs,Dynamic>::type RhsNested;
367  LhsNested lhsNested(lhs);
368  RhsNested rhsNested(rhsView.matrix());
369 
370  // transpose everything
371  Transpose<Dest> dstT(dst);
372  internal::sparse_selfadjoint_time_dense_product<RhsView::TransposeMode>(rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
373  }
374 };
375 
376 // NOTE: these two overloads are needed to evaluate the sparse selfadjoint view into a full sparse matrix
377 // TODO: maybe the copy could be handled by generic_product_impl so that these overloads would not be needed anymore
378 
379 template<typename LhsView, typename Rhs, int ProductTag>
381  : public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject>
382 {
384  typedef typename XprType::PlainObject PlainObject;
386 
387  product_evaluator(const XprType& xpr)
388  : m_lhs(xpr.lhs()), m_result(xpr.rows(), xpr.cols())
389  {
390  ::new (static_cast<Base*>(this)) Base(m_result);
392  }
393 
394 protected:
395  typename Rhs::PlainObject m_lhs;
396  PlainObject m_result;
397 };
398 
399 template<typename Lhs, typename RhsView, int ProductTag>
401  : public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject>
402 {
404  typedef typename XprType::PlainObject PlainObject;
406 
407  product_evaluator(const XprType& xpr)
408  : m_rhs(xpr.rhs()), m_result(xpr.rows(), xpr.cols())
409  {
410  ::new (static_cast<Base*>(this)) Base(m_result);
412  }
413 
414 protected:
415  typename Lhs::PlainObject m_rhs;
416  PlainObject m_result;
417 };
418 
419 } // namespace internal
420 
421 /***************************************************************************
422 * Implementation of symmetric copies and permutations
423 ***************************************************************************/
424 namespace internal {
425 
426 template<int Mode,typename MatrixType,int DestOrder>
428 {
429  typedef typename MatrixType::StorageIndex StorageIndex;
430  typedef typename MatrixType::Scalar Scalar;
432  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
433  typedef evaluator<MatrixType> MatEval;
434  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
435 
436  MatEval matEval(mat);
437  Dest& dest(_dest.derived());
438  enum {
439  StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
440  };
441 
442  Index size = mat.rows();
443  VectorI count;
444  count.resize(size);
445  count.setZero();
446  dest.resize(size,size);
447  for(Index j = 0; j<size; ++j)
448  {
449  Index jp = perm ? perm[j] : j;
450  for(MatIterator it(matEval,j); it; ++it)
451  {
452  Index i = it.index();
453  Index r = it.row();
454  Index c = it.col();
455  Index ip = perm ? perm[i] : i;
456  if(Mode==(Upper|Lower))
457  count[StorageOrderMatch ? jp : ip]++;
458  else if(r==c)
459  count[ip]++;
460  else if(( Mode==Lower && r>c) || ( Mode==Upper && r<c))
461  {
462  count[ip]++;
463  count[jp]++;
464  }
465  }
466  }
467  Index nnz = count.sum();
468 
469  // reserve space
470  dest.resizeNonZeros(nnz);
471  dest.outerIndexPtr()[0] = 0;
472  for(Index j=0; j<size; ++j)
473  dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
474  for(Index j=0; j<size; ++j)
475  count[j] = dest.outerIndexPtr()[j];
476 
477  // copy data
478  for(StorageIndex j = 0; j<size; ++j)
479  {
480  for(MatIterator it(matEval,j); it; ++it)
481  {
482  StorageIndex i = internal::convert_index<StorageIndex>(it.index());
483  Index r = it.row();
484  Index c = it.col();
485 
486  StorageIndex jp = perm ? perm[j] : j;
487  StorageIndex ip = perm ? perm[i] : i;
488 
489  if(Mode==(Upper|Lower))
490  {
491  Index k = count[StorageOrderMatch ? jp : ip]++;
492  dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
493  dest.valuePtr()[k] = it.value();
494  }
495  else if(r==c)
496  {
497  Index k = count[ip]++;
498  dest.innerIndexPtr()[k] = ip;
499  dest.valuePtr()[k] = it.value();
500  }
501  else if(( (Mode&Lower)==Lower && r>c) || ( (Mode&Upper)==Upper && r<c))
502  {
503  if(!StorageOrderMatch)
504  std::swap(ip,jp);
505  Index k = count[jp]++;
506  dest.innerIndexPtr()[k] = ip;
507  dest.valuePtr()[k] = it.value();
508  k = count[ip]++;
509  dest.innerIndexPtr()[k] = jp;
510  dest.valuePtr()[k] = numext::conj(it.value());
511  }
512  }
513  }
514 }
515 
516 template<int _SrcMode,int _DstMode,typename MatrixType,int DstOrder>
518 {
519  typedef typename MatrixType::StorageIndex StorageIndex;
520  typedef typename MatrixType::Scalar Scalar;
522  typedef Matrix<StorageIndex,Dynamic,1> VectorI;
523  typedef evaluator<MatrixType> MatEval;
524  typedef typename evaluator<MatrixType>::InnerIterator MatIterator;
525 
526  enum {
527  SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
528  StorageOrderMatch = int(SrcOrder) == int(DstOrder),
529  DstMode = DstOrder==RowMajor ? (_DstMode==Upper ? Lower : Upper) : _DstMode,
530  SrcMode = SrcOrder==RowMajor ? (_SrcMode==Upper ? Lower : Upper) : _SrcMode
531  };
532 
533  MatEval matEval(mat);
534 
535  Index size = mat.rows();
536  VectorI count(size);
537  count.setZero();
538  dest.resize(size,size);
539  for(StorageIndex j = 0; j<size; ++j)
540  {
541  StorageIndex jp = perm ? perm[j] : j;
542  for(MatIterator it(matEval,j); it; ++it)
543  {
544  StorageIndex i = it.index();
545  if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
546  continue;
547 
548  StorageIndex ip = perm ? perm[i] : i;
549  count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
550  }
551  }
552  dest.outerIndexPtr()[0] = 0;
553  for(Index j=0; j<size; ++j)
554  dest.outerIndexPtr()[j+1] = dest.outerIndexPtr()[j] + count[j];
555  dest.resizeNonZeros(dest.outerIndexPtr()[size]);
556  for(Index j=0; j<size; ++j)
557  count[j] = dest.outerIndexPtr()[j];
558 
559  for(StorageIndex j = 0; j<size; ++j)
560  {
561 
562  for(MatIterator it(matEval,j); it; ++it)
563  {
564  StorageIndex i = it.index();
565  if((int(SrcMode)==int(Lower) && i<j) || (int(SrcMode)==int(Upper) && i>j))
566  continue;
567 
568  StorageIndex jp = perm ? perm[j] : j;
569  StorageIndex ip = perm? perm[i] : i;
570 
571  Index k = count[int(DstMode)==int(Lower) ? (std::min)(ip,jp) : (std::max)(ip,jp)]++;
572  dest.innerIndexPtr()[k] = int(DstMode)==int(Lower) ? (std::max)(ip,jp) : (std::min)(ip,jp);
573 
574  if(!StorageOrderMatch) std::swap(ip,jp);
575  if( ((int(DstMode)==int(Lower) && ip<jp) || (int(DstMode)==int(Upper) && ip>jp)))
576  dest.valuePtr()[k] = numext::conj(it.value());
577  else
578  dest.valuePtr()[k] = it.value();
579  }
580  }
581 }
582 
583 }
584 
585 // TODO implement twists in a more evaluator friendly fashion
586 
587 namespace internal {
588 
589 template<typename MatrixType, int Mode>
591 };
592 
593 }
594 
595 template<typename MatrixType,int Mode>
597  : public EigenBase<SparseSymmetricPermutationProduct<MatrixType,Mode> >
598 {
599  public:
600  typedef typename MatrixType::Scalar Scalar;
601  typedef typename MatrixType::StorageIndex StorageIndex;
602  enum {
605  };
606  protected:
608  public:
610  typedef typename MatrixType::Nested MatrixTypeNested;
612 
614  : m_matrix(mat), m_perm(perm)
615  {}
616 
617  inline Index rows() const { return m_matrix.rows(); }
618  inline Index cols() const { return m_matrix.cols(); }
619 
620  const NestedExpression& matrix() const { return m_matrix; }
621  const Perm& perm() const { return m_perm; }
622 
623  protected:
624  MatrixTypeNested m_matrix;
625  const Perm& m_perm;
626 
627 };
628 
629 namespace internal {
630 
631 template<typename DstXprType, typename MatrixType, int Mode, typename Scalar>
632 struct Assignment<DstXprType, SparseSymmetricPermutationProduct<MatrixType,Mode>, internal::assign_op<Scalar,typename MatrixType::Scalar>, Sparse2Sparse>
633 {
635  typedef typename DstXprType::StorageIndex DstIndex;
636  template<int Options>
638  {
639  // internal::permute_symm_to_fullsymm<Mode>(m_matrix,_dest,m_perm.indices().data());
641  internal::permute_symm_to_fullsymm<Mode>(src.matrix(),tmp,src.perm().indices().data());
642  dst = tmp;
643  }
644 
645  template<typename DestType,unsigned int DestMode>
647  {
648  internal::permute_symm_to_symm<Mode,DestMode>(src.matrix(),dst.matrix(),src.perm().indices().data());
649  }
650 };
651 
652 } // end namespace internal
653 
654 } // end namespace Eigen
655 
656 #endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
ConstSelfAdjointViewReturnType< UpLo >::Type selfadjointView() const
Product< SparseSelfAdjointView, OtherDerived > operator*(const SparseMatrixBase< OtherDerived > &rhs) const
SCALAR Scalar
Definition: bench_gemm.cpp:33
#define max(a, b)
Definition: datatypes.h:20
EigenBase< SparseSelfAdjointView > Base
const AdjointReturnType adjoint() const
Expression of the product of two arbitrary matrices or vectors.
Definition: Product.h:71
return int(ret)+1
SparseSelfAdjointView(MatrixType &matrix)
A versatible sparse matrix representation.
Definition: SparseMatrix.h:96
#define min(a, b)
Definition: datatypes.h:19
PermutationMatrix< Dynamic, Dynamic, StorageIndex > Perm
static void run(SparseMatrix< DestScalar, StorageOrder, StorageIndex > &dst, const SrcXprType &src, const AssignFunc &func)
Expression of the transpose of a matrix.
Definition: Transpose.h:52
friend Product< OtherDerived, SparseSelfAdjointView > operator*(const SparseMatrixBase< OtherDerived > &lhs, const SparseSelfAdjointView &rhs)
friend Product< OtherDerived, SparseSelfAdjointView > operator*(const MatrixBase< OtherDerived > &lhs, const SparseSelfAdjointView &rhs)
static void run(SparseSelfAdjointView< DestType, DestMode > &dst, const SrcXprType &src, const internal::assign_op< Scalar, typename MatrixType::Scalar > &)
SparseSymmetricPermutationProduct(const MatrixType &mat, const Perm &perm)
Scalar Scalar * c
Definition: benchVecAdd.cpp:17
internal::remove_reference< MatrixTypeNested >::type & matrix()
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
Matrix< StorageIndex, Dynamic, 1 > VectorI
MatrixXf MatrixType
void sparse_selfadjoint_time_dense_product(const SparseLhsType &lhs, const DenseRhsType &rhs, DenseResType &res, const AlphaType &alpha)
internal::remove_all< MatrixTypeNested >::type _MatrixTypeNested
static void scaleAndAddTo(Dest &dst, const Lhs &lhs, const RhsView &rhsView, const typename Dest::Scalar &alpha)
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:38
static void scaleAndAddTo(Dest &dst, const LhsView &lhsView, const Rhs &rhs, const typename Dest::Scalar &alpha)
const unsigned int RowMajorBit
Definition: Constants.h:61
EIGEN_DEVICE_FUNC const LhsNestedCleaned & lhs() const
Definition: Product.h:103
cout<< "Here is the matrix m:"<< endl<< m<< endl;Matrix< ptrdiff_t, 3, 1 > res
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
SparseSelfAdjointView & operator=(const SparseSelfAdjointView &src)
Base class of any sparse matrices or sparse expressions.
Product< SparseSelfAdjointView, OtherDerived > operator*(const MatrixBase< OtherDerived > &rhs) const
storage_kind_to_evaluator_kind< typename MatrixType::StorageKind >::Kind Kind
static void run(SparseMatrix< Scalar, Options, DstIndex > &dst, const SrcXprType &src, const internal::assign_op< Scalar, typename MatrixType::Scalar > &)
SparseSelfAdjointView & operator=(const SparseSymmetricPermutationProduct< SrcMatrixType, SrcMode > &permutedMatrix)
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
#define eigen_assert(x)
Definition: Macros.h:579
idx_t idx_t idx_t idx_t idx_t * perm
RealScalar alpha
A sparse matrix class designed for matrix assembly purpose.
Definition: SparseUtil.h:53
void permute_symm_to_symm(const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm=0)
internal::ref_selector< MatrixType >::non_const_type MatrixTypeNested
void permute_symm_to_fullsymm(const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm=0)
static void run(SparseMatrix< DestScalar, StorageOrder, StorageIndex > &dst, const SrcXprType &src, const AssignOpType &)
static void run(SparseMatrix< DestScalar, StorageOrder, StorageIndex > &dst, const SrcXprType &src, const internal::add_assign_op< typename DstXprType::Scalar, typename SrcXprType::Scalar > &)
SparseSelfAdjointView & rankUpdate(const SparseMatrixBase< DerivedU > &u, const Scalar &alpha=Scalar(1))
MatrixType::StorageIndex StorageIndex
static void run(DynamicSparseMatrix< DestScalar, ColMajor, StorageIndex > &dst, const SrcXprType &src, const AssignOpType &)
static void run(SparseMatrix< DestScalar, StorageOrder, StorageIndex > &dst, const SrcXprType &src, const internal::sub_assign_op< typename DstXprType::Scalar, typename SrcXprType::Scalar > &)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_assignment_no_alias_no_transpose(Dst &dst, const Src &src, const Func &func)
const Derived & derived() const
const IndicesType & indices() const
const _MatrixTypeNested & matrix() const
Matrix< StorageIndex, Dynamic, 1 > VectorI
internal::assign_op< typename DstXprType::Scalar, typename SrcXprType::Scalar > AssignOpType
SparseSelfAdjointView & operator=(const SparseSelfAdjointView< SrcMatrixType, SrcMode > &src)
Determines whether the given binary operation of two numeric types is allowed and what the scalar ret...
Definition: XprHelper.h:766
internal::remove_all< MatrixTypeNested >::type NestedExpression
Map< Matrix< T, Dynamic, Dynamic, ColMajor >, 0, OuterStride<> > matrix(T *data, int rows, int cols, int stride)
SparseSymmetricPermutationProduct< _MatrixTypeNested, Mode > twistedBy(const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm) const
void run(Expr &expr, Dev &dev)
Definition: TensorSyclRun.h:33
const NestedExpression & matrix() const
EIGEN_DEVICE_FUNC const RhsNestedCleaned & rhs() const
Definition: Product.h:104
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:48
void swap(mpfr::mpreal &x, mpfr::mpreal &y)
Definition: mpreal.h:2986
std::ptrdiff_t j
ScalarWithExceptions conj(const ScalarWithExceptions &x)
Definition: exceptions.cpp:74
void resize(Index rows, Index cols)
#define EIGEN_ONLY_USED_FOR_DEBUG(x)
Definition: Macros.h:591


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:44:38