The syntax for creating a Suite Sparse Solver object follows the basic syntax used for creating every plugin based object. In addition, the solver supports several optional attributes that can be used to configure its behaviour. Every option has a default value so in practice none of them is required.

Four different solvers from the Suite Sparse package are supported:

CHOLMOD: CHOLMOD is a set of routines for factorizing sparse symmetric positive definite matrices of the form A or AAT, updating/downdating a sparse Cholesky factorization, solving linear systems, updating/downdating the solution to the triangular system Lx = b, and many other sparse matrix functions for both symmetric and unsymmetric matrices. Its supernodal Cholesky factorization relies on LAPACK and the Level-3 BLAS, and obtains a substantial fraction of the peak performance of the BLAS. Both real and complex matrices are supported. It also includes a non-supernodal LDLT factorization method that can factorize symmetric indefinite matrices if all of their leading submatrices are well-conditioned (D is diagonal).
UMFPACK: UMFPACK is a set of routines for solving unsymmetric sparse linear systems, Ax = b, using the Unsymmetric MultiFrontal method and direct sparse LU factorization.
ParU: ParU is an implementation of the multifrontal sparse LU factorization method. Parallelism is exploited both in the BLAS and across diferent frontal matrices using OpenMP tasking.
SPQR: SuiteSparseQR is an implementation of the multifrontal sparse QR factorization method. Parallelism is exploited both in the BLAS and across diferent frontal matrices.

IMPORTANT: Not all of the available SuiteSparse solver configuration options where made available as a plugin option. They can be added on an "as needed" basis. So, if you are missing some desired option, please check the libraries user manuals to see if it is there and should be added to GeMA.

Example

NumericalSolver 
{
  id           = 'solver',
  typeName     = 'SuiteSparseSolver.umfpack',
  description  = 'UMFPACK matrix solver',
}

Fields

Field	Description	Type	Required	Def. Value
id	The numeric solver name.	String	Yes
typeName	The plugin name. Should be equal to "SuiteSparseSolver.xxx", where `xxx` should be one of the following options: `cholmod`, `umfpack`, `paru` or `spqr`, defining the solver that will be used.	String	Yes
description	A description of the numeric solver purpose.	String	No
General options:
i64	When set to `true`, sparse matrix indices are represented as 64-bit integers. Requires more memory but might be necessary to solve big problems. Ignored by the `paru` solver (it always uses 64-bit integers).	Boolean	No	false
threads	The number of threads used by the linear solver. If not given, or the given value is greater than the maximum number of concurrent threads supported by the machine, the maximum number will be used. Negative or 0 values are also interpreted as the maximum number of threads. Ignored by the `umfpack` solver.	Integer	No	Max supported threads
normType	The p-norm type used to calculate the solution residual (b - Ax). Its value can be 0 for the infinity-norm, 1 for L1 norm and 2 for L2 norm.	Integer	No	2
printResidual	If set to true, the residual value, calculated as specified by the `normType` option, will be printed to the GeMA log.	Boolean	No	false
CHOLMOD options:
gpu	If set to true and the plugin was compiled with CUDA support and the current computer has a CUDA enabled NVIDIA video board, part of the computation will be done on the GPU. Can be effective for large problems.	Boolean	No	false
symmetric	This option can be used to inform the solver about the symmetry of the input matrix to be solved. When solving a symmetric system, `cholmod` will solve the standard Ax = b equation. For unsymmetric matrices, the (AA')y = b system will be solved followed by x = A'y. A value of `true` tells the solver that the matrix is guaranteed to be symmetric. A value of `false` tells the solver that the matrix is unsymmetric. A value of `auto` tells the solver to traverse the matrix to check wheher it is symmetric or not each time the system is solved. A value of `first` is similar to `auto`, but the check is done only the first time that system is solved.	String or Boolean	No	'auto'
symRelTol	The relative tolerance used when checking if a matrix is symmetric or not when the `symmetric` option is equal to `auto` or `first`. Two numbers a and b are considered equal if their absolute difference is smaller or equal to relTol * max(a, b). Set it to 0.0 if you don't want any tolerance in the comparison.	Number	No	1.e-8
symAbsTol	The absolute tolerance used when checking if a matrix is symmetric or not when the `symmetric` option is equal to `auto` or `first`. Two numbers a and b are considered equal if their absolute difference is smaller or equal to absTol. Set it to 0.0 if you don't want any tolerance in the comparison.	Number	No	1.e-12
ldl	If set to true, the solver will force an LDL' factorization. This enables the factorization of symmetric indefinite matrices if all of their leading submatrices are well-conditioned. The performance is much slower than using an LL' factorization, so this option should be rarely used. Try using `umfpack` to solve indefinite matrices.	Boolean	No	false
ordering	Defines the algorithm that will be applied to reorder (permutate) the matrix columns in order to reduce the factorization's fill-in (non-zero entries that where zero in the original matrix). The following options are valid: - `auto`: Tries the `AMD` method. If the fill-in is not satisfactory, also tries `METIS`. Chooses the best option; - `all`: Tries all the other options below. Chooses the best one. Time consuming but may be worthy if the system will be solved multiple times; - `amd` or `cholmod1`: Uses the AMD - Aproximate minimum degree algorithm; - `metis` or `cholmod2`: Uses `METIS` nested dissection algorithm; - `nesdis` or `cholmod3`: Uses CHOLMOD's internal nested dissection algorithm; - `natural` or `cholmod4`: No reordering; - `nesdis_20000` or `cholmod5`: Uses CHOLMOD's internal nested dissection algorithm, stopping at subgraphs of 20.000 nodes; - `nesdis_4` or `cholmod6`: Uses CHOLMOD's internal nested dissection algorithm, stopping at subgraphs of 4 nodes and not using CAMD; - `nesdis_no_pruning` or `cholmod7`: Uses CHOLMOD's internal nested dissection algorithm with no pruning of dense rows/cols; - `colamd` or `cholmod8`: Uses the `AMD` algorithm for symmetric matrices and the COLAMD - Column approximate minimum degree algorithm for unsymmetric matrices. For additional details, please refer to CHOLMOD's user manual.	String	No	'auto'
refine	If set to true, a single refinement step will be executed after the system solution.	Boolean	No	false
UMFPACK options:
strategy	Defines the strategy used by the solver: symmetric or unsymmetric. For the symmetric strategy, a symmetric row and column ordering (such as AMD) is used and a strong preference is given to the diagonal during partial pivoting. For the unsymmetric strategy, a column pre-ordering (such as COLAMD) is used and no preference is given to the diagonal during partial pivoting. The library can usually select the best strategy by anlysing the non-zero pattern of the matrix and measuring its symmetry and the number of non-zero values on the diagonal. Keep in mind that for this option, the symmetry refers to the symmetry of the non-zero pattern, not the matrix values. Availabe options are `auto`, `symmetric` and `unsymmetric`. For additional details, please refer to UMFPACK's user manual.	String	No	'auto'
ordering	Defines the algorithm that will be applied to reorder (permutate) the matrix columns in order to reduce the factorization's fill-in (non-zero entries that where zero in the original matrix). The following options are valid: - `auto`: Equal to the `cholmod` option; - `cholmod`: Similar to CHOLMOD's automatic method. Tries the `AMD` method for the symmetric strategy or `COLAMD` for the unsymmetric one. If the fill-in is not satisfactory, also tries `METIS`. Chooses the best option; - `amd`: Uses the AMD - Aproximate minimum degree algorithm method for the symmetric strategy or the COLAMD - Column approximate minimum degree algorithm for the unsymmetric one; - `metis`: Uses METIS nested dissection algorithm; - `best`: Tries three orderings, picks the best. This includes AMD or COLAMD, depending on the strategy, METIS and the CHOLMOD's NESDIS method (that can not be choosed otherwise!); - `none`: No reordering; - `metis_guard`: Uses METIS for the symmetric strategy. For the unsymmetric one, uses METIS unless the matrix has one or more very dense rows. In that case, uses COLAMD. For additional details, please refer to UMFPACK's user manual.	String	No	'auto'
scale	Defines the method that will be used to internally scale the matrix. This is important for the "symmetric" strategy and can also improve performance fer the "unsymmetric" strategy. The following options are valid: - `none`: No scaling; - `sum`: Each row of the input matrix is divided by the sum of the absolute values of the entries in that row.g; - `max`: Each row of the input matrix is divided by the maximum absolute value of the entries in that row.	String	No	'sum'
refine	The maximum number of refinement steps that will be executed after the system solution.	Integer	No	2
ParU options:
ordering	See the description for the `ordering` option for `umfpack`.	String	No	'auto'
strategy	See the description for the `strategy` option for `umfpack`.	String	No	'auto'
umfpackStrategy	See the description for the `strategy` option for `umfpack`. Affects only the symbolic factorization phase, done by UMFPACK. In rare cases, setting this option differently from `strategy` can lead to optimal performance. See ParU's user manual for details.	String	No	'auto'
scale	See the description for the `scale` option for `umfpack`.	String	No	'sum'
SPQR options: