spqr_support.cpp File Reference

#include "sparse.h"
#include <Eigen/SPQRSupport>

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 Scalar >
void	test_spqr_scalar ()
	EIGEN_DECLARE_TEST (spqr_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

(

spqr_support

)

                                 {
  CALL_SUBTEST_1(test_spqr_scalar<double>());
  CALL_SUBTEST_2(test_spqr_scalar<std::complex<double> >());
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, and test_spqr_scalar().

generate_sparse_rectangular_problem()

template<typename MatrixType , typename DenseMat >

int generate_sparse_rectangular_problem	(	MatrixType &	A,
		DenseMat &	dA,
		int	maxRows = 300,
		int	maxCols = 300
	)

                                                                                                           {
  eigen_assert(maxRows >= maxCols);
  typedef typename MatrixType::Scalar Scalar;
  int rows = internal::random<int>(1, maxRows);
  int cols = internal::random<int>(1, rows);
  double density = (std::max)(8. / (rows * cols), 0.01);
 
  A.resize(rows, cols);
  dA.resize(rows, cols);
  initSparse<Scalar>(density, dA, A, ForceNonZeroDiag);
  A.makeCompressed();
  return rows;
}

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

Referenced by test_spqr_scalar().

test_spqr_scalar()

template<typename Scalar >

void test_spqr_scalar

(

)

                        {
  typedef SparseMatrix<Scalar, ColMajor> MatrixType;
  MatrixType A;
  Matrix<Scalar, Dynamic, Dynamic> dA;
  typedef Matrix<Scalar, Dynamic, 1> DenseVector;
  DenseVector refX, x, b;
  SPQR<MatrixType> solver;
  generate_sparse_rectangular_problem(A, dA);
 
  Index m = A.rows();
  b = DenseVector::Random(m);
  solver.compute(A);
  if (solver.info() != Success) {
    std::cerr << "sparse QR factorization failed\n";
    exit(0);
    return;
  }
  x = solver.solve(b);
  if (solver.info() != Success) {
    std::cerr << "sparse QR factorization failed\n";
    exit(0);
    return;
  }
  // Compare with a dense solver
  refX = dA.colPivHouseholderQr().solve(b);
  VERIFY(x.isApprox(refX, test_precision<Scalar>()));
}

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

Referenced by EIGEN_DECLARE_TEST().