MumpsSolver (Artisynth API documentation)

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

All Implemented Interfaces:

DirectSolver
```
public class MumpsSolver
extends DirectSolverBase
```
JNI interface to the MUMPS sparse solver. Usage of MUMPS is usually dividing into three phases:
- An analyze phase that reorder the matrix to reduce fill-in and performs a symbolic factorization;
- A factor phase that numerically factors the matrix into a sutiable 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
    
    MumpsSolver solver = new MumpsSolver();
    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 MUMPS 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 descrive the sparse matrix structure using the CRS format as described in the documentation for Matrix.setCRSValues.
MUMPS itself uses an assembled coordinate format, in which the row and column index of every non-zero element is given explicitly. The conversion from CRS is done inside the native layer, once per analyze() call, by expanding the row offsets into row indices. For symmetric matrices, only the upper triangular portion is supplied, which MUMPS accepts directly.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`MumpsSolver.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`	`printThreadInfo`
`static boolean`	`supportsMultipleRhs`
`static int`	`WARN_COMPACT_MEMORY` Warning bit indicating insufficient memory to compact the internal work array at the end of the factorization.
`static int`	`WARN_INDEX_OUT_OF_RANGE` Warning bit (returned in INFOG(1)) indicating that entries with out-of-range indices were found and ignored.
`static int`	`WARN_RANK_REVEALING` Warning bit returned by the rank revealing feature.
`static int`	`WARN_REFINEMENT` Warning bit indicating that iterative refinement did not converge within the allowed number of steps.
`static int`	`WARN_ZERO_SOLUTION` Warning bit indicating that the max-norm of the solution is close to zero.

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

MumpsSolver()
Creates a new MumpsSolver object.

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`getAnalysisMemoryUsage()` Returns the total amount of memory (in kbytes), summed over all processes, that MUMPS estimated during the most recent `analyze()` call would be needed for an in-core factorization (MUMPS parameter INFOG(17)).
`boolean`	`getApplyWeightedMatchings()` Returns whether or not weighted matchings are enabled.
`int`	`getFactorSolveMemoryUsage()` Returns the memory (in kbytes) actually used during the most recent `factor()` call (MUMPS parameter INFOG(21)).
`static java.lang.String`	`getInitErrorMessage()` Returns a message describing an error that occurred during initialization, or `null` if no error occurred.
`double[]`	`getLastIterativeTimes()` Returns a time breakdown of the most recent call to `iterativeSolve(double[], double[], double[])`, in msec: the total time spent in the native code, the time spent in preconditioner solves, and the time spent in matrix-vector products.
`int`	`getMaxRefinementSteps()` Returns the maximum number of iterative refinement steps that MUMPS should perform after a solve.
`int`	`getMaxWorkingMemory()` Returns the maximum size of the working memory, in Mbytes, that MUMPS is allowed to allocate.
`boolean`	`getNullPivotDetection()` Queries whether null pivot detection is enabled.
`double`	`getNullPivotThreshold()` Returns the threshold used to identify null pivots.
`int`	`getNumDelayedPivots()` Returns the number of delayed pivots that occurred during the most recent numeric factorization (MUMPS parameter INFOG(13)).
`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, MUMPS parameter INFOG(12)).
`long`	`getNumNonZerosInFactors()` Returns the number of non-zeros elements in the factorization.
`int`	`getNumNullPivots()` Returns the number of null pivot rows that were detected during the most recent numeric factorization (MUMPS parameter INFOG(28)), which corresponds to the deficiency of the matrix.
`int`	`getNumPerturbedPivots()` Returns the number of pivots that were perturbed 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 MUMPS actually performed during the most recent call to `solve()` (MUMPS parameter INFOG(15)).
`int`	`getNumTinyPivots()` Returns the number of tiny pivots that were modified by static pivoting during the most recent numeric factorization (MUMPS parameter INFOG(25)).
`int`	`getPeakAnalysisMemoryUsage()` Returns the maximum amount of memory (in kbytes) that MUMPS estimated, during the most recent `analyze()` call, would be needed by a single process for an in-core factorization (MUMPS parameter INFOG(16)).
`MumpsSolver.ReorderMethod`	`getReorderMethod()` Gets the reorder method that is used during the analyze phase to reduced factorization fill-in (MUMPS parameter ICNTL(7)).
`MumpsSolver.ReorderMethod`	`getReorderMethodUsed()` Returns the reorder method that MUMPS actually used during the most recent analyze phase (MUMPS parameter INFOG(7)).
`int`	`getScaling()` Returns the scaling which MUMPS applies to the matrix, as described for `setScaling(int)`.
`static boolean`	`getShowPerturbedPivots()` Queries whether the "num perturbed pivots" message is enabled.
`int`	`getSPDZeroPivot()` If the solver detected null pivots during the most recent factorization, this method returns the row number of the first such pivot, as identified by the MUMPS PIVNUL_LIST array.
`double`	`getStaticPivotTolerance()` Returns the threshold used for static pivoting.
`int`	`getSymOrderingStrategy()` Returns the ordering strategy used for symmetric indefinite matrices.
`int`	`getWorkspaceIncrease()` Returns the percentage by which MUMPS increases the working space estimated during the analyze phase.
`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)`.
`static boolean`	`isAvailable()` Returns true if the MUMPS solver is available.
`int`	`iterativeSolve(double[] vals, double[] x, double[] b)` Solves the system
`void`	`setApplyWeightedMatchings(int enable)` Sets whether or not MUMPS should compute a weighted matching (maximum transversal) for the matrix (MUMPS parameter ICNTL(6)).
`void`	`setMaxRefinementSteps(int nsteps)` Sets the maximum number of iterative refinement steps that MUMPS should perform after a solve (MUMPS parameter ICNTL(10)).
`void`	`setMaxWorkingMemory(int mbytes)` Sets the maximum size of the working memory, in Mbytes, that MUMPS is allowed to allocate (MUMPS parameter ICNTL(23)).
`void`	`setNullPivotDetection(boolean enable)` Enables or disables the detection of null pivot rows (MUMPS parameter ICNTL(24)).
`void`	`setNullPivotThreshold(double thresh)` Sets the threshold used to identify null pivots (MUMPS parameter CNTL(3)), when null pivot detection is enabled.
`void`	`setReorderMethod(MumpsSolver.ReorderMethod method)` Sets the reorder method that should be used during the analyze phase to reduced factorization fill-in.
`void`	`setScaling(int value)` Sets the scaling which MUMPS applies to the matrix, as the value of the MUMPS parameter ICNTL(8).
`static void`	`setShowPerturbedPivots(boolean enable)` Enables/disables the "num perturbed pivots" message (which usually indicates a singular or ill-conditioned solve).
`void`	`setStaticPivotTolerance(double tol)` Sets the threshold used for static pivoting (MUMPS parameter CNTL(4)).
`void`	`setSymOrderingStrategy(int strategy)` Sets the ordering strategy that MUMPS uses for symmetric indefinite matrices (MUMPS parameter ICNTL(12)).
`void`	`setWorkspaceIncrease(int percent)` Sets the percentage by which MUMPS should increase the working space estimated during the analyze phase (MUMPS parameter ICNTL(14)).

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
```
  - WARN_INDEX_OUT_OF_RANGE
```
public static final int WARN_INDEX_OUT_OF_RANGE
```
    Warning bit (returned in INFOG(1)) indicating that entries with out-of-range indices were found and ignored.
    
    See Also:
    
    Constant Field Values
  - WARN_ZERO_SOLUTION
```
public static final int WARN_ZERO_SOLUTION
```
    Warning bit indicating that the max-norm of the solution is close to zero.
    
    See Also:
    
    Constant Field Values
  - WARN_COMPACT_MEMORY
```
public static final int WARN_COMPACT_MEMORY
```
    Warning bit indicating insufficient memory to compact the internal work array at the end of the factorization.
    
    See Also:
    
    Constant Field Values
  - WARN_REFINEMENT
```
public static final int WARN_REFINEMENT
```
    Warning bit indicating that iterative refinement did not converge within the allowed number of steps.
    
    See Also:
    
    Constant Field Values
  - WARN_RANK_REVEALING
```
public static final int WARN_RANK_REVEALING
```
    Warning bit returned by the rank revealing feature.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_SHOW_PERTURBED_PIVOTS
```
public static boolean DEFAULT_SHOW_PERTURBED_PIVOTS
```
- Constructor Detail
  - MumpsSolver
```
public MumpsSolver()
```
    Creates a new MumpsSolver object.
- Method Detail
  - isAvailable
```
public static boolean isAvailable()
```
    Returns true if the MUMPS solver is available. A solver might not be available if the MUMPS native libraries cannot be loaded for some reason.
    
    Returns:
    
    true if MUMPS 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 a singular or ill-conditioned solve). See getNumPerturbedPivots().
    
    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 MUMPS should perform after a solve (MUMPS parameter ICNTL(10)). Setting this to 0 (the MUMPS default) disables iterative refinement. Positive values specify a maximum number of steps, with a convergence test performed at each step, while negative values specify a fixed number of steps (-nsteps) with no convergence test. More iterative refinement steps will increase solution accuracy but slow down the solve.
    Note: MUMPS silently disables iterative refinement whenever more than one right hand side is solved for.
    
    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 MUMPS 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 MUMPS actually performed during the most recent call to solve() (MUMPS parameter INFOG(15)).
    
    Returns:
    
    number of iterative refinement steps actually performed
    
    See Also:
    
    getMaxRefinementSteps(), setMaxRefinementSteps(int)
  - getReorderMethod
```
public MumpsSolver.ReorderMethod getReorderMethod()
```
    Gets the reorder method that is used during the analyze phase to reduced factorization fill-in (MUMPS parameter ICNTL(7)).
    
    Returns:
    
    current reorder method
    
    See Also:
    
    setReorderMethod(maspack.solvers.MumpsSolver.ReorderMethod)
  - getReorderMethodUsed
```
public MumpsSolver.ReorderMethod getReorderMethodUsed()
```
    Returns the reorder method that MUMPS actually used during the most recent analyze phase (MUMPS parameter INFOG(7)). This may differ from the value returned by getReorderMethod(), either because DEFAULT was requested, or because the requested method was not available or not compatible with other settings.
    
    Returns:
    
    reorder method used by the most recent analyze
  - setReorderMethod
```
public void setReorderMethod(MumpsSolver.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 MUMPS to choose the method automatically. For the symmetric indefinite systems typically encountered in ArtiSynth, METIS is usually the best choice.
    
    Parameters:
    
    method - reorder method
    
    See Also:
    
    getReorderMethod()
  - setStaticPivotTolerance
```
public void setStaticPivotTolerance(double tol)
```
    Sets the threshold used for static pivoting (MUMPS parameter CNTL(4)). Static pivoting replaces pivots whose magnitude is smaller than the threshold by the threshold itself, thus perturbing the matrix instead of postponing the pivot. The number of pivots so modified is returned by getNumTinyPivots(). Values are interpreted as follows:
    
    tol < 0
    
    static pivoting is disabled (the MUMPS default);
    tol == 0
    
    static pivoting is enabled, with the threshold determined automatically as sqrt(eps)*norm(M);
    tol > 0
    
    static pivoting is enabled, using tol as an absolute threshold.
    
    Note: unlike the pivot perturbation used by Pardiso, this is an absolute quantity rather than a factor applied to a norm of the matrix. Also, MUMPS ignores static pivoting when null pivot detection is enabled (see setNullPivotDetection(boolean)), which is the default for this solver.
    
    Parameters:
    
    tol - static pivoting threshold
    
    See Also:
    
    getStaticPivotTolerance()
  - getStaticPivotTolerance
```
public double getStaticPivotTolerance()
```
    Returns the threshold used for static pivoting.
    
    Returns:
    
    static pivoting threshold
    
    See Also:
    
    setStaticPivotTolerance(double)
  - setNullPivotDetection
```
public void setNullPivotDetection(boolean enable)
```
    Enables or disables the detection of null pivot rows (MUMPS parameter ICNTL(24)). When enabled, pivots whose magnitude falls below the threshold described for setNullPivotThreshold(double) are treated as null and the factorization continues, with the number of such pivots returned by getNumNullPivots(). When disabled, a null pivot instead causes the factorization to fail with a NumericalException.
    This is enabled by default, since it most closely matches the behavior of Pardiso, which perturbs zero pivots and continues.
    
    Parameters:
    
    enable - if true, enables null pivot detection
    
    See Also:
    
    getNullPivotDetection()
  - getNullPivotDetection
```
public boolean getNullPivotDetection()
```
    Queries whether null pivot detection is enabled.
    
    Returns:
    
    true if null pivot detection is enabled
    
    See Also:
    
    setNullPivotDetection(boolean)
  - setNullPivotThreshold
```
public void setNullPivotThreshold(double thresh)
```
    Sets the threshold used to identify null pivots (MUMPS parameter CNTL(3)), when null pivot detection is enabled. Values are interpreted as follows:
    
    thresh > 0
    
    the threshold is thresh*norm(M);
    thresh == 0
    
    the threshold is determined automatically (the default);
    thresh < 0
    
    the threshold is the absolute value -thresh.
    
    Parameters:
    
    thresh - null pivot threshold
    
    See Also:
    
    getNullPivotThreshold()
  - getNullPivotThreshold
```
public double getNullPivotThreshold()
```
    Returns the threshold used to identify null pivots.
    
    Returns:
    
    null pivot threshold
    
    See Also:
    
    setNullPivotThreshold(double)
  - setScaling
```
public void setScaling(int value)
```
    Sets the scaling which MUMPS applies to the matrix, as the value of the MUMPS parameter ICNTL(8). The values relevant to the symmetric systems used by ArtiSynth are 0 (none), 1, 7 and 8 (computed during each factorization), and 77 (automatic, which for these systems usually means computed during the analysis).
    The default is -1, which lets the solver choose between analysis and factorization scaling for each matrix, since neither suits all of them and the choice also affects the ordering MUMPS selects. Setting any other value pins ICNTL(8) and disables that choice. The policy is described where it is implemented, in Mumps::adaptStrategy().
    
    Parameters:
    
    value - value for ICNTL(8)
    
    See Also:
    
    getScaling()
  - getScaling
```
public int getScaling()
```
    Returns the scaling which MUMPS applies to the matrix, as described for setScaling(int). If MUMPS was left to choose, the value it actually used is returned once a solve phase has been run.
    
    Returns:
    
    value of ICNTL(8)
    
    See Also:
    
    setScaling(int)
  - setApplyWeightedMatchings
```
public void setApplyWeightedMatchings(int enable)
```
    Sets whether or not MUMPS should compute a weighted matching (maximum transversal) for the matrix (MUMPS parameter ICNTL(6)). For unsymmetric matrices this permutes the matrix to a zero-free diagonal; for symmetric matrices it is used to identify 1 x 1 and 2 x 2 pivots, and is recommended for highly indefinite systems such as the saddle point problems arising in ArtiSynth. Weighted matchings are controlled by enable as follows: enable > 0 enables them, enable = 0 disables them, and enable < 0 causes MUMPS to choose automatically (the default). Weighted matchings are always disabled for SPD matrices.
    
    Parameters:
    
    enable - enables/disables weighted 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)
  - setSymOrderingStrategy
```
public void setSymOrderingStrategy(int strategy)
```
    Sets the ordering strategy that MUMPS uses for symmetric indefinite matrices (MUMPS parameter ICNTL(12)). Possible values are 0 (automatic choice, the default), 1 (usual ordering), 2 (ordering on the compressed graph) and 3 (constrained ordering, available only with the AMF reorder method). Setting this to 2 can significantly reduce the number of delayed pivots (see getNumDelayedPivots()) for augmented systems, at the cost of increased fill-in.
    
    Parameters:
    
    strategy - symmetric ordering strategy
    
    See Also:
    
    getSymOrderingStrategy()
  - getSymOrderingStrategy
```
public int getSymOrderingStrategy()
```
    Returns the ordering strategy used for symmetric indefinite matrices.
    
    Returns:
    
    symmetric ordering strategy
    
    See Also:
    
    setSymOrderingStrategy(int)
  - setWorkspaceIncrease
```
public void setWorkspaceIncrease(int percent)
```
    Sets the percentage by which MUMPS should increase the working space estimated during the analyze phase (MUMPS parameter ICNTL(14)). Setting this to a value < 0 causes MUMPS to use its default value (between 20 and 35 percent). Numerical pivoting can cause significantly more fill-in than was predicted by the analysis, in which case the factorization will fail because the working space is too small; this solver responds by automatically increasing the workspace and retrying, but setting a larger value here in advance will avoid the wasted factorizations.
    
    Parameters:
    
    percent - percentage increase in the estimated working space
    
    See Also:
    
    getWorkspaceIncrease()
  - getWorkspaceIncrease
```
public int getWorkspaceIncrease()
```
    Returns the percentage by which MUMPS increases the working space estimated during the analyze phase.
    
    Returns:
    
    percentage increase in the estimated working space
    
    See Also:
    
    setWorkspaceIncrease(int)
  - setMaxWorkingMemory
```
public void setMaxWorkingMemory(int mbytes)
```
    Sets the maximum size of the working memory, in Mbytes, that MUMPS is allowed to allocate (MUMPS parameter ICNTL(23)). Setting this to a value <= 0 (the default) places no limit other than that implied by setWorkspaceIncrease(int).
    
    Parameters:
    
    mbytes - maximum working memory, in Mbytes
    
    See Also:
    
    getMaxWorkingMemory()
  - getMaxWorkingMemory
```
public int getMaxWorkingMemory()
```
    Returns the maximum size of the working memory, in Mbytes, that MUMPS is allowed to allocate.
    
    Returns:
    
    maximum working memory, in Mbytes
    
    See Also:
    
    setMaxWorkingMemory(int)
  - getNumNonZerosInFactors
```
public long getNumNonZerosInFactors()
```
    Returns the number of non-zeros elements in the factorization. After a factor() call, this is the actual number (MUMPS parameter INFOG(29)); otherwise, it is the number estimated by the most recent analyze() call (MUMPS parameter INFOG(20)).
    
    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, MUMPS parameter INFOG(12)). For matrices that are not symmetric indefinite, -1 is returned.
    Note that when null pivot detection is enabled (the default), null pivots are excluded from this count, even if their sign is negative.
    
    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). MUMPS does not report this directly; it is inferred from the matrix size and the numbers of negative and null pivots. 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 pivots that were perturbed during the most recent numeric factorization (i.e., during the last factor() call). This is the sum of the null pivots detected (see getNumNullPivots()) and the tiny pivots modified by static pivoting (see getNumTinyPivots()); only one of these mechanisms can be active at a time. As with the perturbed pivots reported by Pardiso, a non-zero value generally indicates a singular, or very nearly singular, matrix.
    
    Returns:
    
    number of perturbed pivots
  - getNumNullPivots
```
public int getNumNullPivots()
```
    Returns the number of null pivot rows that were detected during the most recent numeric factorization (MUMPS parameter INFOG(28)), which corresponds to the deficiency of the matrix. This will be zero unless null pivot detection is enabled (see setNullPivotDetection(boolean)).
    
    Returns:
    
    number of null pivots
  - getNumTinyPivots
```
public int getNumTinyPivots()
```
    Returns the number of tiny pivots that were modified by static pivoting during the most recent numeric factorization (MUMPS parameter INFOG(25)). This will be zero unless static pivoting is enabled (see setStaticPivotTolerance(double)).
    
    Returns:
    
    number of tiny pivots
  - getNumDelayedPivots
```
public int getNumDelayedPivots()
```
    Returns the number of delayed pivots that occurred during the most recent numeric factorization (MUMPS parameter INFOG(13)). Delayed pivots arise from numerical pivoting and increase both fill-in and factorization time; a number exceeding 10 percent of the matrix size indicates numerical problems, which may be alleviated by adjusting setApplyWeightedMatchings(), setScaling(), or setSymOrderingStrategy().
    
    Returns:
    
    number of delayed pivots
  - getSPDZeroPivot
```
public int getSPDZeroPivot()
```
    If the solver detected null pivots during the most recent factorization, this method returns the row number of the first such pivot, as identified by the MUMPS PIVNUL_LIST array. Otherwise, 0 is returned. For an SPD matrix, this indicates the row at which the matrix was found not to be positive definite.
    
    Returns:
    
    location of first null pivot, if any
  - getPeakAnalysisMemoryUsage
```
public int getPeakAnalysisMemoryUsage()
```
    Returns the maximum amount of memory (in kbytes) that MUMPS estimated, during the most recent analyze() call, would be needed by a single process for an in-core factorization (MUMPS parameter INFOG(16)). MUMPS reports memory in Mbytes, so the returned value is a multiple of 1024.
    
    Returns:
    
    estimated peak memory usage for factorization.
  - getAnalysisMemoryUsage
```
public int getAnalysisMemoryUsage()
```
    Returns the total amount of memory (in kbytes), summed over all processes, that MUMPS estimated during the most recent analyze() call would be needed for an in-core factorization (MUMPS parameter INFOG(17)). MUMPS reports memory in Mbytes, so the returned value is a multiple of 1024.
    
    Returns:
    
    estimated total memory usage for factorization.
  - getFactorSolveMemoryUsage
```
public int getFactorSolveMemoryUsage()
```
    Returns the memory (in kbytes) actually used during the most recent factor() call (MUMPS parameter INFOG(21)). MUMPS reports memory in Mbytes, so the returned value is a multiple of 1024.
    
    Returns:
    
    memory actually used during factor and solve steps.
  - 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
  - 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.
    MUMPS does not provide iterative solves itself. Instead, the iteration is performed in the native wrapper, using the most recent factorization as a preconditioner and the supplied values for matrix products.
    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
  - getLastIterativeTimes
```
public double[] getLastIterativeTimes()
```
    Returns a time breakdown of the most recent call to iterativeSolve(double[], double[], double[]), 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 not available

Class MumpsSolver

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

WARN_INDEX_OUT_OF_RANGE

WARN_ZERO_SOLUTION

WARN_COMPACT_MEMORY

WARN_REFINEMENT

WARN_RANK_REVEALING

DEFAULT_SHOW_PERTURBED_PIVOTS

Constructor Detail

MumpsSolver

Method Detail

isAvailable

getInitErrorMessage

setShowPerturbedPivots

getShowPerturbedPivots

setMaxRefinementSteps

getMaxRefinementSteps

getNumRefinementSteps

getReorderMethod

getReorderMethodUsed

setReorderMethod

setStaticPivotTolerance

getStaticPivotTolerance

setNullPivotDetection

getNullPivotDetection

setNullPivotThreshold

getNullPivotThreshold

setScaling

getScaling

setApplyWeightedMatchings

getApplyWeightedMatchings

setSymOrderingStrategy

getSymOrderingStrategy

setWorkspaceIncrease

getWorkspaceIncrease

setMaxWorkingMemory

getMaxWorkingMemory

getNumNonZerosInFactors

getNumNegEigenvalues

getNumPosEigenvalues

getNumPerturbedPivots

getNumNullPivots

getNumTinyPivots

getNumDelayedPivots

getSPDZeroPivot

getPeakAnalysisMemoryUsage

getAnalysisMemoryUsage

getFactorSolveMemoryUsage

hasMultipleRhsSolves

hasIterativeSolves

iterativeSolve

getLastIterativeTimes