Eigen  3.4.90 (git rev a4098ac676528a83cfb73d4d26ce1b42ec05f47c)
CholmodSupport.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2008-2010 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_CHOLMODSUPPORT_H
11#define EIGEN_CHOLMODSUPPORT_H
12
13#include "./InternalHeaderCheck.h"
14
15namespace Eigen {
16
17namespace internal {
18
19template<typename Scalar> struct cholmod_configure_matrix;
20
21template<> struct cholmod_configure_matrix<double> {
22 template<typename CholmodType>
23 static void run(CholmodType& mat) {
24 mat.xtype = CHOLMOD_REAL;
25 mat.dtype = CHOLMOD_DOUBLE;
26 }
27};
28
29template<> struct cholmod_configure_matrix<std::complex<double> > {
30 template<typename CholmodType>
31 static void run(CholmodType& mat) {
32 mat.xtype = CHOLMOD_COMPLEX;
33 mat.dtype = CHOLMOD_DOUBLE;
34 }
35};
36
37// Other scalar types are not yet supported by Cholmod
38// template<> struct cholmod_configure_matrix<float> {
39// template<typename CholmodType>
40// static void run(CholmodType& mat) {
41// mat.xtype = CHOLMOD_REAL;
42// mat.dtype = CHOLMOD_SINGLE;
43// }
44// };
45//
46// template<> struct cholmod_configure_matrix<std::complex<float> > {
47// template<typename CholmodType>
48// static void run(CholmodType& mat) {
49// mat.xtype = CHOLMOD_COMPLEX;
50// mat.dtype = CHOLMOD_SINGLE;
51// }
52// };
53
54} // namespace internal
55
59template<typename Scalar_, int Options_, typename StorageIndex_>
61{
62 cholmod_sparse res;
63 res.nzmax = mat.nonZeros();
64 res.nrow = mat.rows();
65 res.ncol = mat.cols();
66 res.p = mat.outerIndexPtr();
67 res.i = mat.innerIndexPtr();
68 res.x = mat.valuePtr();
69 res.z = 0;
70 res.sorted = 1;
71 if(mat.isCompressed())
72 {
73 res.packed = 1;
74 res.nz = 0;
75 }
76 else
77 {
78 res.packed = 0;
79 res.nz = mat.innerNonZeroPtr();
80 }
81
82 res.dtype = 0;
83 res.stype = -1;
84
85 if (internal::is_same<StorageIndex_,int>::value)
86 {
87 res.itype = CHOLMOD_INT;
88 }
89 else if (internal::is_same<StorageIndex_,SuiteSparse_long>::value)
90 {
91 res.itype = CHOLMOD_LONG;
92 }
93 else
94 {
95 eigen_assert(false && "Index type not supported yet");
96 }
97
98 // setup res.xtype
99 internal::cholmod_configure_matrix<Scalar_>::run(res);
100
101 res.stype = 0;
102
103 return res;
104}
105
106template<typename Scalar_, int Options_, typename Index_>
107const cholmod_sparse viewAsCholmod(const SparseMatrix<Scalar_,Options_,Index_>& mat)
108{
109 cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<Scalar_,Options_,Index_> >(mat.const_cast_derived()));
110 return res;
111}
112
113template<typename Scalar_, int Options_, typename Index_>
114const cholmod_sparse viewAsCholmod(const SparseVector<Scalar_,Options_,Index_>& mat)
115{
116 cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<Scalar_,Options_,Index_> >(mat.const_cast_derived()));
117 return res;
118}
119
122template<typename Scalar_, int Options_, typename Index_, unsigned int UpLo>
124{
125 cholmod_sparse res = viewAsCholmod(Ref<SparseMatrix<Scalar_,Options_,Index_> >(mat.matrix().const_cast_derived()));
126
127 if(UpLo==Upper) res.stype = 1;
128 if(UpLo==Lower) res.stype = -1;
129 // swap stype for rowmajor matrices (only works for real matrices)
130 EIGEN_STATIC_ASSERT((Options_ & RowMajorBit) == 0 || NumTraits<Scalar_>::IsComplex == 0, THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
131 if(Options_ & RowMajorBit) res.stype *=-1;
132
133 return res;
134}
135
138template<typename Derived>
140{
141 EIGEN_STATIC_ASSERT((internal::traits<Derived>::Flags&RowMajorBit)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
142 typedef typename Derived::Scalar Scalar;
143
144 cholmod_dense res;
145 res.nrow = mat.rows();
146 res.ncol = mat.cols();
147 res.nzmax = res.nrow * res.ncol;
148 res.d = Derived::IsVectorAtCompileTime ? mat.derived().size() : mat.derived().outerStride();
149 res.x = (void*)(mat.derived().data());
150 res.z = 0;
151
152 internal::cholmod_configure_matrix<Scalar>::run(res);
153
154 return res;
155}
156
159template<typename Scalar, int Flags, typename StorageIndex>
161{
163 (cm.nrow, cm.ncol, static_cast<StorageIndex*>(cm.p)[cm.ncol],
164 static_cast<StorageIndex*>(cm.p), static_cast<StorageIndex*>(cm.i),static_cast<Scalar*>(cm.x) );
165}
166
167namespace internal {
168
169// template specializations for int and long that call the correct cholmod method
170
171#define EIGEN_CHOLMOD_SPECIALIZE0(ret, name) \
172 template<typename StorageIndex_> inline ret cm_ ## name (cholmod_common &Common) { return cholmod_ ## name (&Common); } \
173 template<> inline ret cm_ ## name<SuiteSparse_long> (cholmod_common &Common) { return cholmod_l_ ## name (&Common); }
174
175#define EIGEN_CHOLMOD_SPECIALIZE1(ret, name, t1, a1) \
176 template<typename StorageIndex_> inline ret cm_ ## name (t1& a1, cholmod_common &Common) { return cholmod_ ## name (&a1, &Common); } \
177 template<> inline ret cm_ ## name<SuiteSparse_long> (t1& a1, cholmod_common &Common) { return cholmod_l_ ## name (&a1, &Common); }
178
179EIGEN_CHOLMOD_SPECIALIZE0(int, start)
180EIGEN_CHOLMOD_SPECIALIZE0(int, finish)
181
182EIGEN_CHOLMOD_SPECIALIZE1(int, free_factor, cholmod_factor*, L)
183EIGEN_CHOLMOD_SPECIALIZE1(int, free_dense, cholmod_dense*, X)
184EIGEN_CHOLMOD_SPECIALIZE1(int, free_sparse, cholmod_sparse*, A)
185
186EIGEN_CHOLMOD_SPECIALIZE1(cholmod_factor*, analyze, cholmod_sparse, A)
187
188template<typename StorageIndex_> inline cholmod_dense* cm_solve (int sys, cholmod_factor& L, cholmod_dense& B, cholmod_common &Common) { return cholmod_solve (sys, &L, &B, &Common); }
189template<> inline cholmod_dense* cm_solve<SuiteSparse_long> (int sys, cholmod_factor& L, cholmod_dense& B, cholmod_common &Common) { return cholmod_l_solve (sys, &L, &B, &Common); }
190
191template<typename StorageIndex_> inline cholmod_sparse* cm_spsolve (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_spsolve (sys, &L, &B, &Common); }
192template<> inline cholmod_sparse* cm_spsolve<SuiteSparse_long> (int sys, cholmod_factor& L, cholmod_sparse& B, cholmod_common &Common) { return cholmod_l_spsolve (sys, &L, &B, &Common); }
193
194template<typename StorageIndex_>
195inline int cm_factorize_p (cholmod_sparse* A, double beta[2], StorageIndex_* fset, std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_factorize_p (A, beta, fset, fsize, L, &Common); }
196template<>
197inline int cm_factorize_p<SuiteSparse_long> (cholmod_sparse* A, double beta[2], SuiteSparse_long* fset, std::size_t fsize, cholmod_factor* L, cholmod_common &Common) { return cholmod_l_factorize_p (A, beta, fset, fsize, L, &Common); }
198
199#undef EIGEN_CHOLMOD_SPECIALIZE0
200#undef EIGEN_CHOLMOD_SPECIALIZE1
201
202} // namespace internal
203
204
205enum CholmodMode {
206 CholmodAuto, CholmodSimplicialLLt, CholmodSupernodalLLt, CholmodLDLt
207};
208
209
215template<typename MatrixType_, int UpLo_, typename Derived>
216class CholmodBase : public SparseSolverBase<Derived>
217{
218 protected:
220 using Base::derived;
221 using Base::m_isInitialized;
222 public:
223 typedef MatrixType_ MatrixType;
224 enum { UpLo = UpLo_ };
225 typedef typename MatrixType::Scalar Scalar;
226 typedef typename MatrixType::RealScalar RealScalar;
227 typedef MatrixType CholMatrixType;
228 typedef typename MatrixType::StorageIndex StorageIndex;
229 enum {
230 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
231 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
232 };
233
234 public:
235
237 : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
238 {
239 EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
240 m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
241 internal::cm_start<StorageIndex>(m_cholmod);
242 }
243
244 explicit CholmodBase(const MatrixType& matrix)
245 : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false)
246 {
247 EIGEN_STATIC_ASSERT((internal::is_same<double,RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
248 m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
249 internal::cm_start<StorageIndex>(m_cholmod);
250 compute(matrix);
251 }
252
254 {
255 if(m_cholmodFactor)
256 internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
257 internal::cm_finish<StorageIndex>(m_cholmod);
258 }
259
260 inline StorageIndex cols() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
261 inline StorageIndex rows() const { return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }
262
269 {
270 eigen_assert(m_isInitialized && "Decomposition is not initialized.");
271 return m_info;
272 }
273
275 Derived& compute(const MatrixType& matrix)
276 {
277 analyzePattern(matrix);
278 factorize(matrix);
279 return derived();
280 }
281
288 void analyzePattern(const MatrixType& matrix)
289 {
290 if(m_cholmodFactor)
291 {
292 internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
293 m_cholmodFactor = 0;
294 }
295 cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
296 m_cholmodFactor = internal::cm_analyze<StorageIndex>(A, m_cholmod);
297
298 this->m_isInitialized = true;
299 this->m_info = Success;
300 m_analysisIsOk = true;
301 m_factorizationIsOk = false;
302 }
303
310 void factorize(const MatrixType& matrix)
311 {
312 eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
313 cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
314 internal::cm_factorize_p<StorageIndex>(&A, m_shiftOffset, 0, 0, m_cholmodFactor, m_cholmod);
315
316 // If the factorization failed, minor is the column at which it did. On success minor == n.
317 this->m_info = (m_cholmodFactor->minor == m_cholmodFactor->n ? Success : NumericalIssue);
318 m_factorizationIsOk = true;
319 }
320
323 cholmod_common& cholmod() { return m_cholmod; }
324
325 #ifndef EIGEN_PARSED_BY_DOXYGEN
327 template<typename Rhs,typename Dest>
328 void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const
329 {
330 eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
331 const Index size = m_cholmodFactor->n;
332 EIGEN_UNUSED_VARIABLE(size);
333 eigen_assert(size==b.rows());
334
335 // Cholmod needs column-major storage without inner-stride, which corresponds to the default behavior of Ref.
337
338 cholmod_dense b_cd = viewAsCholmod(b_ref);
339 cholmod_dense* x_cd = internal::cm_solve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cd, m_cholmod);
340 if(!x_cd)
341 {
342 this->m_info = NumericalIssue;
343 return;
344 }
345 // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
346 // NOTE Actually, the copy can be avoided by calling cholmod_solve2 instead of cholmod_solve
347 dest = Matrix<Scalar,Dest::RowsAtCompileTime,Dest::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x),b.rows(),b.cols());
348 internal::cm_free_dense<StorageIndex>(x_cd, m_cholmod);
349 }
350
352 template<typename RhsDerived, typename DestDerived>
353 void _solve_impl(const SparseMatrixBase<RhsDerived> &b, SparseMatrixBase<DestDerived> &dest) const
354 {
355 eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
356 const Index size = m_cholmodFactor->n;
357 EIGEN_UNUSED_VARIABLE(size);
358 eigen_assert(size==b.rows());
359
360 // note: cs stands for Cholmod Sparse
361 Ref<SparseMatrix<typename RhsDerived::Scalar,ColMajor,typename RhsDerived::StorageIndex> > b_ref(b.const_cast_derived());
362 cholmod_sparse b_cs = viewAsCholmod(b_ref);
363 cholmod_sparse* x_cs = internal::cm_spsolve<StorageIndex>(CHOLMOD_A, *m_cholmodFactor, b_cs, m_cholmod);
364 if(!x_cs)
365 {
366 this->m_info = NumericalIssue;
367 return;
368 }
369 // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
370 // NOTE cholmod_spsolve in fact just calls the dense solver for blocks of 4 columns at a time (similar to Eigen's sparse solver)
371 dest.derived() = viewAsEigen<typename DestDerived::Scalar,ColMajor,typename DestDerived::StorageIndex>(*x_cs);
372 internal::cm_free_sparse<StorageIndex>(x_cs, m_cholmod);
373 }
374 #endif // EIGEN_PARSED_BY_DOXYGEN
375
376
386 Derived& setShift(const RealScalar& offset)
387 {
388 m_shiftOffset[0] = double(offset);
389 return derived();
390 }
391
393 Scalar determinant() const
394 {
395 using std::exp;
396 return exp(logDeterminant());
397 }
398
400 Scalar logDeterminant() const
401 {
402 using std::log;
403 using numext::real;
404 eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
405
406 RealScalar logDet = 0;
407 Scalar *x = static_cast<Scalar*>(m_cholmodFactor->x);
408 if (m_cholmodFactor->is_super)
409 {
410 // Supernodal factorization stored as a packed list of dense column-major blocs,
411 // as described by the following structure:
412
413 // super[k] == index of the first column of the j-th super node
414 StorageIndex *super = static_cast<StorageIndex*>(m_cholmodFactor->super);
415 // pi[k] == offset to the description of row indices
416 StorageIndex *pi = static_cast<StorageIndex*>(m_cholmodFactor->pi);
417 // px[k] == offset to the respective dense block
418 StorageIndex *px = static_cast<StorageIndex*>(m_cholmodFactor->px);
419
420 Index nb_super_nodes = m_cholmodFactor->nsuper;
421 for (Index k=0; k < nb_super_nodes; ++k)
422 {
423 StorageIndex ncols = super[k + 1] - super[k];
424 StorageIndex nrows = pi[k + 1] - pi[k];
425
426 Map<const Array<Scalar,1,Dynamic>, 0, InnerStride<> > sk(x + px[k], ncols, InnerStride<>(nrows+1));
427 logDet += sk.real().log().sum();
428 }
429 }
430 else
431 {
432 // Simplicial factorization stored as standard CSC matrix.
433 StorageIndex *p = static_cast<StorageIndex*>(m_cholmodFactor->p);
434 Index size = m_cholmodFactor->n;
435 for (Index k=0; k<size; ++k)
436 logDet += log(real( x[p[k]] ));
437 }
438 if (m_cholmodFactor->is_ll)
439 logDet *= 2.0;
440 return logDet;
441 }
442
443 template<typename Stream>
444 void dumpMemory(Stream& /*s*/)
445 {}
446
447 protected:
448 mutable cholmod_common m_cholmod;
449 cholmod_factor* m_cholmodFactor;
450 double m_shiftOffset[2];
451 mutable ComputationInfo m_info;
452 int m_factorizationIsOk;
453 int m_analysisIsOk;
454};
455
478template<typename MatrixType_, int UpLo_ = Lower>
479class CholmodSimplicialLLT : public CholmodBase<MatrixType_, UpLo_, CholmodSimplicialLLT<MatrixType_, UpLo_> >
480{
482 using Base::m_cholmod;
483
484 public:
485
486 typedef MatrixType_ MatrixType;
487
488 CholmodSimplicialLLT() : Base() { init(); }
489
490 CholmodSimplicialLLT(const MatrixType& matrix) : Base()
491 {
492 init();
493 this->compute(matrix);
494 }
495
497 protected:
498 void init()
499 {
500 m_cholmod.final_asis = 0;
501 m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
502 m_cholmod.final_ll = 1;
503 }
504};
505
506
529template<typename MatrixType_, int UpLo_ = Lower>
530class CholmodSimplicialLDLT : public CholmodBase<MatrixType_, UpLo_, CholmodSimplicialLDLT<MatrixType_, UpLo_> >
531{
533 using Base::m_cholmod;
534
535 public:
536
537 typedef MatrixType_ MatrixType;
538
539 CholmodSimplicialLDLT() : Base() { init(); }
540
541 CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
542 {
543 init();
544 this->compute(matrix);
545 }
546
548 protected:
549 void init()
550 {
551 m_cholmod.final_asis = 1;
552 m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
553 }
554};
555
578template<typename MatrixType_, int UpLo_ = Lower>
579class CholmodSupernodalLLT : public CholmodBase<MatrixType_, UpLo_, CholmodSupernodalLLT<MatrixType_, UpLo_> >
580{
582 using Base::m_cholmod;
583
584 public:
585
586 typedef MatrixType_ MatrixType;
587
588 CholmodSupernodalLLT() : Base() { init(); }
589
590 CholmodSupernodalLLT(const MatrixType& matrix) : Base()
591 {
592 init();
593 this->compute(matrix);
594 }
595
597 protected:
598 void init()
599 {
600 m_cholmod.final_asis = 1;
601 m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
602 }
603};
604
629template<typename MatrixType_, int UpLo_ = Lower>
630class CholmodDecomposition : public CholmodBase<MatrixType_, UpLo_, CholmodDecomposition<MatrixType_, UpLo_> >
631{
633 using Base::m_cholmod;
634
635 public:
636
637 typedef MatrixType_ MatrixType;
638
639 CholmodDecomposition() : Base() { init(); }
640
641 CholmodDecomposition(const MatrixType& matrix) : Base()
642 {
643 init();
644 this->compute(matrix);
645 }
646
648
649 void setMode(CholmodMode mode)
650 {
651 switch(mode)
652 {
653 case CholmodAuto:
654 m_cholmod.final_asis = 1;
655 m_cholmod.supernodal = CHOLMOD_AUTO;
656 break;
657 case CholmodSimplicialLLt:
658 m_cholmod.final_asis = 0;
659 m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
660 m_cholmod.final_ll = 1;
661 break;
662 case CholmodSupernodalLLt:
663 m_cholmod.final_asis = 1;
664 m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
665 break;
666 case CholmodLDLt:
667 m_cholmod.final_asis = 1;
668 m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
669 break;
670 default:
671 break;
672 }
673 }
674 protected:
675 void init()
676 {
677 m_cholmod.final_asis = 1;
678 m_cholmod.supernodal = CHOLMOD_AUTO;
679 }
680};
681
682} // end namespace Eigen
683
684#endif // EIGEN_CHOLMODSUPPORT_H
The base class for the direct Cholesky factorization of Cholmod.
Definition: CholmodSupport.h:217
void factorize(const MatrixType &matrix)
Definition: CholmodSupport.h:310
ComputationInfo info() const
Reports whether previous computation was successful.
Definition: CholmodSupport.h:268
Scalar determinant() const
Definition: CholmodSupport.h:393
Derived & setShift(const RealScalar &offset)
Definition: CholmodSupport.h:386
Derived & compute(const MatrixType &matrix)
Definition: CholmodSupport.h:275
Scalar logDeterminant() const
Definition: CholmodSupport.h:400
cholmod_common & cholmod()
Definition: CholmodSupport.h:323
void analyzePattern(const MatrixType &matrix)
Definition: CholmodSupport.h:288
A general Cholesky factorization and solver based on Cholmod.
Definition: CholmodSupport.h:631
A simplicial direct Cholesky (LDLT) factorization and solver based on Cholmod.
Definition: CholmodSupport.h:531
A simplicial direct Cholesky (LLT) factorization and solver based on Cholmod.
Definition: CholmodSupport.h:480
A supernodal Cholesky (LLT) factorization and solver based on Cholmod.
Definition: CholmodSupport.h:580
EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT
Definition: EigenBase.h:65
Derived & derived()
Definition: EigenBase.h:48
EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: EigenBase.h:62
Convenience specialization of Stride to specify only an inner stride See class Map for some examples.
Definition: Stride.h:102
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:98
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:52
static ConstMapType Map(const Scalar *data)
Definition: PlainObjectBase.h:643
A matrix or vector expression mapping an existing expression.
Definition: Ref.h:285
A versatible sparse matrix representation.
Definition: SparseMatrix.h:100
Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
Definition: SparseSelfAdjointView.h:47
A base class for sparse solvers.
Definition: SparseSolverBase.h:70
ComputationInfo
Definition: Constants.h:442
@ Lower
Definition: Constants.h:211
@ Upper
Definition: Constants.h:213
@ NumericalIssue
Definition: Constants.h:446
@ Success
Definition: Constants.h:444
const unsigned int RowMajorBit
Definition: Constants.h:68
Namespace containing all symbols from the Eigen library.
Definition: B01_Experimental.dox:1
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_real_op< typename Derived::Scalar >, const Derived > real(const Eigen::ArrayBase< Derived > &x)
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_exp_op< typename Derived::Scalar >, const Derived > exp(const Eigen::ArrayBase< Derived > &x)
Map< SparseMatrix< Scalar, Flags, StorageIndex > > viewAsEigen(cholmod_sparse &cm)
Definition: CholmodSupport.h:160
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:59
cholmod_sparse viewAsCholmod(Ref< SparseMatrix< Scalar_, Options_, StorageIndex_ > > mat)
Definition: CholmodSupport.h:60
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_log_op< typename Derived::Scalar >, const Derived > log(const Eigen::ArrayBase< Derived > &x)
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:235