Macros | Functions
accelerate_support.cpp File Reference
#include "sparse_solver.h"
#include <Eigen/AccelerateSupport>

Macros

#define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS
 

Functions

template<typename MatrixType , typename DenseMat >
int generate_sparse_rectangular_problem (MatrixType &A, DenseMat &dA, int maxRows=300, int maxCols=300)
 
template<typename MatrixType , typename DenseMat >
int generate_sparse_square_symmetric_problem (MatrixType &A, DenseMat &dA, int maxSize=300)
 
template<typename Scalar , typename Solver >
void test_accelerate_ldlt ()
 
template<typename Scalar , typename Solver >
void test_accelerate_llt ()
 
template<typename Scalar , typename Solver >
void test_accelerate_qr ()
 
template<typename Scalar >
void run_tests ()
 
 EIGEN_DECLARE_TEST (accelerate_support)
 

Macro Definition Documentation

◆ EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS

#define EIGEN_NO_DEBUG_SMALL_PRODUCT_BLOCKS

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( accelerate_support  )
163  {
164  CALL_SUBTEST_1(run_tests<float>());
165  CALL_SUBTEST_2(run_tests<double>());
166 }
CALL_SUBTEST_1
#define CALL_SUBTEST_1(FUNC)
Definition: split_test_helper.h:4
CALL_SUBTEST_2
#define CALL_SUBTEST_2(FUNC)
Definition: split_test_helper.h:10

References CALL_SUBTEST_1, and CALL_SUBTEST_2.

◆ generate_sparse_rectangular_problem()

template<typename MatrixType , typename DenseMat >
int generate_sparse_rectangular_problem ( MatrixType &  A,
DenseMat &  dA,
int  maxRows = 300,
int  maxCols = 300 
)
11  {
12  typedef typename MatrixType::Scalar Scalar;
13  int rows = internal::random<int>(1, maxRows);
14  int cols = internal::random<int>(1, maxCols);
15  double density = (std::max)(8.0 / (rows * cols), 0.01);
16 
17  A.resize(rows, cols);
18  dA.resize(rows, cols);
19  initSparse<Scalar>(density, dA, A, ForceNonZeroDiag);
20  A.makeCompressed();
21  return rows;
22 }
rows
int rows
Definition: Tutorial_commainit_02.cpp:1
cols
int cols
Definition: Tutorial_commainit_02.cpp:1
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:45
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
Eigen::PlainObjectBase::resize
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE void resize(Index rows, Index cols)
Definition: PlainObjectBase.h:294
max
#define max(a, b)
Definition: datatypes.h:23
UniformPSDSelfTest.density
density
Definition: UniformPSDSelfTest.py:19
ForceNonZeroDiag
@ ForceNonZeroDiag
Definition: sparse.h:32

References cols, UniformPSDSelfTest::density, ForceNonZeroDiag, max, Eigen::PlainObjectBase< Derived >::resize(), and rows.

Referenced by test_accelerate_qr().

◆ generate_sparse_square_symmetric_problem()

template<typename MatrixType , typename DenseMat >
int generate_sparse_square_symmetric_problem ( MatrixType &  A,
DenseMat &  dA,
int  maxSize = 300 
)
25  {
26  typedef typename MatrixType::Scalar Scalar;
27  int rows = internal::random<int>(1, maxSize);
28  int cols = rows;
29  double density = (std::max)(8.0 / (rows * cols), 0.01);
30 
31  A.resize(rows, cols);
32  dA.resize(rows, cols);
33  initSparse<Scalar>(density, dA, A, ForceNonZeroDiag);
34  dA = dA * dA.transpose();
35  A = A * A.transpose();
36  A.makeCompressed();
37  return rows;
38 }

References cols, UniformPSDSelfTest::density, ForceNonZeroDiag, max, Eigen::PlainObjectBase< Derived >::resize(), and rows.

Referenced by test_accelerate_ldlt(), and test_accelerate_llt().

◆ run_tests()

template<typename Scalar >
void run_tests ( )
143  {
144  typedef SparseMatrix<Scalar> MatrixType;
145 
146  test_accelerate_ldlt<Scalar, AccelerateLDLT<MatrixType, Lower> >();
147  test_accelerate_ldlt<Scalar, AccelerateLDLTUnpivoted<MatrixType, Lower> >();
148  test_accelerate_ldlt<Scalar, AccelerateLDLTSBK<MatrixType, Lower> >();
149  test_accelerate_ldlt<Scalar, AccelerateLDLTTPP<MatrixType, Lower> >();
150 
151  test_accelerate_ldlt<Scalar, AccelerateLDLT<MatrixType, Upper> >();
152  test_accelerate_ldlt<Scalar, AccelerateLDLTUnpivoted<MatrixType, Upper> >();
153  test_accelerate_ldlt<Scalar, AccelerateLDLTSBK<MatrixType, Upper> >();
154  test_accelerate_ldlt<Scalar, AccelerateLDLTTPP<MatrixType, Upper> >();
155 
156  test_accelerate_llt<Scalar, AccelerateLLT<MatrixType, Lower> >();
157 
158  test_accelerate_llt<Scalar, AccelerateLLT<MatrixType, Upper> >();
159 
160  test_accelerate_qr<Scalar, AccelerateQR<MatrixType> >();
161 }
MatrixType
MatrixXf MatrixType
Definition: benchmark-blocking-sizes.cpp:52

◆ test_accelerate_ldlt()

template<typename Scalar , typename Solver >
void test_accelerate_ldlt ( )
41  {
42  typedef SparseMatrix<Scalar> MatrixType;
43  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
44 
45  MatrixType A;
46  Matrix<Scalar, Dynamic, Dynamic> dA;
47 
48  generate_sparse_square_symmetric_problem(A, dA);
49 
50  DenseVector b = DenseVector::Random(A.rows());
51 
52  Solver solver;
53  solver.compute(A);
54 
55  if (solver.info() != Success) {
56  std::cerr << "sparse LDLT factorization failed\n";
57  exit(0);
58  return;
59  }
60 
61  DenseVector x = solver.solve(b);
62 
63  if (solver.info() != Success) {
64  std::cerr << "sparse LDLT factorization failed\n";
65  exit(0);
66  return;
67  }
68 
69  // Compare with a dense solver
70  DenseVector refX = dA.ldlt().solve(b);
71  VERIFY((A * x).isApprox(A * refX, test_precision<Scalar>()));
72 }
DenseVector
Matrix< Scalar, Dynamic, 1 > DenseVector
Definition: BenchSparseUtil.h:24
solver
BiCGSTAB< SparseMatrix< double > > solver
Definition: BiCGSTAB_simple.cpp:5
generate_sparse_square_symmetric_problem
int generate_sparse_square_symmetric_problem(MatrixType &A, DenseMat &dA, int maxSize=300)
Definition: accelerate_support.cpp:25
b
Scalar * b
Definition: benchVecAdd.cpp:17
A
Matrix< SCALARA, Dynamic, Dynamic, opt_A > A
Definition: bench_gemm.cpp:47
Eigen::PlainObjectBase::rows
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT
Definition: PlainObjectBase.h:191
Eigen::Success
@ Success
Definition: Constants.h:440
VERIFY
#define VERIFY(a)
Definition: main.h:362
Eigen::internal::isApprox
EIGEN_DEVICE_FUNC bool isApprox(const Scalar &x, const Scalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
Definition: MathFunctions.h:1923
plotDoE.x
list x
Definition: plotDoE.py:28

References b, generate_sparse_square_symmetric_problem(), Eigen::internal::isApprox(), Eigen::PlainObjectBase< Derived >::rows(), solver, Eigen::Success, VERIFY, and plotDoE::x.

◆ test_accelerate_llt()

template<typename Scalar , typename Solver >
void test_accelerate_llt ( )
75  {
76  typedef SparseMatrix<Scalar> MatrixType;
77  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
78 
79  MatrixType A;
80  Matrix<Scalar, Dynamic, Dynamic> dA;
81 
82  generate_sparse_square_symmetric_problem(A, dA);
83 
84  DenseVector b = DenseVector::Random(A.rows());
85 
86  Solver solver;
87  solver.compute(A);
88 
89  if (solver.info() != Success) {
90  std::cerr << "sparse LLT factorization failed\n";
91  exit(0);
92  return;
93  }
94 
95  DenseVector x = solver.solve(b);
96 
97  if (solver.info() != Success) {
98  std::cerr << "sparse LLT factorization failed\n";
99  exit(0);
100  return;
101  }
102 
103  // Compare with a dense solver
104  DenseVector refX = dA.llt().solve(b);
105  VERIFY((A * x).isApprox(A * refX, test_precision<Scalar>()));
106 }

References b, generate_sparse_square_symmetric_problem(), Eigen::internal::isApprox(), Eigen::PlainObjectBase< Derived >::rows(), solver, Eigen::Success, VERIFY, and plotDoE::x.

◆ test_accelerate_qr()

template<typename Scalar , typename Solver >
void test_accelerate_qr ( )
109  {
110  typedef SparseMatrix<Scalar> MatrixType;
111  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
112 
113  MatrixType A;
114  Matrix<Scalar, Dynamic, Dynamic> dA;
115 
116  generate_sparse_rectangular_problem(A, dA);
117 
118  DenseVector b = DenseVector::Random(A.rows());
119 
120  Solver solver;
121  solver.compute(A);
122 
123  if (solver.info() != Success) {
124  std::cerr << "sparse QR factorization failed\n";
125  exit(0);
126  return;
127  }
128 
129  DenseVector x = solver.solve(b);
130 
131  if (solver.info() != Success) {
132  std::cerr << "sparse QR factorization failed\n";
133  exit(0);
134  return;
135  }
136 
137  // Compare with a dense solver
138  DenseVector refX = dA.colPivHouseholderQr().solve(b);
139  VERIFY((A * x).isApprox(A * refX, test_precision<Scalar>()));
140 }
generate_sparse_rectangular_problem
int generate_sparse_rectangular_problem(MatrixType &A, DenseMat &dA, int maxRows=300, int maxCols=300)
Definition: accelerate_support.cpp:11

References b, generate_sparse_rectangular_problem(), Eigen::internal::isApprox(), Eigen::PlainObjectBase< Derived >::rows(), solver, Eigen::Success, VERIFY, and plotDoE::x.