Spezialfunktionen (scipy.special)#

Fast alle unten aufgeführten Funktionen akzeptieren NumPy-Arrays als Eingabeargumente sowie einzelne Zahlen. Das bedeutet, dass sie den Broadcasting- und automatischen Array-Looping-Regeln folgen. Technisch gesehen handelt es sich um NumPy Universal Functions. Funktionen, die keine NumPy-Arrays akzeptieren, werden in der Abschnittsbeschreibung mit einer Warnung gekennzeichnet.

Siehe auch

scipy.special.cython_special – Typisierte Cython-Versionen von Spezialfunktionen

Fehlerbehandlung#

Fehler werden durch Rückgabe von NaNs oder anderen geeigneten Werten behandelt. Einige der Spezialfunktionsroutinen können Warnungen ausgeben oder Ausnahmen auslösen, wenn ein Fehler auftritt. Standardmäßig ist dies deaktiviert, mit Ausnahme von Speicherzuordnungsfehlern, die zur Auslösung einer Ausnahme führen. Um den aktuellen Fehlerbehandlungsstatus abzufragen und zu steuern, werden die folgenden Funktionen bereitgestellt.

geterr()

Ruft die aktuelle Art der Behandlung von Spezialfunktionsfehlern ab.

seterr(**kwargs)

Legt fest, wie Spezialfunktionsfehler behandelt werden.

errstate(**kwargs)

Kontextmanager für die Fehlerbehandlung von Spezialfunktionen.

SpecialFunctionWarning

Warnung, die von Spezialfunktionen ausgegeben werden kann.

SpecialFunctionError

Ausnahme, die von Spezialfunktionen ausgelöst werden kann.

Verfügbare Funktionen#

Airy-Funktionen#

airy(z[, out])

Airy-Funktionen und ihre Ableitungen.

airye(z[, out])

Exponentiell skalierte Airy-Funktionen und ihre Ableitungen.

ai_zeros(nt)

Berechnet nt Nullen und Werte der Airy-Funktion Ai und ihrer Ableitung.

bi_zeros(nt)

Berechnet nt Nullen und Werte der Airy-Funktion Bi und ihrer Ableitung.

itairy(x[, out])

Integrale von Airy-Funktionen

Elliptische Funktionen und Integrale#

ellipj(u, m[, out])

Jacobische elliptische Funktionen

ellipk(m[, out])

Vollständiges elliptisches Integral erster Art.

ellipkm1(p[, out])

Vollständiges elliptisches Integral erster Art um m = 1

ellipkinc(phi, m[, out])

Unvollständiges elliptisches Integral erster Art

ellipe(m[, out])

Vollständiges elliptisches Integral zweiter Art

ellipeinc(phi, m[, out])

Unvollständiges elliptisches Integral zweiter Art

elliprc(x, y[, out])

Degeneriertes symmetrisches elliptisches Integral.

elliprd(x, y, z[, out])

Symmetrisches elliptisches Integral zweiter Art.

elliprf(x, y, z[, out])

Vollständig symmetrisches elliptisches Integral erster Art.

elliprg(x, y, z[, out])

Vollständig symmetrisches elliptisches Integral zweiter Art.

elliprj(x, y, z, p[, out])

Symmetrisches elliptisches Integral dritter Art.

Bessel-Funktionen#

jv(v, z[, out])

Bessel-Funktion erster Art mit reeller Ordnung und komplexem Argument.

jve(v, z[, out])

Exponentiell skalierte Bessel-Funktion erster Art der Ordnung v.

yn(n, x[, out])

Bessel-Funktion zweiter Art mit ganzzahliger Ordnung und reellem Argument.

yv(v, z[, out])

Bessel-Funktion zweiter Art mit reeller Ordnung und komplexem Argument.

yve(v, z[, out])

Exponentiell skalierte Bessel-Funktion zweiter Art mit reeller Ordnung.

kn(n, x[, out])

Modifizierte Bessel-Funktion zweiter Art mit ganzzahliger Ordnung n

kv(v, z[, out])

Modifizierte Bessel-Funktion zweiter Art mit reeller Ordnung v

kve(v, z[, out])

Exponentiell skalierte modifizierte Bessel-Funktion zweiter Art.

iv(v, z[, out])

Modifizierte Bessel-Funktion erster Art mit reeller Ordnung.

ive(v, z[, out])

Exponentiell skalierte modifizierte Bessel-Funktion erster Art.

hankel1(v, z[, out])

Hankel-Funktion erster Art

hankel1e(v, z[, out])

Exponentiell skalierte Hankel-Funktion erster Art

hankel2(v, z[, out])

Hankel-Funktion zweiter Art

hankel2e(v, z[, out])

Exponentiell skalierte Hankel-Funktion zweiter Art

wright_bessel(a, b, x[, out])

Verallgemeinerte Wright-Bessel-Funktion.

log_wright_bessel(a, b, x[, out])

Natürlicher Logarithmus der verallgemeinerten Wright-Bessel-Funktion, siehe wright_bessel.

Die folgende Funktion akzeptiert keine NumPy-Arrays (sie ist keine universelle Funktion)

lmbda(v, x)

Jahnke-Emden Lambda-Funktion, Lambdav(x).

Nullstellen von Bessel-Funktionen#

Die folgenden Funktionen akzeptieren keine NumPy-Arrays (sie sind keine universellen Funktionen)

jnjnp_zeros(nt)

Berechnet Nullstellen von Bessel-Funktionen Jn und Jn' ganzzahliger Ordnung.

jnyn_zeros(n, nt)

Berechnet nt Nullstellen der Bessel-Funktionen Jn(x), Jn'(x), Yn(x) und Yn'(x).

jn_zeros(n, nt)

Berechnet Nullstellen von Bessel-Funktionen Jn ganzzahliger Ordnung.

jnp_zeros(n, nt)

Berechnet Nullstellen von Ableitungen von Bessel-Funktionen Jn' ganzzahliger Ordnung.

yn_zeros(n, nt)

Berechnet Nullstellen der Bessel-Funktion Yn(x) ganzzahliger Ordnung.

ynp_zeros(n, nt)

Berechnet Nullstellen von Ableitungen der Bessel-Funktion Yn'(x) ganzzahliger Ordnung.

y0_zeros(nt[, complex])

Berechnet nt Nullen der Bessel-Funktion Y0(z) und ihre Ableitung an jeder Nullstelle.

y1_zeros(nt[, complex])

Berechnet nt Nullen der Bessel-Funktion Y1(z) und ihre Ableitung an jeder Nullstelle.

y1p_zeros(nt[, complex])

Berechnet nt Nullen der Bessel-Ableitung Y1'(z) und ihren Wert an jeder Nullstelle.

Schnellere Versionen gängiger Bessel-Funktionen#

j0(x[, out])

Bessel-Funktion erster Art der Ordnung 0.

j1(x[, out])

Bessel-Funktion erster Art der Ordnung 1.

y0(x[, out])

Bessel-Funktion zweiter Art der Ordnung 0.

y1(x[, out])

Bessel-Funktion zweiter Art der Ordnung 1.

i0(x[, out])

Modifizierte Bessel-Funktion der Ordnung 0.

i0e(x[, out])

Exponentiell skalierte modifizierte Bessel-Funktion der Ordnung 0.

i1(x[, out])

Modifizierte Bessel-Funktion der Ordnung 1.

i1e(x[, out])

Exponentiell skalierte modifizierte Bessel-Funktion der Ordnung 1.

k0(x[, out])

Modifizierte Bessel-Funktion zweiter Art der Ordnung 0, \(K_0\).

k0e(x[, out])

Exponentiell skalierte modifizierte Bessel-Funktion K der Ordnung 0

k1(x[, out])

Modifizierte Bessel-Funktion zweiter Art der Ordnung 1, \(K_1(x)\).

k1e(x[, out])

Exponentiell skalierte modifizierte Bessel-Funktion K der Ordnung 1

Integrale von Bessel-Funktionen#

itj0y0(x[, out])

Integrale von Bessel-Funktionen erster Art der Ordnung 0.

it2j0y0(x[, out])

Mit Bessel-Funktionen erster Art der Ordnung 0 verwandte Integrale.

iti0k0(x[, out])

Integrale von modifizierten Bessel-Funktionen der Ordnung 0.

it2i0k0(x[, out])

Mit modifizierten Bessel-Funktionen der Ordnung 0 verwandte Integrale.

besselpoly(a, lmb, nu[, out])

Gewichtetes Integral der Bessel-Funktion erster Art.

Ableitungen von Bessel-Funktionen#

jvp(v, z[, n])

Berechnet Ableitungen von Bessel-Funktionen erster Art.

yvp(v, z[, n])

Berechnet Ableitungen von Bessel-Funktionen zweiter Art.

kvp(v, z[, n])

Berechnet Ableitungen der modifizierten Bessel-Funktion Kv(z) mit reeller Ordnung

ivp(v, z[, n])

Berechnet Ableitungen von modifizierten Bessel-Funktionen erster Art.

h1vp(v, z[, n])

Berechnet Ableitungen der Hankel-Funktion H1v(z) bezüglich z.

h2vp(v, z[, n])

Berechnet Ableitungen der Hankel-Funktion H2v(z) bezüglich z.

Sphärische Bessel-Funktionen#

spherical_jn(n, z[, derivative])

Sphärische Bessel-Funktion erster Art oder ihre Ableitung.

spherical_yn(n, z[, derivative])

Sphärische Bessel-Funktion zweiter Art oder ihre Ableitung.

spherical_in(n, z[, derivative])

Modifizierte sphärische Bessel-Funktion erster Art oder ihre Ableitung.

spherical_kn(n, z[, derivative])

Modifizierte sphärische Bessel-Funktion zweiter Art oder ihre Ableitung.

Riccati-Bessel-Funktionen#

Die folgenden Funktionen akzeptieren keine NumPy-Arrays (sie sind keine universellen Funktionen)

riccati_jn(n, x)

Berechnet Riccati-Bessel-Funktion erster Art und ihre Ableitung.

riccati_yn(n, x)

Berechnet Riccati-Bessel-Funktion zweiter Art und ihre Ableitung.

Struve-Funktionen#

struve(v, x[, out])

Struve-Funktion.

modstruve(v, x[, out])

Modifizierte Struve-Funktion.

itstruve0(x[, out])

Integral der Struve-Funktion der Ordnung 0.

it2struve0(x[, out])

Mit der Struve-Funktion der Ordnung 0 verwandtes Integral.

itmodstruve0(x[, out])

Integral der modifizierten Struve-Funktion der Ordnung 0.

Rohe statistische Funktionen#

Siehe auch

scipy.stats: Freundliche Versionen dieser Funktionen.

Binomialverteilung#

bdtr(k, n, p[, out])

Kumulative Verteilungsfunktion der Binomialverteilung.

bdtrc(k, n, p[, out])

Überlebensfunktion der Binomialverteilung.

bdtri(k, n, y[, out])

Inverse Funktion zu bdtr bezüglich p.

bdtrik(y, n, p[, out])

Inverse Funktion zu bdtr bezüglich k.

bdtrin(k, y, p[, out])

Inverse Funktion zu bdtr bezüglich n.

Betaverteilung#

btdtria(p, b, x[, out])

Inverse von betainc bezüglich a.

btdtrib(a, p, x[, out])

Inverse von betainc bezüglich b.

F-Verteilung#

fdtr(dfn, dfd, x[, out])

Kumulative Verteilungsfunktion der F-Verteilung.

fdtrc(dfn, dfd, x[, out])

Überlebensfunktion der F-Verteilung.

fdtri(dfn, dfd, p[, out])

Das p-te Quantil der F-Verteilung.

fdtridfd(dfn, p, x[, out])

Inverse zu fdtr vs dfd

Gammaverteilung#

gdtr(a, b, x[, out])

Kumulative Verteilungsfunktion der Gammaverteilung.

gdtrc(a, b, x[, out])

Überlebensfunktion der Gammaverteilung.

gdtria(p, b, x[, out])

Inverse von gdtr vs a.

gdtrib(a, p, x[, out])

Inverse von gdtr vs b.

gdtrix(a, b, p[, out])

Inverse von gdtr vs x.

Negative Binomialverteilung#

nbdtr(k, n, p[, out])

Kumulative Verteilungsfunktion der negativen Binomialverteilung.

nbdtrc(k, n, p[, out])

Überlebensfunktion der negativen Binomialverteilung.

nbdtri(k, n, y[, out])

Gibt die Inverse bezüglich des Parameters p von y = nbdtr(k, n, p) zurück, der kumulativen Verteilungsfunktion der negativen Binomialverteilung.

nbdtrik(y, n, p[, out])

Perzentilfunktion der negativen Binomialverteilung.

nbdtrin(k, y, p[, out])

Inverse von nbdtr vs n.

Nichtzentrale F-Verteilung#

ncfdtr(dfn, dfd, nc, f[, out])

Kumulative Verteilungsfunktion der nichtzentralen F-Verteilung.

ncfdtridfd(dfn, p, nc, f[, out])

Berechne Freiheitsgrade (Nenner) für die nichtzentrale F-Verteilung.

ncfdtridfn(p, dfd, nc, f[, out])

Berechne Freiheitsgrade (Zähler) für die nichtzentrale F-Verteilung.

ncfdtri(dfn, dfd, nc, p[, out])

Inverse bezüglich f der KVF der nichtzentralen F-Verteilung.

ncfdtrinc(dfn, dfd, p, f[, out])

Berechne den Nichtzentralitätsparameter für die nichtzentrale F-Verteilung.

Nichtzentrale t-Verteilung#

nctdtr(df, nc, t[, out])

Kumulative Verteilungsfunktion der nichtzentralen t-Verteilung.

nctdtridf(p, nc, t[, out])

Berechne Freiheitsgrade für die nichtzentrale t-Verteilung.

nctdtrit(df, nc, p[, out])

Inverse kumulative Verteilungsfunktion der nichtzentralen t-Verteilung.

nctdtrinc(df, p, t[, out])

Berechne Nichtzentralitätsparameter für die nichtzentrale t-Verteilung.

Normalverteilung#

nrdtrimn(p, std, x[, out])

Berechne den Mittelwert einer Normalverteilung bei gegebenen anderen Parametern.

nrdtrisd(mn, p, x[, out])

Berechne die Standardabweichung einer Normalverteilung bei gegebenen anderen Parametern.

ndtr(x[, out])

Kumulative Verteilung der Standardnormalverteilung.

log_ndtr(x[, out])

Logarithmus der gaußschen kumulativen Verteilungsfunktion.

ndtri(y[, out])

Inverse von ndtr vs x

ndtri_exp(y[, out])

Inverse von log_ndtr vs x.

Poisson-Verteilung#

pdtr(k, m[, out])

Poisson kumulative Verteilungsfunktion.

pdtrc(k, m[, out])

Poisson Überlebensfunktion

pdtri(k, y[, out])

Inverse zu pdtr vs m

pdtrik(p, m[, out])

Inverse zu pdtr vs k.

Student-t-Verteilung#

stdtr(df, t[, out])

Student-t-Verteilung kumulative Verteilungsfunktion

stdtridf(p, t[, out])

Inverse von stdtr vs df

stdtrit(df, p[, out])

Das p-te Quantil der Student-t-Verteilung.

Chi-Quadrat-Verteilung#

chdtr(v, x[, out])

Chi-Quadrat kumulative Verteilungsfunktion.

chdtrc(v, x[, out])

Chi-Quadrat Überlebensfunktion.

chdtri(v, p[, out])

Inverse zu chdtrc bezüglich x.

chdtriv(p, x[, out])

Inverse zu chdtr bezüglich v.

Nichtzentrale Chi-Quadrat-Verteilung#

chndtr(x, df, nc[, out])

Nichtzentrale Chi-Quadrat kumulative Verteilungsfunktion

chndtridf(x, p, nc[, out])

Inverse zu chndtr vs df

chndtrinc(x, df, p[, out])

Inverse zu chndtr vs nc

chndtrix(p, df, nc[, out])

Inverse zu chndtr vs x

Kolmogorow-Verteilung#

smirnov(n, d[, out])

Kolmogorow-Smirnow komplementäre kumulative Verteilungsfunktion

smirnovi(n, p[, out])

Inverse zu smirnov

kolmogorov(y[, out])

Komplementäre kumulative Verteilungsfunktion (Überlebensfunktion) der Kolmogorow-Verteilung.

kolmogi(p[, out])

Inverse Überlebensfunktion der Kolmogorow-Verteilung

Box-Cox-Transformation#

boxcox(x, lmbda[, out])

Berechne die Box-Cox-Transformation.

boxcox1p(x, lmbda[, out])

Berechne die Box-Cox-Transformation von 1 + x.

inv_boxcox(y, lmbda[, out])

Berechne die Inverse der Box-Cox-Transformation.

inv_boxcox1p(y, lmbda[, out])

Berechne die Inverse der Box-Cox-Transformation.

Sigmoidale Funktionen#

logit(x[, out])

Logit ufunc für ndarrays.

expit(x[, out])

Expit (auch bekannt als

log_expit(x[, out])

Logarithmus der logistischen Sigmoidfunktion.

Sonstiges#

tklmbda(x, lmbda[, out])

Kumulative Verteilungsfunktion der Tukey-Lambda-Verteilung.

owens_t(h, a[, out])

Owen's T-Funktion.

Informationstheoretische Funktionen#

entr(x[, out])

Elementweise Funktion zur Berechnung der Entropie.

rel_entr(x, y[, out])

Elementweise Funktion zur Berechnung der relativen Entropie.

kl_div(x, y[, out])

Elementweise Funktion zur Berechnung der Kullback-Leibler-Divergenz.

huber(delta, r[, out])

Huber-Verlustfunktion.

pseudo_huber(delta, r[, out])

Pseudo-Huber-Verlustfunktion.

Fehlerfunktion und Fresnel-Integrale#

erf(z[, out])

Gibt die Fehlerfunktion für komplexe Argumente zurück.

erfc(x[, out])

Komplementäre Fehlerfunktion, 1 - erf(x).

erfcx(x[, out])

Skalierte komplementäre Fehlerfunktion, exp(x**2) * erfc(x).

erfi(z[, out])

Imaginäre Fehlerfunktion, -i erf(i z).

erfinv(y[, out])

Inverse der Fehlerfunktion.

erfcinv(y[, out])

Inverse der komplementären Fehlerfunktion.

wofz(z[, out])

Faddeeva-Funktion

dawsn(x[, out])

Dawson-Integral.

fresnel(z[, out])

Fresnel-Integrale.

fresnel_zeros(nt)

Berechne nt komplexe Nullstellen der Sinus- und Kosinus-Fresnel-Integrale S(z) und C(z).

modfresnelp(x[, out])

Modifizierte positive Fresnel-Integrale

modfresnelm(x[, out])

Modifizierte negative Fresnel-Integrale

voigt_profile(x, sigma, gamma[, out])

Voigt-Profil.

Die folgenden Funktionen akzeptieren keine NumPy-Arrays (sie sind keine universellen Funktionen)

erf_zeros(nt)

Berechne die ersten nt Nullstellen im ersten Quadranten, geordnet nach Betrag.

fresnelc_zeros(nt)

Berechne nt komplexe Nullstellen des Kosinus-Fresnel-Integrals C(z).

fresnels_zeros(nt)

Berechne nt komplexe Nullstellen des Sinus-Fresnel-Integrals S(z).

Legendre-Funktionen#

legendre_p(n, z, *[, diff_n])

Legendre-Polynom der ersten Art.

legendre_p_all(n, z, *[, diff_n])

Alle Legendre-Polynome der ersten Art bis zum angegebenen Grad n.

assoc_legendre_p(n, m, z, *[, branch_cut, ...])

Assoziierte Legendre-Funktion der ersten Art.

assoc_legendre_p_all(n, m, z, *[, ...])

Alle assoziierten Legendre-Funktionen der ersten Art bis zum angegebenen Grad n und Ordnung m.

sph_legendre_p(n, m, theta, *[, diff_n])

Sphärische Legendre-Funktion der ersten Art.

sph_legendre_p_all(n, m, theta, *[, diff_n])

Alle sphärischen Legendre-Funktionen der ersten Art bis zum angegebenen Grad n und Ordnung m.

sph_harm_y(n, m, theta, phi, *[, diff_n])

Sphärische Harmonische.

sph_harm_y_all(n, m, theta, phi, *[, diff_n])

Alle sphärischen Harmonischen bis zum angegebenen Grad n und Ordnung m.

Die folgenden Funktionen werden zugunsten der oben genannten, die eine flexiblere und konsistentere Schnittstelle bieten, deprecatiert.

lpmv(m, v, x[, out])

Assoziierte Legendre-Funktion von ganzzahligem Grad und reellem Nenner.

sph_harm(m, n, theta, phi[, out])

Berechne sphärische Harmonische.

clpmn(m, n, z[, type])

Assoziierte Legendre-Funktion der ersten Art für komplexe Argumente.

lpn(n, z)

Legendre-Funktion der ersten Art.

lqn(n, z)

Legendre-Funktion der zweiten Art.

lpmn(m, n, z)

Sequenz von assoziierten Legendre-Funktionen der ersten Art.

lqmn(m, n, z)

Sequenz von assoziierten Legendre-Funktionen der zweiten Art.

Ellipsoidale Harmonische#

ellip_harm(h2, k2, n, p, s[, signm, signn])

Ellipsoidale harmonische Funktionen E^p_n(l)

ellip_harm_2(h2, k2, n, p, s)

Ellipsoidale harmonische Funktionen F^p_n(l)

ellip_normal(h2, k2, n, p)

Ellipsoidale harmonische Normierungskonstanten gamma^p_n

Orthogonale Polynome#

Die folgenden Funktionen werten Werte von orthogonalen Polynomen aus

assoc_laguerre(x, n[, k])

Berechne das verallgemeinerte (assoziierte) Laguerre-Polynom vom Grad n und Ordnung k.

eval_legendre(n, x[, out])

Auswertung des Legendre-Polynoms an einem Punkt.

eval_chebyt(n, x[, out])

Auswertung des Chebyshev-Polynoms der ersten Art an einem Punkt.

eval_chebyu(n, x[, out])

Auswertung des Chebyshev-Polynoms der zweiten Art an einem Punkt.

eval_chebyc(n, x[, out])

Auswertung des Chebyshev-Polynoms der ersten Art im Intervall [-2, 2] an einem Punkt.

eval_chebys(n, x[, out])

Auswertung des Chebyshev-Polynoms der zweiten Art im Intervall [-2, 2] an einem Punkt.

eval_jacobi(n, alpha, beta, x[, out])

Auswertung des Jacobi-Polynoms an einem Punkt.

eval_laguerre(n, x[, out])

Auswertung des Laguerre-Polynoms an einem Punkt.

eval_genlaguerre(n, alpha, x[, out])

Auswertung des verallgemeinerten Laguerre-Polynoms an einem Punkt.

eval_hermite(n, x[, out])

Auswertung des Physik-Hermite-Polynoms an einem Punkt.

eval_hermitenorm(n, x[, out])

Auswertung des Wahrscheinlichkeits- (normalisierten) Hermite-Polynoms an einem Punkt.

eval_gegenbauer(n, alpha, x[, out])

Auswertung des Gegenbauer-Polynoms an einem Punkt.

eval_sh_legendre(n, x[, out])

Evaluiere verschobenes Legendre-Polynom an einem Punkt.

eval_sh_chebyt(n, x[, out])

Evaluiere verschobenes Chebyshev-Polynom erster Art an einem Punkt.

eval_sh_chebyu(n, x[, out])

Evaluiere verschobenes Chebyshev-Polynom zweiter Art an einem Punkt.

eval_sh_jacobi(n, p, q, x[, out])

Evaluiere verschobenes Jacobi-Polynom an einem Punkt.

Die folgenden Funktionen berechnen Wurzeln und Quadratur-Gewichte für orthogonale Polynome

roots_legendre(n[, mu])

Gauss-Legendre-Quadratur.

roots_chebyt(n[, mu])

Gauss-Chebyshev-Quadratur (erster Art).

roots_chebyu(n[, mu])

Gauss-Chebyshev-Quadratur (zweiter Art).

roots_chebyc(n[, mu])

Gauss-Chebyshev-Quadratur (erster Art).

roots_chebys(n[, mu])

Gauss-Chebyshev-Quadratur (zweiter Art).

roots_jacobi(n, alpha, beta[, mu])

Gauss-Jacobi-Quadratur.

roots_laguerre(n[, mu])

Gauss-Laguerre-Quadratur.

roots_genlaguerre(n, alpha[, mu])

Gauss-verallgemeinerte Laguerre-Quadratur.

roots_hermite(n[, mu])

Gauss-Hermite-Quadratur (Physiker).

roots_hermitenorm(n[, mu])

Gauss-Hermite-Quadratur (Statistiker).

roots_gegenbauer(n, alpha[, mu])

Gauss-Gegenbauer-Quadratur.

roots_sh_legendre(n[, mu])

Gauss-Legendre-Quadratur (verschoben).

roots_sh_chebyt(n[, mu])

Gauss-Chebyshev-Quadratur (erster Art, verschoben).

roots_sh_chebyu(n[, mu])

Gauss-Chebyshev-Quadratur (zweiter Art, verschoben).

roots_sh_jacobi(n, p1, q1[, mu])

Gauss-Jacobi-Quadratur (verschoben).

Die folgenden Funktionen geben die Polynomkoeffizienten in orthopoly1d-Objekten zurück, die ähnlich wie numpy.poly1d funktionieren. Die Klasse orthopoly1d hat auch ein Attribut weights, das die Wurzeln, Gewichte und Gesamtgewichte für die entsprechende Form der Gauß-Quadratur zurückgibt. Diese werden in einem n x 3-Array zurückgegeben, wobei die Wurzeln in der ersten Spalte, die Gewichte in der zweiten Spalte und die Gesamtgewichte in der letzten Spalte stehen. Beachten Sie, dass orthopoly1d-Objekte bei der Durchführung von Arithmetik in poly1d-Objekte umgewandelt werden und dabei Informationen über das ursprüngliche orthogonale Polynom verloren gehen.

legendre(n[, monic])

Legendre-Polynom.

chebyt(n[, monic])

Chebyshev-Polynom erster Art.

chebyu(n[, monic])

Chebyshev-Polynom zweiter Art.

chebyc(n[, monic])

Chebyshev-Polynom erster Art auf \([-2, 2]\).

chebys(n[, monic])

Chebyshev-Polynom zweiter Art auf \([-2, 2]\).

jacobi(n, alpha, beta[, monic])

Jacobi-Polynom.

laguerre(n[, monic])

Laguerre-Polynom.

genlaguerre(n, alpha[, monic])

Verallgemeinertes (assoziiertes) Laguerre-Polynom.

hermite(n[, monic])

Hermite-Polynom (Physiker).

hermitenorm(n[, monic])

Normiertes Hermite-Polynom (Statistiker).

gegenbauer(n, alpha[, monic])

Gegenbauer- (Ultrasphärisches) Polynom.

sh_legendre(n[, monic])

Verschobenes Legendre-Polynom.

sh_chebyt(n[, monic])

Verschobenes Chebyshev-Polynom erster Art.

sh_chebyu(n[, monic])

Verschobenes Chebyshev-Polynom zweiter Art.

sh_jacobi(n, p, q[, monic])

Verschobenes Jacobi-Polynom.

Warnung

Die Berechnung von Werten für Polynome hoher Ordnung (ungefähr Ordnung > 20) mittels Polynomkoeffizienten ist numerisch instabil. Zur Auswertung von Polynomwerten sollten stattdessen die eval_*-Funktionen verwendet werden.

Hypergeometrische Funktionen#

hyp2f1(a, b, c, z[, out])

Gaußsche hypergeometrische Funktion 2F1(a, b; c; z)

hyp1f1(a, b, x[, out])

Konfluente hypergeometrische Funktion 1F1.

hyperu(a, b, x[, out])

Konfluente hypergeometrische Funktion U

hyp0f1(v, z[, out])

Konfluenter hypergeometrischer Grenzwert 0F1.

Parabolische Zylinderfunktionen#

pbdv(v, x[, out])

Parabolische Zylinderfunktion D

pbvv(v, x[, out])

Parabolische Zylinderfunktion V

pbwa(a, x[, out])

Parabolische Zylinderfunktion W.

Die folgenden Funktionen akzeptieren keine NumPy-Arrays (sie sind keine universellen Funktionen)

pbdv_seq(v, x)

Parabolische Zylinderfunktionen Dv(x) und deren Ableitungen.

pbvv_seq(v, x)

Parabolische Zylinderfunktionen Vv(x) und deren Ableitungen.

pbdn_seq(n, z)

Parabolische Zylinderfunktionen Dn(z) und deren Ableitungen.

Sphäroidale Wellenfunktionen#

pro_ang1(m, n, c, x[, out])

Prolate sphäroidale Winkel-Funktion erster Art und ihre Ableitung

pro_rad1(m, n, c, x[, out])

Prolate sphäroidale Radial-Funktion erster Art und ihre Ableitung

pro_rad2(m, n, c, x[, out])

Prolate sphäroidale Radial-Funktion zweiter Art und ihre Ableitung

obl_ang1(m, n, c, x[, out])

Oblate sphäroidale Winkel-Funktion erster Art und ihre Ableitung

obl_rad1(m, n, c, x[, out])

Oblate sphäroidale Radial-Funktion erster Art und ihre Ableitung

obl_rad2(m, n, c, x[, out])

Oblate sphäroidale Radial-Funktion zweiter Art und ihre Ableitung.

pro_cv(m, n, c[, out])

Charakteristischer Wert der prolate sphäroidalen Funktion

obl_cv(m, n, c[, out])

Charakteristischer Wert der oblate sphäroidalen Funktion

pro_cv_seq(m, n, c)

Charakteristische Werte für prolate sphäroidale Wellenfunktionen.

obl_cv_seq(m, n, c)

Charakteristische Werte für oblate sphäroidale Wellenfunktionen.

Die folgenden Funktionen erfordern einen vorab berechneten charakteristischen Wert

pro_ang1_cv(m, n, c, cv, x[, out])

Prolate sphäroidale Winkel-Funktion pro_ang1 für vorab berechneten charakteristischen Wert

pro_rad1_cv(m, n, c, cv, x[, out])

Prolate sphäroidale Radial-Funktion pro_rad1 für vorab berechneten charakteristischen Wert

pro_rad2_cv(m, n, c, cv, x[, out])

Prolate sphäroidale Radial-Funktion pro_rad2 für vorab berechneten charakteristischen Wert

obl_ang1_cv(m, n, c, cv, x[, out])

Oblate sphäroidale Winkel-Funktion obl_ang1 für vorab berechneten charakteristischen Wert

obl_rad1_cv(m, n, c, cv, x[, out])

Oblate sphäroidale Radial-Funktion obl_rad1 für vorab berechneten charakteristischen Wert

obl_rad2_cv(m, n, c, cv, x[, out])

Oblate sphäroidale Radial-Funktion obl_rad2 für vorab berechneten charakteristischen Wert

Kelvin-Funktionen#

kelvin(x[, out])

Kelvin-Funktionen als komplexe Zahlen

kelvin_zeros(nt)

Berechne nt Nullstellen aller Kelvin-Funktionen.

ber(x[, out])

Kelvin-Funktion ber.

bei(x[, out])

Kelvin-Funktion bei.

berp(x[, out])

Ableitung der Kelvin-Funktion ber.

beip(x[, out])

Ableitung der Kelvin-Funktion bei.

ker(x[, out])

Kelvin-Funktion ker.

kei(x[, out])

Kelvin-Funktion kei.

kerp(x[, out])

Ableitung der Kelvin-Funktion ker.

keip(x[, out])

Ableitung der Kelvin-Funktion kei.

Die folgenden Funktionen akzeptieren keine NumPy-Arrays (sie sind keine universellen Funktionen)

ber_zeros(nt)

Berechne nt Nullstellen der Kelvin-Funktion ber.

bei_zeros(nt)

Berechne nt Nullstellen der Kelvin-Funktion bei.

berp_zeros(nt)

Berechne nt Nullstellen der Ableitung der Kelvin-Funktion ber.

beip_zeros(nt)

Berechne nt Nullstellen der Ableitung der Kelvin-Funktion bei.

ker_zeros(nt)

Berechne nt Nullstellen der Kelvin-Funktion ker.

kei_zeros(nt)

Berechne nt Nullstellen der Kelvin-Funktion kei.

kerp_zeros(nt)

Berechne nt Nullstellen der Ableitung der Kelvin-Funktion ker.

keip_zeros(nt)

Berechne nt Nullstellen der Ableitung der Kelvin-Funktion kei.

Kombinatorik#

comb(N, k, *[, exact, repetition])

Die Anzahl der Kombinationen von N Dingen, die auf einmal mit k genommen werden.

perm(N, k[, exact])

Permutationen von N Dingen, die auf einmal mit k genommen werden, d.h. k-Permutationen von N.

stirling2(N, K, *[, exact])

Generiere Stirling-Zahl(en) zweiter Art.

Andere spezielle Funktionen#

agm(a, b[, out])

Berechne das arithmetisch-geometrische Mittel von a und b.

bernoulli(n)

Bernoulli-Zahlen B0..Bn (einschließlich).

binom(x, y[, out])

Binomialkoeffizient, betrachtet als Funktion von zwei reellen Variablen.

diric(x, n)

Periodische Sinc-Funktion, auch Dirichlet-Funktion genannt.

euler(n)

Euler-Zahlen E(0), E(1), ..., E(n).

expn(n, x[, out])

Verallgemeinerte Exponentialintegrale En.

exp1(z[, out])

Exponentielle Integrale E1.

expi(x[, out])

Exponentielle Integrale Ei.

factorial(n[, exact, extend])

Die Fakultät einer Zahl oder eines Arrays von Zahlen.

factorial2(n[, exact, extend])

Doppelte Fakultät.

factorialk(n, k[, exact, extend])

Multifaktoriell von n der Ordnung k, n(!!...!).

shichi(x[, out])

Hyperbolische Sinus- und Cosinus-Integrale.

sici(x[, out])

Sinus- und Cosinus-Integrale.

softmax(x[, axis])

Berechne die Softmax-Funktion.

log_softmax(x[, axis])

Berechne den Logarithmus der Softmax-Funktion.

spence(z[, out])

Spence-Funktion, auch bekannt als Dilogarithmus.

zeta(x[, q, out])

Riemannsche oder Hurwitzsche Zeta-Funktion.

zetac(x[, out])

Riemannsche Zeta-Funktion minus 1.

softplus(x, **kwargs)

Berechne die Softplus-Funktion elementweise.

Komfortfunktionen#

cbrt(x[, out])

Elementweise Kubikwurzel von x.

exp10(x[, out])

Berechne 10**x elementweise.

exp2(x[, out])

Berechnet 2**x elementweise.

radian(d, m, s[, out])

Konvertiert von Grad in Radiant.

cosdg(x[, out])

Kosinus des Winkels x in Grad.

sindg(x[, out])

Sinus des Winkels x in Grad.

tandg(x[, out])

Tangens des Winkels x in Grad.

cotdg(x[, out])

Kotangens des Winkels x in Grad.

log1p(x[, out])

Berechnet log(1 + x) für den Fall, dass x nahe Null ist.

expm1(x[, out])

Berechnet exp(x) - 1.

cosm1(x[, out])

cos(x) - 1 für den Fall, dass x nahe Null ist.

powm1(x, y[, out])

Berechnet x**y - 1.

round(x[, out])

Rundet auf die nächste ganze Zahl.

xlogy(x, y[, out])

Berechnet x*log(y) so, dass das Ergebnis 0 ist, wenn x = 0.

xlog1py(x, y[, out])

Berechnet x*log1p(y) so, dass das Ergebnis 0 ist, wenn x = 0.

logsumexp(a[, axis, b, keepdims, return_sign])

Berechnet den Logarithmus der Summe der Exponentialfunktionen von Eingabeelementen.

exprel(x[, out])

Relative Fehler-Exponentialfunktion, (exp(x) - 1)/x.

sinc(x)

Gibt die normalisierte Sinc-Funktion zurück.