spbenchsolver.h File Reference

#include <iostream>
#include <fstream>
#include <Eigen/SparseCore>
#include <bench/BenchTimer.h>
#include <cstdlib>
#include <string>
#include <Eigen/Cholesky>
#include <Eigen/Jacobi>
#include <Eigen/Householder>
#include <Eigen/IterativeLinearSolvers>
#include <unsupported/Eigen/IterativeSolvers>
#include <Eigen/LU>
#include <unsupported/Eigen/SparseExtra>
#include <Eigen/SparseLU>
#include "spbenchstyle.h"

Go to the source code of this file.

Macros
#define	EIGEN_UMFPACK   10
#define	EIGEN_KLU   11
#define	EIGEN_SUPERLU   20
#define	EIGEN_PASTIX   30
#define	EIGEN_PARDISO   40
#define	EIGEN_SPARSELU_COLAMD   50
#define	EIGEN_SPARSELU_METIS   51
#define	EIGEN_BICGSTAB   60
#define	EIGEN_BICGSTAB_ILUT   61
#define	EIGEN_GMRES   70
#define	EIGEN_GMRES_ILUT   71
#define	EIGEN_SIMPLICIAL_LDLT   80
#define	EIGEN_CHOLMOD_LDLT   90
#define	EIGEN_PASTIX_LDLT   100
#define	EIGEN_PARDISO_LDLT   110
#define	EIGEN_SIMPLICIAL_LLT   120
#define	EIGEN_CHOLMOD_SUPERNODAL_LLT   130
#define	EIGEN_CHOLMOD_SIMPLICIAL_LLT   140
#define	EIGEN_PASTIX_LLT   150
#define	EIGEN_PARDISO_LLT   160
#define	EIGEN_CG   170
#define	EIGEN_CG_PRECOND   180

Functions
template<typename T >
NumTraits< T >::Real	test_precision ()
template<>
float	test_precision< float > ()
template<>
double	test_precision< double > ()
template<>
float	test_precision< std::complex< float > > ()
template<>
double	test_precision< std::complex< double > > ()
void	printStatheader (std::ofstream &out)
template<typename Solver , typename Scalar >
void	call_solver (Solver &solver, const int solver_id, const typename Solver::MatrixType &A, const Matrix< Scalar, Dynamic, 1 > &b, const Matrix< Scalar, Dynamic, 1 > &refX, std::ofstream &statbuf)
template<typename Solver , typename Scalar >
void	call_directsolver (Solver &solver, const int solver_id, const typename Solver::MatrixType &A, const Matrix< Scalar, Dynamic, 1 > &b, const Matrix< Scalar, Dynamic, 1 > &refX, std::string &statFile)
template<typename Solver , typename Scalar >
void	call_itersolver (Solver &solver, const int solver_id, const typename Solver::MatrixType &A, const Matrix< Scalar, Dynamic, 1 > &b, const Matrix< Scalar, Dynamic, 1 > &refX, std::string &statFile)
template<typename Scalar >
void	SelectSolvers (const SparseMatrix< Scalar > &A, unsigned int sym, Matrix< Scalar, Dynamic, 1 > &b, const Matrix< Scalar, Dynamic, 1 > &refX, std::string &statFile)
template<typename Scalar >
void	Browse_Matrices (const string folder, bool statFileExists, std::string &statFile, int maxiters, double tol)
bool	get_options (int argc, char **args, string option, string *value=0)

Variables
int	MaximumIters
double	RelErr
double	best_time_val
int	best_time_id

Macro Definition Documentation

EIGEN_BICGSTAB

#define EIGEN_BICGSTAB   60

EIGEN_BICGSTAB_ILUT

#define EIGEN_BICGSTAB_ILUT   61

EIGEN_CG

#define EIGEN_CG   170

EIGEN_CG_PRECOND

#define EIGEN_CG_PRECOND   180

EIGEN_CHOLMOD_LDLT

#define EIGEN_CHOLMOD_LDLT   90

EIGEN_CHOLMOD_SIMPLICIAL_LLT

#define EIGEN_CHOLMOD_SIMPLICIAL_LLT   140

EIGEN_CHOLMOD_SUPERNODAL_LLT

#define EIGEN_CHOLMOD_SUPERNODAL_LLT   130

EIGEN_GMRES

#define EIGEN_GMRES   70

EIGEN_GMRES_ILUT

#define EIGEN_GMRES_ILUT   71

EIGEN_KLU

#define EIGEN_KLU   11

EIGEN_PARDISO

#define EIGEN_PARDISO   40

EIGEN_PARDISO_LDLT

#define EIGEN_PARDISO_LDLT   110

EIGEN_PARDISO_LLT

#define EIGEN_PARDISO_LLT   160

EIGEN_PASTIX

#define EIGEN_PASTIX   30

EIGEN_PASTIX_LDLT

#define EIGEN_PASTIX_LDLT   100

EIGEN_PASTIX_LLT

#define EIGEN_PASTIX_LLT   150

EIGEN_SIMPLICIAL_LDLT

#define EIGEN_SIMPLICIAL_LDLT   80

EIGEN_SIMPLICIAL_LLT

#define EIGEN_SIMPLICIAL_LLT   120

EIGEN_SPARSELU_COLAMD

#define EIGEN_SPARSELU_COLAMD   50

EIGEN_SPARSELU_METIS

#define EIGEN_SPARSELU_METIS   51

EIGEN_SUPERLU

#define EIGEN_SUPERLU   20

EIGEN_UMFPACK

#define EIGEN_UMFPACK   10

Function Documentation

Browse_Matrices()

template<typename Scalar >

void Browse_Matrices	(	const string	folder,
		bool	statFileExists,
		std::string &	statFile,
		int	maxiters,
		double	tol
	)

                                                                                                              {
  MaximumIters = maxiters;  // Maximum number of iterations, global variable
  RelErr = tol;             // Relative residual error  as stopping criterion for iterative solvers
  MatrixMarketIterator<Scalar> it(folder);
  for (; it; ++it) {
    // print the infos for this linear system
    if (statFileExists) {
      std::ofstream statbuf(statFile.c_str(), std::ios::app);
      statbuf << "<LINEARSYSTEM> \n";
      statbuf << "   <MATRIX> \n";
      statbuf << "     <NAME> " << it.matname() << " </NAME>\n";
      statbuf << "     <SIZE> " << it.matrix().rows() << " </SIZE>\n";
      statbuf << "     <ENTRIES> " << it.matrix().nonZeros() << "</ENTRIES>\n";
      if (it.sym() != NonSymmetric) {
        statbuf << "     <SYMMETRY> Symmetric </SYMMETRY>\n";
        if (it.sym() == SPD)
          statbuf << "     <POSDEF> YES </POSDEF>\n";
        else
          statbuf << "     <POSDEF> NO </POSDEF>\n";
 
      } else {
        statbuf << "     <SYMMETRY> NonSymmetric </SYMMETRY>\n";
        statbuf << "     <POSDEF> NO </POSDEF>\n";
      }
      statbuf << "   </MATRIX> \n";
      statbuf.close();
    }
 
    cout << "\n\n===================================================== \n";
    cout << " ======  SOLVING WITH MATRIX " << it.matname() << " ====\n";
    cout << " =================================================== \n\n";
    Matrix<Scalar, Dynamic, 1> refX;
    if (it.hasrefX()) refX = it.refX();
    // Call all suitable solvers for this linear system
    SelectSolvers<Scalar>(it.matrix(), it.sym(), it.rhs(), refX, statFile);
 
    if (statFileExists) {
      std::ofstream statbuf(statFile.c_str(), std::ios::app);
      statbuf << "  <BEST_SOLVER ID='" << best_time_id << "'></BEST_SOLVER>\n";
      statbuf << " </LINEARSYSTEM> \n";
      statbuf.close();
    }
  }
}

References best_time_id, Eigen::MatrixMarketIterator< Scalar >::hasrefX(), Eigen::MatrixMarketIterator< Scalar >::matname(), Eigen::MatrixMarketIterator< Scalar >::matrix(), MaximumIters, Eigen::NonSymmetric, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::nonZeros(), Eigen::MatrixMarketIterator< Scalar >::refX(), RelErr, Eigen::MatrixMarketIterator< Scalar >::rhs(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), Eigen::SPD, and Eigen::MatrixMarketIterator< Scalar >::sym().

call_directsolver()

template<typename Solver , typename Scalar >

void call_directsolver	(	Solver &	solver,
		const int	solver_id,
		const typename Solver::MatrixType &	A,
		const Matrix< Scalar, Dynamic, 1 > &	b,
		const Matrix< Scalar, Dynamic, 1 > &	refX,
		std::string &	statFile
	)

                                            {
  std::ofstream statbuf(statFile.c_str(), std::ios::app);
  statbuf << "   <SOLVER_STAT ID='" << solver_id << "'>\n";
  call_solver(solver, solver_id, A, b, refX, statbuf);
  statbuf << "   </SOLVER_STAT>\n";
  statbuf.close();
}

References b, call_solver(), and solver.

Referenced by SelectSolvers().

call_itersolver()

template<typename Solver , typename Scalar >

void call_itersolver	(	Solver &	solver,
		const int	solver_id,
		const typename Solver::MatrixType &	A,
		const Matrix< Scalar, Dynamic, 1 > &	b,
		const Matrix< Scalar, Dynamic, 1 > &	refX,
		std::string &	statFile
	)

                                          {
  solver.setTolerance(RelErr);
  solver.setMaxIterations(MaximumIters);
 
  std::ofstream statbuf(statFile.c_str(), std::ios::app);
  statbuf << " <SOLVER_STAT ID='" << solver_id << "'>\n";
  call_solver(solver, solver_id, A, b, refX, statbuf);
  statbuf << "   <ITER> " << solver.iterations() << "</ITER>\n";
  statbuf << " </SOLVER_STAT>\n";
  std::cout << "ITERATIONS : " << solver.iterations() << "\n\n\n";
}

References b, call_solver(), MaximumIters, RelErr, and solver.

Referenced by SelectSolvers().

call_solver()

template<typename Solver , typename Scalar >

void call_solver	(	Solver &	solver,
		const int	solver_id,
		const typename Solver::MatrixType &	A,
		const Matrix< Scalar, Dynamic, 1 > &	b,
		const Matrix< Scalar, Dynamic, 1 > &	refX,
		std::ofstream &	statbuf
	)

                                                                                                                    {
  double total_time;
  double compute_time;
  double solve_time;
  double rel_error;
  Matrix<Scalar, Dynamic, 1> x;
  BenchTimer timer;
  timer.reset();
  timer.start();
  solver.compute(A);
  if (solver.info() != Success) {
    std::cerr << "Solver failed ... \n";
    return;
  }
  timer.stop();
  compute_time = timer.value();
  statbuf << "    <TIME>\n";
  statbuf << "     <COMPUTE> " << timer.value() << "</COMPUTE>\n";
  std::cout << "COMPUTE TIME : " << timer.value() << std::endl;
 
  timer.reset();
  timer.start();
  x = solver.solve(b);
  if (solver.info() == NumericalIssue) {
    std::cerr << "Solver failed ... \n";
    return;
  }
  timer.stop();
  solve_time = timer.value();
  statbuf << "     <SOLVE> " << timer.value() << "</SOLVE>\n";
  std::cout << "SOLVE TIME : " << timer.value() << std::endl;
 
  total_time = solve_time + compute_time;
  statbuf << "     <TOTAL> " << total_time << "</TOTAL>\n";
  std::cout << "TOTAL TIME : " << total_time << std::endl;
  statbuf << "    </TIME>\n";
 
  // Verify the relative error
  if (refX.size() != 0)
    rel_error = (refX - x).norm() / refX.norm();
  else {
    // Compute the relative residual norm
    Matrix<Scalar, Dynamic, 1> temp;
    temp = A * x;
    rel_error = (b - temp).norm() / b.norm();
  }
  statbuf << "    <ERROR> " << rel_error << "</ERROR>\n";
  std::cout << "REL. ERROR : " << rel_error << "\n\n";
  if (rel_error <= RelErr) {
    // check the best time if convergence
    if (!best_time_val || (best_time_val > total_time)) {
      best_time_val = total_time;
      best_time_id = solver_id;
    }
  }
}

References b, best_time_id, best_time_val, Eigen::NumericalIssue, RelErr, solver, Eigen::Success, and plotDoE::x.

Referenced by call_directsolver(), and call_itersolver().

get_options()

bool get_options	(	int	argc,
		char **	args,
		string	option,
		string *	value = 0
	)

                                                                          {
  int idx = 1, found = false;
  while (idx < argc && !found) {
    if (option.compare(args[idx]) == 0) {
      found = true;
      if (value) *value = args[idx + 1];
    }
    idx += 2;
  }
  return found;
}

References compute_granudrum_aor::args, MergeRestartFiles::found, and Eigen::value.

Referenced by main().

printStatheader()

void printStatheader

(

std::ofstream &

out

)

                                       {
  // Print XML header
  // NOTE It would have been much easier to write these XML documents using external libraries like tinyXML or
  // Xerces-C++.
 
  out << "<?xml version='1.0' encoding='UTF-8'?> \n";
  out << "<?xml-stylesheet type='text/xsl' href='#stylesheet' ?> \n";
  out << "<!DOCTYPE BENCH  [\n<!ATTLIST xsl:stylesheet\n id\t ID  #REQUIRED>\n]>";
  out << "\n\n<!-- Generated by the Eigen library -->\n";
 
  out << "\n<BENCH> \n";  // root XML element
  // Print the xsl style section
  printBenchStyle(out);
  // List all available solvers
  out << " <AVAILSOLVER> \n";
#ifdef EIGEN_UMFPACK_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_UMFPACK << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> UMFPACK </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_KLU_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_KLU << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> KLU </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_SUPERLU_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_SUPERLU << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> SUPERLU </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_CHOLMOD_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_CHOLMOD_SIMPLICIAL_LLT << "'>\n";
  out << "   <TYPE> LLT SP</TYPE> \n";
  out << "   <PACKAGE> CHOLMOD </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_CHOLMOD_SUPERNODAL_LLT << "'>\n";
  out << "   <TYPE> LLT</TYPE> \n";
  out << "   <PACKAGE> CHOLMOD </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_CHOLMOD_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> CHOLMOD </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_PARDISO_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_PARDISO << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> PARDISO </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_PARDISO_LLT << "'>\n";
  out << "   <TYPE> LLT </TYPE> \n";
  out << "   <PACKAGE> PARDISO </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_PARDISO_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> PARDISO </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_PASTIX_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_PASTIX << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> PASTIX </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_PASTIX_LLT << "'>\n";
  out << "   <TYPE> LLT </TYPE> \n";
  out << "   <PACKAGE> PASTIX </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_PASTIX_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> PASTIX </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
 
  out << "  <SOLVER ID='" << EIGEN_BICGSTAB << "'>\n";
  out << "   <TYPE> BICGSTAB </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_BICGSTAB_ILUT << "'>\n";
  out << "   <TYPE> BICGSTAB_ILUT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_GMRES_ILUT << "'>\n";
  out << "   <TYPE> GMRES_ILUT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_SIMPLICIAL_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_SIMPLICIAL_LLT << "'>\n";
  out << "   <TYPE> LLT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_CG << "'>\n";
  out << "   <TYPE> CG </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
  out << "  <SOLVER ID='" << EIGEN_SPARSELU_COLAMD << "'>\n";
  out << "   <TYPE> LU_COLAMD </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
 
#ifdef EIGEN_METIS_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_SPARSELU_METIS << "'>\n";
  out << "   <TYPE> LU_METIS </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
  out << " </AVAILSOLVER> \n";
}

References EIGEN_BICGSTAB, EIGEN_BICGSTAB_ILUT, EIGEN_CG, EIGEN_CHOLMOD_LDLT, EIGEN_CHOLMOD_SIMPLICIAL_LLT, EIGEN_CHOLMOD_SUPERNODAL_LLT, EIGEN_GMRES_ILUT, EIGEN_KLU, EIGEN_PARDISO, EIGEN_PARDISO_LDLT, EIGEN_PARDISO_LLT, EIGEN_PASTIX, EIGEN_PASTIX_LDLT, EIGEN_PASTIX_LLT, EIGEN_SIMPLICIAL_LDLT, EIGEN_SIMPLICIAL_LLT, EIGEN_SPARSELU_COLAMD, EIGEN_SPARSELU_METIS, EIGEN_SUPERLU, EIGEN_UMFPACK, out(), and printBenchStyle().

Referenced by main().

SelectSolvers()

template<typename Scalar >

void SelectSolvers	(	const SparseMatrix< Scalar > &	A,
		unsigned int	sym,
		Matrix< Scalar, Dynamic, 1 > &	b,
		const Matrix< Scalar, Dynamic, 1 > &	refX,
		std::string &	statFile
	)

                                                                                {
  typedef SparseMatrix<Scalar, ColMajor> SpMat;
  // First, deal with Nonsymmetric and symmetric matrices
  best_time_id = 0;
  best_time_val = 0.0;
// UMFPACK
#ifdef EIGEN_UMFPACK_SUPPORT
  {
    cout << "Solving with UMFPACK LU ... \n";
    UmfPackLU<SpMat> solver;
    call_directsolver(solver, EIGEN_UMFPACK, A, b, refX, statFile);
  }
#endif
// KLU
#ifdef EIGEN_KLU_SUPPORT
  {
    cout << "Solving with KLU LU ... \n";
    KLU<SpMat> solver;
    call_directsolver(solver, EIGEN_KLU, A, b, refX, statFile);
  }
#endif
  // SuperLU
#ifdef EIGEN_SUPERLU_SUPPORT
  {
    cout << "\nSolving with SUPERLU ... \n";
    SuperLU<SpMat> solver;
    call_directsolver(solver, EIGEN_SUPERLU, A, b, refX, statFile);
  }
#endif
 
  // PaStix LU
#ifdef EIGEN_PASTIX_SUPPORT
  {
    cout << "\nSolving with PASTIX LU ... \n";
    PastixLU<SpMat> solver;
    call_directsolver(solver, EIGEN_PASTIX, A, b, refX, statFile);
  }
#endif
 
  // PARDISO LU
#ifdef EIGEN_PARDISO_SUPPORT
  {
    cout << "\nSolving with PARDISO LU ... \n";
    PardisoLU<SpMat> solver;
    call_directsolver(solver, EIGEN_PARDISO, A, b, refX, statFile);
  }
#endif
 
  // Eigen SparseLU METIS
  cout << "\n Solving with Sparse LU AND COLAMD ... \n";
  SparseLU<SpMat, COLAMDOrdering<int> > solver;
  call_directsolver(solver, EIGEN_SPARSELU_COLAMD, A, b, refX, statFile);
// Eigen SparseLU METIS
#ifdef EIGEN_METIS_SUPPORT
  {
    cout << "\n Solving with Sparse LU AND METIS ... \n";
    SparseLU<SpMat, MetisOrdering<int> > solver;
    call_directsolver(solver, EIGEN_SPARSELU_METIS, A, b, refX, statFile);
  }
#endif
 
  // BiCGSTAB
  {
    cout << "\nSolving with BiCGSTAB ... \n";
    BiCGSTAB<SpMat> solver;
    call_itersolver(solver, EIGEN_BICGSTAB, A, b, refX, statFile);
  }
  // BiCGSTAB+ILUT
  {
    cout << "\nSolving with BiCGSTAB and ILUT ... \n";
    BiCGSTAB<SpMat, IncompleteLUT<Scalar> > solver;
    call_itersolver(solver, EIGEN_BICGSTAB_ILUT, A, b, refX, statFile);
  }
 
  // GMRES
  //   {
  //     cout << "\nSolving with GMRES ... \n";
  //     GMRES<SpMat> solver;
  //     call_itersolver(solver, EIGEN_GMRES, A, b, refX,statFile);
  //   }
  // GMRES+ILUT
  {
    cout << "\nSolving with GMRES and ILUT ... \n";
    GMRES<SpMat, IncompleteLUT<Scalar> > solver;
    call_itersolver(solver, EIGEN_GMRES_ILUT, A, b, refX, statFile);
  }
 
  // Hermitian and not necessarily positive-definites
  if (sym != NonSymmetric) {
    // Internal Cholesky
    {
      cout << "\nSolving with Simplicial LDLT ... \n";
      SimplicialLDLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_SIMPLICIAL_LDLT, A, b, refX, statFile);
    }
 
// CHOLMOD
#ifdef EIGEN_CHOLMOD_SUPPORT
    {
      cout << "\nSolving with CHOLMOD LDLT ... \n";
      CholmodDecomposition<SpMat, Lower> solver;
      solver.setMode(CholmodLDLt);
      call_directsolver(solver, EIGEN_CHOLMOD_LDLT, A, b, refX, statFile);
    }
#endif
 
// PASTIX LLT
#ifdef EIGEN_PASTIX_SUPPORT
    {
      cout << "\nSolving with PASTIX LDLT ... \n";
      PastixLDLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PASTIX_LDLT, A, b, refX, statFile);
    }
#endif
 
// PARDISO LLT
#ifdef EIGEN_PARDISO_SUPPORT
    {
      cout << "\nSolving with PARDISO LDLT ... \n";
      PardisoLDLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PARDISO_LDLT, A, b, refX, statFile);
    }
#endif
  }
 
  // Now, symmetric POSITIVE DEFINITE matrices
  if (sym == SPD) {
    // Internal Sparse Cholesky
    {
      cout << "\nSolving with SIMPLICIAL LLT ... \n";
      SimplicialLLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_SIMPLICIAL_LLT, A, b, refX, statFile);
    }
 
// CHOLMOD
#ifdef EIGEN_CHOLMOD_SUPPORT
    {
      // CholMOD SuperNodal LLT
      cout << "\nSolving with CHOLMOD LLT (Supernodal)... \n";
      CholmodDecomposition<SpMat, Lower> solver;
      solver.setMode(CholmodSupernodalLLt);
      call_directsolver(solver, EIGEN_CHOLMOD_SUPERNODAL_LLT, A, b, refX, statFile);
      // CholMod Simplicial LLT
      cout << "\nSolving with CHOLMOD LLT (Simplicial) ... \n";
      solver.setMode(CholmodSimplicialLLt);
      call_directsolver(solver, EIGEN_CHOLMOD_SIMPLICIAL_LLT, A, b, refX, statFile);
    }
#endif
 
// PASTIX LLT
#ifdef EIGEN_PASTIX_SUPPORT
    {
      cout << "\nSolving with PASTIX LLT ... \n";
      PastixLLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PASTIX_LLT, A, b, refX, statFile);
    }
#endif
 
// PARDISO LLT
#ifdef EIGEN_PARDISO_SUPPORT
    {
      cout << "\nSolving with PARDISO LLT ... \n";
      PardisoLLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PARDISO_LLT, A, b, refX, statFile);
    }
#endif
 
    // Internal CG
    {
      cout << "\nSolving with CG ... \n";
      ConjugateGradient<SpMat, Lower> solver;
      call_itersolver(solver, EIGEN_CG, A, b, refX, statFile);
    }
    // CG+IdentityPreconditioner
    //     {
    //       cout << "\nSolving with CG and IdentityPreconditioner ... \n";
    //       ConjugateGradient<SpMat, Lower, IdentityPreconditioner> solver;
    //       call_itersolver(solver,EIGEN_CG_PRECOND, A, b, refX,statFile);
    //     }
  }  // End SPD matrices
}

References b, best_time_id, best_time_val, call_directsolver(), call_itersolver(), Eigen::CholmodLDLt, Eigen::CholmodSimplicialLLt, Eigen::CholmodSupernodalLLt, EIGEN_BICGSTAB, EIGEN_BICGSTAB_ILUT, EIGEN_CG, EIGEN_CHOLMOD_LDLT, EIGEN_CHOLMOD_SIMPLICIAL_LLT, EIGEN_CHOLMOD_SUPERNODAL_LLT, EIGEN_GMRES_ILUT, EIGEN_KLU, EIGEN_PARDISO, EIGEN_PARDISO_LDLT, EIGEN_PARDISO_LLT, EIGEN_PASTIX, EIGEN_PASTIX_LDLT, EIGEN_PASTIX_LLT, EIGEN_SIMPLICIAL_LDLT, EIGEN_SIMPLICIAL_LLT, EIGEN_SPARSELU_COLAMD, EIGEN_SPARSELU_METIS, EIGEN_SUPERLU, EIGEN_UMFPACK, Eigen::NonSymmetric, solver, and Eigen::SPD.

test_precision()

template<typename T >

NumTraits<T>::Real test_precision ( )

inline

                                                  {
  return NumTraits<T>::dummy_precision();
}

test_precision< double >()

template<>

double test_precision< double > ( )

inline

                                       {
  return 1e-6;
}

References e().

test_precision< float >()

template<>

float test_precision< float > ( )

inline

                                     {
  return 1e-3f;
}

Referenced by test_isApprox(), and test_return_by_value().

test_precision< std::complex< double > >()

template<>

double test_precision< std::complex< double > > ( )

inline

                                                    {
  return test_precision<double>();
}

References Eigen::test_precision< double >().

test_precision< std::complex< float > >()

template<>

float test_precision< std::complex< float > > ( )

inline

                                                  {
  return test_precision<float>();
}

References Eigen::test_precision< float >().

Variable Documentation

best_time_id

int best_time_id

Referenced by Browse_Matrices(), call_solver(), and SelectSolvers().

best_time_val

double best_time_val

Referenced by call_solver(), and SelectSolvers().

MaximumIters

int MaximumIters

Referenced by Browse_Matrices(), and call_itersolver().

RelErr

double RelErr

Referenced by Browse_Matrices(), call_itersolver(), and call_solver().