Abstract type for statistics returned by a solver

Type for storing statistics returned by the majority of Krylov solvers. The fields are as follows:

• niter: The total number of iterations completed by the solver;
• solved: Indicates whether the solver successfully reached convergence (true if solved, false otherwise);
• inconsistent: Flags whether the system was detected as inconsistent (i.e., when b is not in the range of A);
• residuals: A vector containing the residual norms at each iteration;
• Aresiduals: A vector of A'-residual norms at each iteration;
• Acond: An estimate of the condition number of matrix A.
• timer: The elapsed time (in seconds) taken by the solver to complete all iterations;
• status: A string indicating the outcome of the solve, providing additional details beyond solved.

Type for storing statistics returned by CG-LANCZOS. The fields are as follows:

• niter
• solved
• residuals
• indefinite
• Anorm
• Acond
• timer
• status

Type for storing statistics returned by CG-LANCZOS-SHIFT and CGLS-LANCZOS-SHIFT. The fields are as follows:

• niter
• solved
• residuals
• indefinite
• Anorm
• Acond
• timer
• status

Type for storing statistics returned by SYMMLQ. The fields are as follows:

• niter
• solved
• residuals
• residualscg
• errors
• errorscg
• Anorm
• Acond
• timer
• status

Type for storing statistics returned by adjoint systems solvers BiLQR and TriLQR. The fields are as follows:

• niter
• solved_primal
• solved_dual
• residuals_primal
• residuals_dual
• timer
• status

Type for storing statistics returned by the LNLQ method. The fields are as follows:

• niter
• solved
• residuals
• errorwithbnd
• errorbndx
• errorbndy
• timer
• status

Type for storing statistics returned by the LSLQ method. The fields are as follows:

• niter
• solved
• inconsistent
• residuals
• Aresiduals
• err_lbnds
• errorwithbnd
• errubndslq
• errubndscg
• timer
• status

Type for storing statistics returned by LSMR. The fields are as follows:

• niter
• solved
• inconsistent
• residuals
• Aresiduals
• Acond
• Anorm
• xNorm
• timer
• status

Abstract type for using Krylov solvers in-place

Abstract type for using block Krylov solvers in-place

Type for storing the vectors required by the in-place version of MINRES.

The outer constructors

solver = MinresSolver(m, n, S; window :: Int=5)
solver = MinresSolver(A, b; window :: Int=5)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of MINARES.

The outer constructors

solver = MinaresSolver(m, n, S)
solver = MinaresSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CG.

The outer constructors

solver = CgSolver(m, n, S)
solver = CgSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CR.

The outer constructors

solver = CrSolver(m, n, S)
solver = CrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CAR.

The outer constructors

solver = CarSolver(m, n, S)
solver = CarSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of SYMMLQ.

The outer constructors

solver = SymmlqSolver(m, n, S)
solver = SymmlqSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CG-LANCZOS.

The outer constructors

solver = CgLanczosSolver(m, n, S)
solver = CgLanczosSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CG-LANCZOS-SHIFT.

The outer constructors

solver = CgLanczosShiftSolver(m, n, nshifts, S)
solver = CgLanczosShiftSolver(A, b, nshifts)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of MINRES-QLP.

The outer constructors

solver = MinresQlpSolver(m, n, S)
solver = MinresQlpSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of DIOM.

The outer constructors

solver = DiomSolver(m, n, memory, S)
solver = DiomSolver(A, b, memory = 20)

may be used in order to create these vectors. memory is set to n if the value given is larger than n. memory is an optional argument in the second constructor.

Type for storing the vectors required by the in-place version of FOM.

The outer constructors

solver = FomSolver(m, n, memory, S)
solver = FomSolver(A, b, memory = 20)

may be used in order to create these vectors. memory is set to n if the value given is larger than n. memory is an optional argument in the second constructor.

Type for storing the vectors required by the in-place version of DQGMRES.

The outer constructors

solver = DqgmresSolver(m, n, memory, S)
solver = DqgmresSolver(A, b, memory = 20)

may be used in order to create these vectors. memory is set to n if the value given is larger than n. memory is an optional argument in the second constructor.

Type for storing the vectors required by the in-place version of GMRES.

The outer constructors

solver = GmresSolver(m, n, memory, S)
solver = GmresSolver(A, b, memory = 20)

may be used in order to create these vectors. memory is set to n if the value given is larger than n. memory is an optional argument in the second constructor.

Type for storing the vectors required by the in-place version of USYMLQ.

The outer constructors

solver = UsymlqSolver(m, n, S)
solver = UsymlqSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of USYMQR.

The outer constructors

solver = UsymqrSolver(m, n, S)
solver = UsymqrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of TRICG.

The outer constructors

solver = TricgSolver(m, n, S)
solver = TricgSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of TRIMR.

The outer constructors

solver = TrimrSolver(m, n, S)
solver = TrimrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of TRILQR.

The outer constructors

solver = TrilqrSolver(m, n, S)
solver = TrilqrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CGS.

The outer constructorss

solver = CgsSolver(m, n, S)
solver = CgsSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of BICGSTAB.

The outer constructors

solver = BicgstabSolver(m, n, S)
solver = BicgstabSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of BILQ.

The outer constructors

solver = BilqSolver(m, n, S)
solver = BilqSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of QMR.

The outer constructors

solver = QmrSolver(m, n, S)
solver = QmrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of BILQR.

The outer constructors

solver = BilqrSolver(m, n, S)
solver = BilqrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CGLS.

The outer constructors

solver = CglsSolver(m, n, S)
solver = CglsSolver(A, b)

may be used in order to create these vectors.

Workspace for the in-place version of CGLS-LANCZOS-SHIFT.

The outer constructors:

solver = CglsLanczosShiftSolver(m, n, nshifts, S)
solver = CglsLanczosShiftSolver(A, b, nshifts)

can be used to initialize this workspace.

Type for storing the vectors required by the in-place version of CRLS.

The outer constructors

solver = CrlsSolver(m, n, S)
solver = CrlsSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CGNE.

The outer constructors

solver = CgneSolver(m, n, S)
solver = CgneSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CRMR.

The outer constructors

solver = CrmrSolver(m, n, S)
solver = CrmrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of LSLQ.

The outer constructors

solver = LslqSolver(m, n, S)
solver = LslqSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of LSQR.

The outer constructors

solver = LsqrSolver(m, n, S)
solver = LsqrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of LSMR.

The outer constructors

solver = LsmrSolver(m, n, S)
solver = LsmrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of LNLQ.

The outer constructors

solver = LnlqSolver(m, n, S)
solver = LnlqSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CRAIG.

The outer constructors

solver = CraigSolver(m, n, S)
solver = CraigSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of CRAIGMR.

The outer constructors

solver = CraigmrSolver(m, n, S)
solver = CraigmrSolver(A, b)

may be used in order to create these vectors.

Type for storing the vectors required by the in-place version of GPMR.

The outer constructors

solver = GpmrSolver(m, n, memory, S)
solver = GpmrSolver(A, b, memory = 20)

may be used in order to create these vectors. memory is set to n + m if the value given is larger than n + m. memory is an optional argument in the second constructor.

Type for storing the vectors required by the in-place version of FGMRES.

The outer constructors

solver = FgmresSolver(m, n, memory, S)
solver = FgmresSolver(A, b, memory = 20)

may be used in order to create these vectors. memory is set to n if the value given is larger than n. memory is an optional argument in the second constructor.

Type for storing the vectors required by the in-place version of BLOCK-GMRES.

The outer constructors

solver = BlockGmresSolver(m, n, p, memory, SV, SM)
solver = BlockGmresSolver(A, B, memory = 5)

may be used in order to create these vectors. memory is set to div(n,p) if the value given is larger than div(n,p). memory is an optional argument in the second constructor.

roots = roots_quadratic(q₂, q₁, q₀; nitref)

Find the real roots of the quadratic

q(x) = q₂ x² + q₁ x + q₀,

where q₂, q₁ and q₀ are real. Care is taken to avoid numerical cancellation. Optionally, nitref steps of iterative refinement may be performed to improve accuracy. By default, nitref=1.

(c, s, ρ) = sym_givens(a, b)

Numerically stable symmetric Givens reflection. Given a and b reals, return (c, s, ρ) such that

[ c  s ] [ a ] = [ ρ ]
[ s -c ] [ b ] = [ 0 ].

Numerically stable symmetric Givens reflection. Given a and b complexes, return (c, s, ρ) with c real and (s, ρ) complexes such that

[ c   s ] [ a ] = [ ρ ]
[ s̅  -c ] [ b ] = [ 0 ].

roots = to_boundary(n, x, d, radius; flip, xNorm2, dNorm2)

Given a trust-region radius radius, a vector x lying inside the trust-region and a direction d, return σ1 and σ2 such that

‖x + σi d‖ = radius, i = 1, 2

in the Euclidean norm. n is the length of vectors x and d. If known, ‖x‖² and ‖d‖² may be supplied with xNorm2 and dNorm2.

If flip is set to true, σ1 and σ2 are computed such that

‖x - σi d‖ = radius, i = 1, 2.

s = vec2str(x; ndisp)

Display an array in the form

[ -3.0e-01 -5.1e-01  1.9e-01 ... -2.3e-01 -4.4e-01  2.4e-01 ]

with (ndisp - 1)/2 elements on each side.

S = ktypeof(v)

Return the most relevant storage type S based on the type of v.

v = kzeros(S, n)

Create a vector of storage type S of length n only composed of zero.

v = kones(S, n)

Create a vector of storage type S of length n only composed of one.

M = vector_to_matrix(S)

Return the dense matrix storage type M related to the dense vector storage type S.

S = matrix_to_vector(M)

Return the dense vector storage type S related to the dense matrix storage type M.