PardisoSolver (Artisynth API documentation)

java.lang.Object
- maspack.solvers.DirectSolverBase
- - maspack.solvers.PardisoSolver

All Implemented Interfaces:

DirectSolver
```
public class PardisoSolver
extends DirectSolverBase
```
JNI interface to the Pardiso sparse solver. Usage of Pardiso is usually divided into three phases:
- An analyze phase that reorders the matrix to reduce fill-in and performs a symbolic factorization;
- A factor phase that numerically factors the matrix into a suitable decomposition;
- A solve phase that uses the factorization to solve M x = b for some given right-hand side b.
Typical usage of this solver is exemplified by the following call sequence:
```
    Matrix M;                 // matrix to be solved
    VectorNd x, b;            // solution vector and right-hand side
    
    PardisoSolver solver = new PardisoSolver();
    solver.analyze (M, M.rowSize(), Matrix.SYMMETRIC); // symbolic factorization
    solver.factor();          // numeric factorization
    solver.solve (x, b);      // solution using factorization
    
    solver.dispose();         // release resources when we are done
 
```
It is very important to call dispose() when the solver is no longer required, in order to release internal native resources that have been allocated for the Pardiso native code.
It is not necessary to call the analyze() and factor() methods every time a solution is required. analyze() needs to be called only when a matrix is first presented to the solver or when its sparsity structure changes. factor() needs to be called only when the numeric values of the matrix change. For a given set of numeric values, once factor() has been called, solve() can be called as many times as desired to generate solutions for different right-hand sides.
It is also possible to avoid using a Matrix object, and instead call analyze() and factor() with compressed row storage (CRS) data structures directly, as in
```
    solver.analyze (vals, colIdxs, rowOffs, size, matrixType);
    solver.factor (vals);
 
```
Here vals, colIdxs, and rowOffs describe the sparse matrix structure using the CRS format as described in the documentation for Matrix.setCRSValues.
Pardiso also supports iterative solving, in which the most recent matrix factorization is used as a preconditioner. If the current matrix values are close to those associated with the factorization, then the resulting iterative solution time can be considerably faster than the alternative combination of a factor() and a solve(). By default, the iteration is performed by the native wrapper, using the method set by DirectSolverBase.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod) (GMRES by default, or CGS), with the relative residual tolerance and maximum number of preconditioner solves set by DirectSolverBase.setIterativeTolerance(double) and DirectSolverBase.setIterativeMaxSolves(int). Alternatively, Pardiso's own iterative solve can be selected using setUseNativeIterativeSolve(boolean) or setDefaultUseNativeIterativeSolve(boolean). There are several iterativeSolve() methods, which obtain the current matrix values either directly as an input argument, or from a Matrix object supplied through the analyze() methods. When an iterativeSolve() method is successful, it returns a positive number indicating the number of iterations performed; otherwise it returns a value <= 0. A possible call sequence is as follows:
```
 
    solver.analyze (M, M.rowSize(), Matrix.SYMMETRIC); // symbolic factorization
    solver.factor();          // numeric factorization
    while (computing) {
       ... update matrix values and right-hand side b ...;
       if (solver.iterativeSolve(x, b) <= 0) {
          // iterative solve failed; do explicit factor and solve
          solver.factor();
          solver.solve (x, b);
       }
    }
 
 
```
A more sophisticated version of the above code will also call factor() and solve() when the compute time associated with iterativeSolve() becomes too large relative to that of a direct solve; HybridSolvePolicy implements such a policy. After refactorization, the time required by iterativeSolve() should be reduced since the next set of matrix values will again (presumably) be close to those associated with the factorization.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`PardisoSolver.ReorderMethod` Describes the reorder methods that can be used during the analyze phase to reduce factorization fill-in.

Nested classes/interfaces inherited from interface maspack.solvers.DirectSolver
DirectSolver.IterativeMethod

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`DEFAULT_SHOW_PERTURBED_PIVOTS`
`static boolean`	`DEFAULT_USE_NATIVE_ITERATIVE_SOLVE` Initial value of `getDefaultUseNativeIterativeSolve()`.
`static boolean`	`printThreadInfo`
`static boolean`	`supportsMultipleRhs`

Fields inherited from class maspack.solvers.DirectSolverBase
DEFAULT_GMRES_RESTART

Fields inherited from interface maspack.solvers.DirectSolver
ANALYZED, DEFAULT_ITERATIVE_MAX_SOLVES, DEFAULT_ITERATIVE_TOLERANCE, FACTORED, UNSET

Constructor Summary

Constructors
Constructor and Description

PardisoSolver()
Creates a new PardisoSolver object.

Constructors
Constructor and Description
`PardisoSolver()` Creates a new PardisoSolver object.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`clearIParams()` Removes all parameter overrides set using `setIParam(int, int)`.
`int`	`getAnalysisMemoryUsage()` Returns the amount of permanent memory (in kbytes) that was allocated during the most recent `analyze()` call.
`boolean`	`getApplyScaling()` Returns whether or not matrix scaling is enabled.
`boolean`	`getApplyWeightedMatchings()` Returns whether or not weighted matchings are enabled.
`static boolean`	`getDefaultUseNativeIterativeSolve()` Queries the default value of `getUseNativeIterativeSolve()` for newly created solvers.
`int`	`getFactorSolveMemoryUsage()` Returns the total memory consumption (in kbytes) required for the `factor()` and `solve()` calls.
`static java.lang.String`	`getInitErrorMessage()` Returns a message describing an error that occurred during initialization, or `null` if no error occurred.
`int`	`getIParam(int idx)` Returns the value of Pardiso's integer parameter `iparm[idx]` as of the most recent Pardiso phase.
`double[]`	`getLastIterativeTimes()` Returns a time breakdown of the most recent call to `iterativeSolve(maspack.matrix.VectorNd, maspack.matrix.VectorNd)`, in msec: the total time spent in the native code, the time spent in preconditioner solves, and the time spent in matrix-vector products.
`boolean`	`getMatrixChecking()` Returns true if matrix checking is enabled.
`int`	`getMaxRefinementSteps()` Returns the maximum number of iterative refinement steps that Pardiso should perform after a solve.
`int`	`getMessageLevel()` Returns the message level for the Pardiso native code.
`int`	`getNumNegEigenvalues()` Returns the number of negative eigenvalues that were detected during the most recent numeric factorization of a symmetric indefinite matrix (i.e., during the last `factor()` call).
`long`	`getNumNonZerosInFactors()` Returns the number of non-zeros elements in the factorization.
`int`	`getNumPerturbedPivots()` Returns the number of pivot perturbations that were required during the most recent numeric factorization (i.e., during the last `factor()` call).
`int`	`getNumPosEigenvalues()` Returns the number of positive eigenvalues that were detected during the most recent numeric factorization of a symmetric indefinite matrix (i.e., during the last `factor()` call).
`int`	`getNumRefinementSteps()` Returns the number of iterative refinement steps that Pardiso actually performed during the most recent call to `solve()`.
`int`	`getPeakAnalysisMemoryUsage()` Returns the peak amount of memory (in kbytes) that was used during the most recent `analyze()` call.
`int`	`getPivotPerturbation()` Returns the size of the perturbation that should be used to resolve zero-pivots, expressed as a negative power-of-ten exponent.
`PardisoSolver.ReorderMethod`	`getReorderMethod()` Gets the reorder method that is used during the analyze phase to reduced factorization fill-in.
`static boolean`	`getShowPerturbedPivots()` Queries whether the "num perturbed pivots" message is enabled.
`int`	`getSPDZeroPivot()` If the solver detects a zero or negative pivot for an SPD matrix, this method returns the row number where the first zero or negative pivot was detected.
`boolean`	`getUse2x2Pivoting()` Returns whether or not 2 x 2 pivoting is enabled.
`boolean`	`getUseNativeIterativeSolve()` Queries whether `iterativeSolve(maspack.matrix.VectorNd, maspack.matrix.VectorNd)` uses Pardiso's own iterative solve.
`boolean`	`hasIterativeSolves()` Returns true if this solver supports iterative solving, using a recent directly-factored matrix as a preconditioner.
`boolean`	`hasMultipleRhsSolves()` Returns true if this solver can solve for multiple right hand sides, using `solve(X,B,nrhs)`.
`boolean`	`hasWrapperIterativeSolves()` Queries whether the native library supports the iterative methods set by `DirectSolverBase.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod)` (GMRES and CGS), which are performed by the native wrapper.
`static boolean`	`isAvailable()` Returns true if the Pardiso solver is available.
`int`	`iterativeSolve(double[] x, double[] b)` Attempts to iteratively solve M x = b for a given right-hand side `b`, using the most recent numeric factorization as a preconditioner.
`int`	`iterativeSolve(double[] vals, double[] x, double[] b)` Solves the system
`int`	`iterativeSolve(double[] x, double[] b, int tolExp)` Deprecated. use `DirectSolverBase.setIterativeTolerance(double)` and `iterativeSolve(double[],double[])` instead
`int`	`iterativeSolve(VectorNd x, VectorNd b)` Implementation of `iterativeSolve(double[],double[])` that uses `VectorNd` objects to store to the result and right-hand side.
`int`	`iterativeSolve(VectorNd x, VectorNd b, int tolExp)` Deprecated. use `DirectSolverBase.setIterativeTolerance(double)` and `iterativeSolve(VectorNd,VectorNd)` instead
`static void`	`main(java.lang.String[] args)`
`void`	`setApplyScaling(int enable)` Sets whether or not Pardiso should apply matrix scaling to its factorizations.
`void`	`setApplyWeightedMatchings(int enable)` Sets whether or not Pardiso should apply weighted matching to its factorizations.
`static void`	`setDefaultUseNativeIterativeSolve(boolean enable)` Sets the default value of `getUseNativeIterativeSolve()` for solvers created after this call.
`void`	`setIParam(int idx, int value)` Expert tuning method: explicitly sets Pardiso's integer control parameter `iparm[idx]`, using the 0-based C indexing of Intel's documentation, overriding whatever value this class would otherwise use.
`void`	`setMatrixChecking(boolean enable)` Enables or disables checking of the integrity of the matrix data structures passed to Pardiso.
`void`	`setMaxRefinementSteps(int nsteps)` Sets the maximum number of iterative refinement steps that Pardiso should perform after a solve.
`void`	`setMessageLevel(int level)` Sets the message level for the Pardiso native code.
`void`	`setPivotPerturbation(int n)` Sets the size of the perturbation that should be used to resolve zero-pivots, expressed as a negative power-of-ten exponent.
`void`	`setReorderMethod(PardisoSolver.ReorderMethod method)` Sets the reorder method that should be used during the analyze phase to reduced factorization fill-in.
`static void`	`setShowPerturbedPivots(boolean enable)` Enables/disables the "num perturbed pivots" message (which usually indicates an ill-conditioned solve).
`void`	`setUse2x2Pivoting(int enable)` Sets whether or not Pardiso should use 2 x 2 Bunch and Kaufman pivoting (in addition to regular 1 x 1 pivoting) for symmetric indefinite matrices.
`void`	`setUseNativeIterativeSolve(boolean enable)` Sets whether `iterativeSolve(maspack.matrix.VectorNd, maspack.matrix.VectorNd)` uses Pardiso's own iterative solve (preconditioned CG for symmetric matrices, CGS otherwise), instead of the method set by `DirectSolverBase.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod)`, which is performed by the native wrapper.
`void`	`systemExit(int code)` This method is a hook that gives us access to _exit(), which is is in turn needed to exit ArtiSynth on the MacBook Pro 8.2 version of Ubuntu, since otherwise the JVM exit process encounters a SEGV in XQueryExtension.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface maspack.solvers.DirectSolver
iterativeSolve, residual

- Field Detail
  - printThreadInfo
```
public static boolean printThreadInfo
```
  - supportsMultipleRhs
```
public static boolean supportsMultipleRhs
```
  - DEFAULT_USE_NATIVE_ITERATIVE_SOLVE
```
public static final boolean DEFAULT_USE_NATIVE_ITERATIVE_SOLVE
```
    Initial value of getDefaultUseNativeIterativeSolve().
    
    See Also:
    
    Constant Field Values
  - DEFAULT_SHOW_PERTURBED_PIVOTS
```
public static boolean DEFAULT_SHOW_PERTURBED_PIVOTS
```
- Constructor Detail
  - PardisoSolver
```
public PardisoSolver()
```
    Creates a new PardisoSolver object.
- Method Detail
  - isAvailable
```
public static boolean isAvailable()
```
    Returns true if the Pardiso solver is available. A solver might not be available if the Pardiso native libraries cannot be loaded for some reason.
    
    Returns:
    
    true if Pardiso is available.
  - getInitErrorMessage
```
public static java.lang.String getInitErrorMessage()
```
    Returns a message describing an error that occurred during initialization, or null if no error occurred.
    
    Returns:
    
    initialization error message
  - setShowPerturbedPivots
```
public static void setShowPerturbedPivots(boolean enable)
```
    Enables/disables the "num perturbed pivots" message (which usually indicates an ill-conditioned solve).
    
    Parameters:
    
    enable - if true, enables the message
  - getShowPerturbedPivots
```
public static boolean getShowPerturbedPivots()
```
    Queries whether the "num perturbed pivots" message is enabled.
    
    Returns:
    
    true if the message is enabled
  - setMaxRefinementSteps
```
public void setMaxRefinementSteps(int nsteps)
```
    Sets the maximum number of iterative refinement steps that Pardiso should perform after a solve. Setting this to 0 disables iterative refinement. Setting this to -1 will cause Pardiso to choose a default value appropriate to the matrix type. More iterative refinement steps will increase solution accuracy but slow down the solve. This setting applies to direct solves; the preconditioner solves of the native wrapper's iterative methods never use refinement.
    
    Parameters:
    
    nsteps - maximum number of iterative refinement steps
    
    See Also:
    
    getMaxRefinementSteps(), getNumRefinementSteps()
  - getMaxRefinementSteps
```
public int getMaxRefinementSteps()
```
    Returns the maximum number of iterative refinement steps that Pardiso should perform after a solve.
    
    Returns:
    
    maximum number of iterative refinement steps
    
    See Also:
    
    setMaxRefinementSteps(int), getNumRefinementSteps()
  - getNumRefinementSteps
```
public int getNumRefinementSteps()
```
    Returns the number of iterative refinement steps that Pardiso actually performed during the most recent call to solve().
    
    Returns:
    
    number of iterative refinement steps actually performed
    
    See Also:
    
    getMaxRefinementSteps(), setMaxRefinementSteps(int)
  - getReorderMethod
```
public PardisoSolver.ReorderMethod getReorderMethod()
```
    Gets the reorder method that is used during the analyze phase to reduced factorization fill-in.
    
    Returns:
    
    current reorder method
    
    See Also:
    
    setReorderMethod(maspack.solvers.PardisoSolver.ReorderMethod)
  - setReorderMethod
```
public void setReorderMethod(PardisoSolver.ReorderMethod method)
```
    Sets the reorder method that should be used during the analyze phase to reduced factorization fill-in. Setting the method to DEFAULT will cause Pardiso to choose its default value.
    
    Parameters:
    
    method - reorder method
    
    See Also:
    
    getReorderMethod()
  - setPivotPerturbation
```
public void setPivotPerturbation(int n)
```
    Sets the size of the perturbation that should be used to resolve zero-pivots, expressed as a negative power-of-ten exponent. The perturbation size is given by
```
  norm(M) 10^{-n}
 
```
    where n is the argument to this method and norm(M) is a norm of the matrix. Setting n this to -1 will cause Pardiso to choose a default value appropriate to the matrix type.
    Parameters:
    
    n - perturbation exponent
    
    See Also:
    
    getPivotPerturbation()
  - getPivotPerturbation
```
public int getPivotPerturbation()
```
    Returns the size of the perturbation that should be used to resolve zero-pivots, expressed as a negative power-of-ten exponent.
    
    Returns:
    
    perturbation exponent
    
    See Also:
    
    setPivotPerturbation(int)
  - setApplyScaling
```
public void setApplyScaling(int enable)
```
    Sets whether or not Pardiso should apply matrix scaling to its factorizations. Scaling can be applied to unsymmetric matrices, or to symmetric matrices if weighted matchings (see setApplyWeightedMatchings()) are also selected. Scaling is controlled by enable as follows: enable > 0 enables scaling, enable = 0 disables scaling, and enable < 0 causes the solver to choose a default value appropriate to the matrix type.
    
    Parameters:
    
    enable - enables/disables matrix scaling
    
    See Also:
    
    getApplyScaling()
  - getApplyScaling
```
public boolean getApplyScaling()
```
    Returns whether or not matrix scaling is enabled.
    
    Returns:
    
    true if matrix scaling is enabled
    
    See Also:
    
    setApplyScaling(int)
  - setApplyWeightedMatchings
```
public void setApplyWeightedMatchings(int enable)
```
    Sets whether or not Pardiso should apply weighted matching to its factorizations. This, along with scaling (see setApplyScaling()) is recommended for highly indefinite symmetric systems (such as saddle point problems) and is the default for symmetric matrices. Weighted matchings are controlled by enable as follows: enable > 0 enables them, enable = 0 disables them, and enable < 0 causes the solver to choose a default value appropriate to the matrix type.
    
    Parameters:
    
    enable - enables/disables weight matchings
    
    See Also:
    
    getApplyWeightedMatchings()
  - getApplyWeightedMatchings
```
public boolean getApplyWeightedMatchings()
```
    Returns whether or not weighted matchings are enabled.
    
    Returns:
    
    true if weighted matchings are enabled
    
    See Also:
    
    setApplyWeightedMatchings(int)
  - setUse2x2Pivoting
```
public void setUse2x2Pivoting(int enable)
```
    Sets whether or not Pardiso should use 2 x 2 Bunch and Kaufman pivoting (in addition to regular 1 x 1 pivoting) for symmetric indefinite matrices. 2 x 2 pivoting is controlled by enable as follows: enable > 0 enables it, enable = 0 disables it, and enable < 0 causes the solver to choose a default value.
    
    Parameters:
    
    enable - enables 2 x 2 pivoting
    
    See Also:
    
    getUse2x2Pivoting()
  - getUse2x2Pivoting
```
public boolean getUse2x2Pivoting()
```
    Returns whether or not 2 x 2 pivoting is enabled.
    
    Returns:
    
    true if 2 x 2 pivoting is enabled
    
    See Also:
    
    setUse2x2Pivoting(int)
  - setMatrixChecking
```
public void setMatrixChecking(boolean enable)
```
    Enables or disables checking of the integrity of the matrix data structures passed to Pardiso. By default this is disabled, but it may be a good idea to enable it if problems arise such as crashes within the Pardiso native code.
    
    Parameters:
    
    enable - enables/disables matrix checking
    
    See Also:
    
    getMatrixChecking()
  - getMatrixChecking
```
public boolean getMatrixChecking()
```
    Returns true if matrix checking is enabled.
    
    Returns:
    
    true if matrix checking is enabled
    
    See Also:
    
    setMatrixChecking(boolean)
  - setIParam
```
public void setIParam(int idx,
                      int value)
```
    Expert tuning method: explicitly sets Pardiso's integer control parameter iparm[idx], using the 0-based C indexing of Intel's documentation, overriding whatever value this class would otherwise use. The override is reapplied before every subsequent Pardiso phase (analyze, factor and solve), except that the preconditioner solves of the native wrapper's iterative methods always use iparm[3] = 0 (no Pardiso iterative solve) and iparm[7] = 0 (no iterative refinement). Incorrect values can cause Pardiso to fail or to return inaccurate results. Requires native library support that was added with PardisoJNI 2026.1.1.
    
    Parameters:
    
    idx - parameter index, in the range 0 to 63
    
    value - parameter value
    
    See Also:
    
    clearIParams()
  - getIParam
```
public int getIParam(int idx)
```
    Returns the value of Pardiso's integer parameter iparm[idx] as of the most recent Pardiso phase. This can be used to read output parameters, such as peak memory use.
    
    Parameters:
    
    idx - parameter index, in the range 0 to 63
    
    Returns:
    
    parameter value
  - clearIParams
```
public void clearIParams()
```
    Removes all parameter overrides set using setIParam(int, int).
  - setMessageLevel
```
public void setMessageLevel(int level)
```
    Sets the message level for the Pardiso native code. 0 disables messages, while 1 causes printing of various stats and information about the solve process. The message level should normally be set to 0.
    
    Parameters:
    
    level - native code message level
    
    See Also:
    
    getMessageLevel()
  - getMessageLevel
```
public int getMessageLevel()
```
    Returns the message level for the Pardiso native code.
    
    Returns:
    
    message level
    
    See Also:
    
    setMessageLevel(int)
  - getNumNonZerosInFactors
```
public long getNumNonZerosInFactors()
```
    Returns the number of non-zeros elements in the factorization. Pardiso determines this during the analyze phase, and so the number returned by this method reflects that determined during the most recent analyze() call.
    
    Returns:
    
    number non-zero elements in the factorization.
  - getNumNegEigenvalues
```
public int getNumNegEigenvalues()
```
    Returns the number of negative eigenvalues that were detected during the most recent numeric factorization of a symmetric indefinite matrix (i.e., during the last factor() call). For matrices that are not symmetric indefinite, -1 is returned.
    
    Returns:
    
    number of negative eigenvalues for symmetric indefinite matrices
  - getNumPosEigenvalues
```
public int getNumPosEigenvalues()
```
    Returns the number of positive eigenvalues that were detected during the most recent numeric factorization of a symmetric indefinite matrix (i.e., during the last factor() call). For matrices that are not symmetric indefinite, -1 is returned.
    
    Returns:
    
    number of positive eigenvalues for symmetric indefinite matrices
  - getNumPerturbedPivots
```
public int getNumPerturbedPivots()
```
    Returns the number of pivot perturbations that were required during the most recent numeric factorization (i.e., during the last factor() call). Pivot perturbation generally indicates a singular, or very nearly singular, matrix.
    
    Returns:
    
    number of pivot perturbations
  - getSPDZeroPivot
```
public int getSPDZeroPivot()
```
    If the solver detects a zero or negative pivot for an SPD matrix, this method returns the row number where the first zero or negative pivot was detected.
    
    Returns:
    
    location of first zero or negative pivot, if any
  - getPeakAnalysisMemoryUsage
```
public int getPeakAnalysisMemoryUsage()
```
    Returns the peak amount of memory (in kbytes) that was used during the most recent analyze() call.
    
    Returns:
    
    peak memory usage during analyze.
  - getAnalysisMemoryUsage
```
public int getAnalysisMemoryUsage()
```
    Returns the amount of permanent memory (in kbytes) that was allocated during the most recent analyze() call.
    
    Returns:
    
    permanent memory allocated during analyze.
  - getFactorSolveMemoryUsage
```
public int getFactorSolveMemoryUsage()
```
    Returns the total memory consumption (in kbytes) required for the factor() and solve() calls. This number is determined in the most recent factor() call.
    
    Returns:
    
    total memory usage during factor and solve steps.
  - iterativeSolve
```
public int iterativeSolve(VectorNd x,
                          VectorNd b)
```
    Implementation of iterativeSolve(double[],double[]) that uses VectorNd objects to store to the result and right-hand side.
    
    Parameters:
    
    x - returns the solution value
    
    b - supplies the right-hand side
    
    Returns:
    
    number of iterations performed, or a value <= 0 if unsuccessful
    
    Throws:
    
    ImproperStateException - if not preceded by a call to analyze(Matrix,int,int) or analyzeAndFactor(Matrix), or if the matrix has not previously been factored.
    
    java.lang.IllegalArgumentException - if the dimensions of x or b are incompatible with the matrix size.
  - iterativeSolve
```
@Deprecated
public int iterativeSolve(VectorNd x,
                                      VectorNd b,
                                      int tolExp)
```
    Deprecated. use DirectSolverBase.setIterativeTolerance(double) and iterativeSolve(VectorNd,VectorNd) instead
    
    Performs iterativeSolve(VectorNd,VectorNd) with a relative residual tolerance of 10^-tolExp.
    
    Parameters:
    
    x - returns the solution value
    
    b - supplies the right-hand side
    
    tolExp - exponent for the stopping criterion
    
    Returns:
    
    number of iterations performed, or a value <= 0 if unsuccessful
  - iterativeSolve
```
public int iterativeSolve(double[] x,
                          double[] b)
```
    Attempts to iteratively solve M x = b for a given right-hand side b, using the most recent numeric factorization as a preconditioner. Current numeric values for M are obtained from the matrix that was supplied by a previous call to analyze(Matrix,int,int) or analyzeAndFactor(Matrix). Otherwise this method behaves identically to iterativeSolve(double[],double[],double[]).
    
    Parameters:
    
    x - returns the solution value
    
    b - supplies the right-hand side
    
    Returns:
    
    number of iterations performed, or a value <= 0 if unsuccessful
    
    Throws:
    
    ImproperStateException - if not preceded by a call to analyze(Matrix,int,int) or analyzeAndFactor(Matrix), or if the matrix has not previously been factored.
    
    java.lang.IllegalArgumentException - if the dimensions of x or b are incompatible with the matrix size.
  - iterativeSolve
```
@Deprecated
public int iterativeSolve(double[] x,
                                      double[] b,
                                      int tolExp)
```
    Deprecated. use DirectSolverBase.setIterativeTolerance(double) and iterativeSolve(double[],double[]) instead
    
    Performs iterativeSolve(double[],double[]) with a relative residual tolerance of 10^-tolExp.
    
    Parameters:
    
    x - returns the solution value
    
    b - supplies the right-hand side
    
    tolExp - exponent for the stopping criterion
    
    Returns:
    
    number of iterations performed, or a value <= 0 if unsuccessful
  - iterativeSolve
```
public int iterativeSolve(double[] vals,
                          double[] x,
                          double[] b)
```
    Solves the system
```
  M x = b
 
```
    iteratively, using the most recent factorization as a preconditioner and the matrix values supplied by vals. If the current values are close to those associated with the factorization, this can be considerably faster than an explicit factor() and solve(). The method, maximum number of preconditioner solves and tolerance are set by DirectSolver.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod), DirectSolver.setIterativeMaxSolves(int) and DirectSolver.setIterativeTolerance(double).
    This method is only available if DirectSolver.hasIterativeSolves() returns true; otherwise, it returns 0 and the caller should fall back on factoring and solving directly.
    By default, the method set by DirectSolverBase.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod) is performed by the native wrapper; if it does not converge, 0 is returned. Alternatively, Pardiso's own iterative solve can be used (see setUseNativeIterativeSolve(boolean)): preconditioned CG for symmetric matrices and CGS otherwise. It applies the tolerance only approximately, rounded to a power of 10 and using Pardiso's own stopping criterion, and uses Pardiso's own iteration limit (150) instead of DirectSolverBase.setIterativeMaxSolves(int). If it fails, it returns a negative code equal to -(10*iterations + error). In either case, getErrorMessage() describes the failure.
    Parameters:
    
    vals - current values of the non-zero matrix elements, in the same ordering as that supplied to analyze()
    
    x - vector in which the result is returned
    
    b - right hand vector of the matrix equation
    
    Returns:
    
    number of iterations performed, or a value <= 0 if the iterative solve was not performed or did not succeed
  - hasMultipleRhsSolves
```
public boolean hasMultipleRhsSolves()
```
    Returns true if this solver can solve for multiple right hand sides, using solve(X,B,nrhs).
    
    Returns:
    
    true if multiple right hand sides are supported
  - hasIterativeSolves
```
public boolean hasIterativeSolves()
```
    Returns true if this solver supports iterative solving, using a recent directly-factored matrix as a preconditioner. If it does, all the methods described by DirectSolver.IterativeMethod are available, as are the settings DirectSolver.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod), DirectSolver.setIterativeMaxSolves(int) and DirectSolver.setIterativeTolerance(double).
    
    Returns:
    
    true if iterative solving is available
  - hasWrapperIterativeSolves
```
public boolean hasWrapperIterativeSolves()
```
    Queries whether the native library supports the iterative methods set by DirectSolverBase.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod) (GMRES and CGS), which are performed by the native wrapper. These were added with PardisoJNI 2026.1.1. If they are not supported, iterativeSolve(maspack.matrix.VectorNd, maspack.matrix.VectorNd) uses Pardiso's own iterative solve instead (see setUseNativeIterativeSolve(boolean)).
    
    Returns:
    
    true if GMRES and CGS iterative solves are supported
  - setUseNativeIterativeSolve
```
public void setUseNativeIterativeSolve(boolean enable)
```
    Sets whether iterativeSolve(maspack.matrix.VectorNd, maspack.matrix.VectorNd) uses Pardiso's own iterative solve (preconditioned CG for symmetric matrices, CGS otherwise), instead of the method set by DirectSolverBase.setIterativeMethod(maspack.solvers.DirectSolver.IterativeMethod), which is performed by the native wrapper. The default is given by getDefaultUseNativeIterativeSolve(). Pardiso's own solve applies the tolerance only approximately, ignores DirectSolverBase.setIterativeMaxSolves(int), and does not provide DirectSolverBase.getLastIterativeSolves(), DirectSolverBase.getLastIterativeResidual() or getLastIterativeTimes(). It is also used if the native library does not support the wrapper's methods.
    
    Parameters:
    
    enable - if true, use Pardiso's own iterative solve
  - getUseNativeIterativeSolve
```
public boolean getUseNativeIterativeSolve()
```
    Queries whether iterativeSolve(maspack.matrix.VectorNd, maspack.matrix.VectorNd) uses Pardiso's own iterative solve. See setUseNativeIterativeSolve(boolean).
    
    Returns:
    
    true if Pardiso's own iterative solve is used
  - setDefaultUseNativeIterativeSolve
```
public static void setDefaultUseNativeIterativeSolve(boolean enable)
```
    Sets the default value of getUseNativeIterativeSolve() for solvers created after this call. Initially DEFAULT_USE_NATIVE_ITERATIVE_SOLVE (false), so that the native wrapper's iterative method (GMRES by default) is used.
    
    Parameters:
    
    enable - if true, new solvers use Pardiso's own iterative solve
  - getDefaultUseNativeIterativeSolve
```
public static boolean getDefaultUseNativeIterativeSolve()
```
    Queries the default value of getUseNativeIterativeSolve() for newly created solvers. See setDefaultUseNativeIterativeSolve(boolean).
    
    Returns:
    
    true if new solvers use Pardiso's own iterative solve
  - getLastIterativeTimes
```
public double[] getLastIterativeTimes()
```
    Returns a time breakdown of the most recent call to iterativeSolve(maspack.matrix.VectorNd, maspack.matrix.VectorNd), in msec: the total time spent in the native code, the time spent in preconditioner solves, and the time spent in matrix-vector products. The remainder of the total is vector operations and setup. Intended for performance analysis.
    
    Returns:
    
    total, preconditioner solve and matrix product times, or null if that call used Pardiso's own iterative solve
  - main
```
public static void main(java.lang.String[] args)
```
  - systemExit
```
public void systemExit(int code)
```
    This method is a hook that gives us access to _exit(), which is is in turn needed to exit ArtiSynth on the MacBook Pro 8.2 version of Ubuntu, since otherwise the JVM exit process encounters a SEGV in XQueryExtension. This method was put into PardisoSolver purely ; it has nothing to do with Pardiso per-se.

Class PardisoSolver

Nested Class Summary

Nested classes/interfaces inherited from interface maspack.solvers.DirectSolver

Field Summary

Fields inherited from class maspack.solvers.DirectSolverBase

Fields inherited from interface maspack.solvers.DirectSolver

Constructor Summary

Method Summary

Methods inherited from class maspack.solvers.DirectSolverBase

Methods inherited from class java.lang.Object

Methods inherited from interface maspack.solvers.DirectSolver

Field Detail

printThreadInfo

supportsMultipleRhs

DEFAULT_USE_NATIVE_ITERATIVE_SOLVE

DEFAULT_SHOW_PERTURBED_PIVOTS

Constructor Detail

PardisoSolver

Method Detail

isAvailable

getInitErrorMessage

setShowPerturbedPivots

getShowPerturbedPivots

setMaxRefinementSteps

getMaxRefinementSteps

getNumRefinementSteps

getReorderMethod

setReorderMethod

setPivotPerturbation

getPivotPerturbation

setApplyScaling

getApplyScaling

setApplyWeightedMatchings

getApplyWeightedMatchings

setUse2x2Pivoting

getUse2x2Pivoting

setMatrixChecking

getMatrixChecking

setIParam

getIParam

clearIParams

setMessageLevel

getMessageLevel

getNumNonZerosInFactors

getNumNegEigenvalues

getNumPosEigenvalues

getNumPerturbedPivots

getSPDZeroPivot

getPeakAnalysisMemoryUsage

getAnalysisMemoryUsage

getFactorSolveMemoryUsage

iterativeSolve

iterativeSolve

iterativeSolve

iterativeSolve

iterativeSolve

hasMultipleRhsSolves

hasIterativeSolves

hasWrapperIterativeSolves

setUseNativeIterativeSolve

getUseNativeIterativeSolve

setDefaultUseNativeIterativeSolve

getDefaultUseNativeIterativeSolve

getLastIterativeTimes

main

systemExit