scipy.sparse.linalg.

gmres#

scipy.sparse.linalg.gmres(A, b, x0=None, *, rtol=1e-05, atol=0.0, restart=None, maxiter=None, M=None, callback=None, callback_type=None)[Quelle]#

Löse Ax = b mit der Generalized Minimal RESidual Methode.

Parameter:

A{sparse array, ndarray, LinearOperator}

Die reelle oder komplexe N-mal-N-Matrix des linearen Systems. Alternativ kann A ein linearer Operator sein, der Ax erzeugen kann, z. B. mit scipy.sparse.linalg.LinearOperator.

bndarray

Rechte Seite des linearen Systems. Hat die Form (N,) oder (N,1).

x0ndarray

Startschätzung für die Lösung (standardmäßig ein Vektor von Nullen).

atol, rtolfloat

Parameter für den Konvergenztest. Für Konvergenz sollte norm(b - A @ x) <= max(rtol*norm(b), atol) erfüllt sein. Der Standardwert ist atol=0. und rtol=1e-5.

restartint, optional

Anzahl der Iterationen zwischen Neustarts. Größere Werte erhöhen die Kosten pro Iteration, können aber für die Konvergenz notwendig sein. Wenn weggelassen, wird min(20, n) verwendet.

maxiterint, optional

Maximale Anzahl von Iterationen (Neustartzyklen). Die Iteration wird nach maxiter Schritten beendet, auch wenn die angegebene Toleranz noch nicht erreicht wurde. Siehe callback_type.

M{sparse array, ndarray, LinearOperator}

Inverse des Vorkonditionierers von A. M sollte die Inverse von A approximieren und einfach zu lösen sein (siehe Hinweise). Effektive Vorkonditionierung verbessert dramatisch die Konvergenzrate, was bedeutet, dass weniger Iterationen benötigt werden, um eine gegebene Fehlertoleranz zu erreichen. Standardmäßig wird kein Vorkonditionierer verwendet. In dieser Implementierung wird eine linke Vorkonditionierung verwendet und das vorkonditionierte Residuum minimiert. Die endgültige Konvergenz wird jedoch anhand des Residuums b - A @ x getestet.

callbackfunction

Vom Benutzer bereitgestellte Funktion, die nach jeder Iteration aufgerufen wird. Sie wird als callback(args) aufgerufen, wobei args durch callback_type ausgewählt werden.

callback_type{‘x’, ‘pr_norm’, ‘legacy’}, optional

Angefordertes Argument für die Callback-Funktion

x: aktuelle Iteration (ndarray), wird bei jedem Neustart aufgerufen
pr_norm: relatives (vorkonditioniertes) Residuum (float), wird bei jeder inneren Iteration aufgerufen
legacy (Standard): wie pr_norm, aber ändert auch die Bedeutung von maxiter, um innere Iterationen anstelle von Neustartzyklen zu zählen.

Dieses Schlüsselwort hat keine Auswirkung, wenn callback nicht gesetzt ist.

Rückgabe:

xndarray

Die konvergierte Lösung.

infoint

Liefert Konvergenzinformationen: 0 : erfolgreicher Abbruch >0 : Konvergenz zur Toleranz nicht erreicht, Anzahl der Iterationen

Siehe auch

LinearOperator

Hinweise

Ein Vorkonditionierer P wird so gewählt, dass P nahe an A liegt, aber einfach zu lösen ist. Der von dieser Routine benötigte Vorkonditionierer-Parameter ist M = P^-1. Die Inverse sollte vorzugsweise nicht explizit berechnet werden. Verwenden Sie stattdessen die folgende Vorlage zur Erzeugung von M

# Construct a linear operator that computes P^-1 @ x.
import scipy.sparse.linalg as spla
M_x = lambda x: spla.spsolve(P, x)
M = spla.LinearOperator((n, n), M_x)

Beispiele

>>> import numpy as np
>>> from scipy.sparse import csc_array
>>> from scipy.sparse.linalg import gmres
>>> A = csc_array([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float)
>>> b = np.array([2, 4, -1], dtype=float)
>>> x, exitCode = gmres(A, b, atol=1e-5)
>>> print(exitCode)            # 0 indicates successful convergence
0
>>> np.allclose(A.dot(x), b)
True