Integration und ODEs (scipy.integrate)

Integration von Funktionen, gegeben ein Funktionsobjekt

quad(func, a, b[, args, full_output, ...])	Berechnet ein bestimmtes Integral.
quad_vec(f, a, b[, epsabs, epsrel, norm, ...])	Adaptive Integration einer vektorwertigen Funktion.
cubature(f, a, b, *[, rule, rtol, atol, ...])	Adaptive Kubatur einer mehrdimensionalen array-wertigen Funktion.
dblquad(func, a, b, gfun, hfun[, args, ...])	Berechnet ein Doppelintegral.
tplquad(func, a, b, gfun, hfun, qfun, rfun)	Berechnet ein dreifaches (bestimmtes) Integral.
nquad(func, ranges[, args, opts, full_output])	Integration über mehrere Variablen.
tanhsinh(f, a, b, *[, args, log, maxlevel, ...])	Evaluiert ein konvergentes Integral numerisch mittels Tanh-Sinh-Quadratur.
fixed_quad(func, a, b[, args, n])	Berechnet ein bestimmtes Integral mittels Gauß-Quadratur mit fester Ordnung.
newton_cotes(rn[, equal])	Gibt Gewichte und Fehlerkoeffizienten für die Newton-Cotes-Integration zurück.
lebedev_rule(n)	Lebedev-Quadratur.
qmc_quad(func, a, b, *[, n_estimates, ...])	Berechnet ein Integral in N-Dimensionen mittels Quasi-Monte-Carlo-Quadratur.
IntegrationWarning	Warnung bei Problemen während der Integration.

Integration von Funktionen, gegeben feste Abtastpunkte

trapezoid(y[, x, dx, axis])	Integriert entlang der gegebenen Achse mit der zusammengesetzten Trapezregel.
cumulative_trapezoid(y[, x, dx, axis, initial])	Kumulative Integration von y(x) mittels der zusammengesetzten Trapezregel.
simpson(y[, x, dx, axis])	Integriert y(x) unter Verwendung von Abtastpunkten entlang der gegebenen Achse und der zusammengesetzten Simpsonschen Regel.
cumulative_simpson(y, *[, x, dx, axis, initial])	Kumulative Integration von y(x) mittels der zusammengesetzten Simpsonschen 1/3-Regel.
romb(y[, dx, axis, show])	Romberg-Integration unter Verwendung von Funktionsabtastungen.

Siehe auch

scipy.special für orthogonale Polynome (special) für Gauß-Quadraturwurzeln und Gewichte für andere Gewichtungsfaktoren und Bereiche.

Summation

nsum(f, a, b, *[, step, args, log, ...])

Berechnet eine konvergente endliche oder unendliche Reihe.

Lösen von Anfangswertproblemen für ODE-Systeme

Die Löser sind als einzelne Klassen implementiert, die direkt (Low-Level-Nutzung) oder über eine komfortable Funktion verwendet werden können.

solve_ivp(fun, t_span, y0[, method, t_eval, ...])	Löst ein Anfangswertproblem für ein System von ODEs.
RK23(fun, t0, y0, t_bound[, max_step, rtol, ...])	Explizite Runge-Kutta-Methode der Ordnung 3(2).
RK45(fun, t0, y0, t_bound[, max_step, rtol, ...])	Explizite Runge-Kutta-Methode der Ordnung 5(4).
DOP853(fun, t0, y0, t_bound[, max_step, ...])	Explizite Runge-Kutta-Methode der Ordnung 8.
Radau(fun, t0, y0, t_bound[, max_step, ...])	Implizite Runge-Kutta-Methode der Radau-IIA-Familie der Ordnung 5.
BDF(fun, t0, y0, t_bound[, max_step, rtol, ...])	Implizite Methode basierend auf Rückwärtsdifferenzformeln.
LSODA(fun, t0, y0, t_bound[, first_step, ...])	Adams/BDF-Methode mit automatischer Steifigkeitserkennung und -umschaltung.
OdeSolver(fun, t0, y0, t_bound, vectorized)	Basisklasse für ODE-Löser.
DenseOutput(t_old, t)	Basisklasse für lokale Interpolante über einen Schritt, der von einem ODE-Löser gemacht wurde.
OdeSolution(ts, interpolants[, alt_segment])	Kontinuierliche ODE-Lösung.

Alte API

Dies sind die früher für SciPy entwickelten Routinen. Sie wickeln ältere in Fortran implementierte Löser (hauptsächlich ODEPACK) ein. Obwohl die Schnittstelle zu ihnen nicht besonders praktisch ist und bestimmte Funktionen im Vergleich zur neuen API fehlen, sind die Löser selbst von guter Qualität und arbeiten aufgrund des kompilierten Fortran-Codes schnell. In einigen Fällen kann es sich lohnen, diese alte API zu verwenden.

odeint(func, y0, t[, args, Dfun, col_deriv, ...])	Integriert ein System gewöhnlicher Differentialgleichungen.
ode(f[, jac])	Eine generische Schnittstellenklasse für numerische Integratoren.
complex_ode(f[, jac])	Eine Wrapper-Klasse für ode für komplexe Systeme.
ODEintWarning	Warnung, die während der Ausführung von odeint ausgegeben wird.

Lösen von Randwertproblemen für ODE-Systeme

solve_bvp(fun, bc, x, y[, p, S, fun_jac, ...])

Löst ein Randwertproblem für ein System von ODEs.