Bessel-Funktionen im SymPy Symbolic Math Program

Einführung:
Mit der Anwendung von Bessel-Funktionen ist eine Vielzahl der unterschiedlichsten Probleme verbunden, die sich auf fast alle wichtigen Bereiche der mathematischen Physik beziehen und auf die Beantwortung aktueller technischer Fragen ausgelegt sind.

Bessel-Funktionen werden häufig zur Lösung von Problemen der Akustik, Radiophysik, Hydrodynamik sowie der Atom- und Kernphysik eingesetzt. Zahlreiche Anwendungen der Bessel-Funktionen auf die Theorie der Wärmeleitfähigkeit und die Theorie der Elastizität (Probleme bei Plattenschwingungen, Probleme der Schalentheorie, Probleme bei der Bestimmung der Spannungskonzentration in der Nähe von Rissen).

Diese Popularität von Bessel-Funktionen erklärt sich aus der Tatsache, dass das Lösen von Gleichungen der mathematischen Physik, die den Laplace-Operator in Zylinderkoordinaten enthalten, mit der klassischen Methode der Variablentrennung zu einer gewöhnlichen Differentialgleichung führt, die zur Bestimmung dieser Funktionen dient [1].

Bessel-Funktionen sind nach dem deutschen Astronomen Friedrich Bessel benannt, der 1824, als er die Bewegung von Planeten um die Sonne untersuchte, Wiederholungsrelationen für Bessel-Funktionen ableitete $$$J_ {v} (x)$ für ganze Zahlen empfangen $$$v$ integrale Darstellung einer Funktion $$$J_ {v} (x)$ bewies die Existenz unzähliger Funktionsnullen $$$J_ {0} (x)$ und kompilierte die ersten Tabellen für Funktionen $$$J_ {1} (x)$ und $$$J_ {2} (x)$ .

Zum ersten Mal jedoch eine der Funktionen von Bessel $$$J_ {0} (x)$ Es wurde bereits 1732 von Daniel Bernoulli in einer Arbeit über die Schwingung schwerer Ketten betrachtet. D. Bernoulli fand einen Ausdruck der Funktion $$$J_ {0} (x)$ in Form einer Potenzreihe und bemerkte (ohne Beweis), dass die Gleichung $$$J_ {0} (x) = 0$ hat unzählige gültige Wurzeln.

Die nächste Arbeit, in der Bessel-Funktionen angetroffen werden, war die Arbeit von Leonardo Euler im Jahr 1738, die sich mit der Untersuchung der Schwingungen einer kreisförmigen Membran befasste. In dieser Arbeit fand L. Euler für ganze Zahlen $$$v$ Bessel-Funktionsausdruck $$$J_ {v} (x)$ in Form einer Reihe von Kräften $$$x$ und in nachfolgenden Veröffentlichungen wurde dieser Ausdruck auf den Fall beliebiger Indexwerte erweitert $$$v$ . Darüber hinaus hat L. Euler bewiesen, dass für $$$v$ gleich anderthalb ganze Zahlen, Funktionen $$$J_ {v} (x)$ ausgedrückt durch elementare Funktionen.

Er bemerkte (ohne Beweise), dass mit gültig $$$v$ die Funktionen $$$J_ {v} (x)$ habe unzählige reelle Nullen und gab eine ganzzahlige Darstellung für $$$J_ {v} (x)$ . Einige Forscher glauben, dass die wichtigsten Ergebnisse in Bezug auf Bessel-Funktionen und ihre Anwendungen in der mathematischen Physik mit dem Namen L. Euler zusammenhängen.

Um die Eigenschaft von Bessel-Funktionen zu untersuchen und gleichzeitig Methoden zur Lösung von Gleichungen zu beherrschen, die auf Bessel-Funktionen reduziert sind, ermöglicht das frei verteilte Programm der symbolischen Mathematik SymPy - die Python-Bibliothek.

Im SymPy-Programm für symbolische Mathematik können Diagramme von Bessel-Funktionen der ersten Art von ganzzahligen Ordnungen unter Verwendung der Beziehung für die Summe einer Reihe erstellt werden:

$$

$$J_ {p} (x) = \ sum_ {m = 0} ^ {\ infty} \ frac {x ^ {2m + p} (- 1) ^ {m}} {2 ^ {2m + p} m! \ Gamma (p + m + 1)}$$

Mit der Beziehung für die Summe einer Reihe können wir die Eigenschaft dieser Funktionen für ganze Aufträge beweisen

$$

$$J_ {1} (x) = - J _ {- 1} (x):$$

Um die Cauchy-Bedingungen zu demonstrieren, konstruieren wir eine Funktion $$$J_ {1/3} (x)$ und seine Ableitung $$$\ frac {dJ_ {1/3} (x)} {dx}:$ ::




Für praktische Berechnungen wird jedoch das wunderbare mpmath-Modul verwendet, mit dem nicht nur Gleichungen mit Bessel-Funktionen der ersten und zweiten Art numerisch gelöst werden können, einschließlich modifizierter Gleichungen aller zulässigen Ordnungen, sondern auch Diagramme mit automatischer Skalierung erstellt werden können.

Darüber hinaus benötigt das mpmath-Modul keine speziellen Tools für den Austausch symbolischer und numerischer Mathematik. Die Entstehungsgeschichte dieses Moduls und die Möglichkeit seiner Verwendung für die inverse Laplace-Transformation habe ich bereits in Veröffentlichung [2] betrachtet. Nun setzen wir die Diskussion über mpmath für die Arbeit mit Bessel-Funktionen fort [3].

Bessel-Funktion der ersten Art $$$J_ {N} (x)$
mpmath.besselj (n, x, Ableitung = 0) - ergibt eine Bessel-Funktion der ersten Art $$$Jn (x)$ . Funktionen $$$J_ {N} (x)$ ist eine Lösung für die folgende Differentialgleichung:

$$

$$x ^ {2} {y} '' + x {y} '+ (x ^ {2} -n ^ {2}) y = 0$$

Für das ganze Positive $$$n$ verhält sich wie ein Sinus oder Cosinus, multipliziert mit einem Koeffizienten, der langsam mit abnimmt $$$x \ rightarrow \ pm \ infty$
Bessel-Funktion der ersten Art $$$J_ {N} (x)$ ist ein Sonderfall der hypergeometrischen Funktion $$${o} F_ {1}$ ::

$$

$$J_ {n} (x) = \ frac {x ^ {n}} {2 ^ {n} \ Gamma (n + 1)} {o} F_ {1} (n + 1, \ frac {x ^ { 2}} {4})$$

Die Bessel-Funktion kann unterschieden werden $$$m$ Zeiten vorausgesetzt, dass die m-te Ableitung ungleich Null ist:

$$

$$\ frac {d ^ {m}} {dx ^ {m}} J_ {n} (x)$$

Bessel-Funktion der ersten Art $$$J_ {N} (x)$ für positive ganzzahlige Ordnungen n = 0,1,2,3 - die Lösung der Bessel-Gleichung:

 from mpmath import* j0 = lambda x: besselj(0,x) j1 = lambda x: besselj(1,x) j2 = lambda x: besselj(2,x) j3 = lambda x: besselj(3,x) plot([j0,j1,j2,j3],[0,14] 

Bessel-Funktion der ersten Art $$$J_ {N} (x)$ in der komplexen Ebene:

 from sympy import* from mpmath import* cplot(lambda z: besselj(1,z), [-8,8], [-8,8], points=50000) 

Beispiele:
Funktion $$$besselj (N, x)$ liefert ein Ergebnis mit einer bestimmten Anzahl von Ziffern $$$(mp.dps)$ nach dem Komma:

 from mpmath import* mp.dps = 15; mp.pretty = True print(besselj(2, 1000)) nprint(besselj(4, 0.75)) nprint(besselj(2, 1000j)) mp.dps = 25 nprint( besselj(0.75j, 3+4j)) mp.dps = 50 nprint( besselj(1, pi)) 

Ein Funktionsargument kann eine große Zahl sein:

 from mpmath import* mp.dps = 25 nprint( besselj(0, 10000)) nprint(besselj(0, 10**10)) nprint(besselj(2, 10**100)) nprint( besselj(2, 10**5*j)) 

Bessel-Funktionen der ersten Art erfüllen einfache Symmetrien in Bezug auf $$$x = 0$ ::

 from sympy import* from mpmath import* mp.dps = 15 nprint([besselj(n,0) for n in range(5)]) nprint([besselj(n,pi) for n in range(5)]) nprint([besselj(n,-pi) for n in range(5)]) 

Die Wurzeln sind nicht periodisch, aber der Abstand zwischen aufeinanderfolgenden Wurzeln nähert sich asymptotisch $$$2π$ . Bessel-Funktionen der ersten Art haben folgenden Code:

 from mpmath import* print(quadosc(j0, [0, inf], period=2*pi)) print(quadosc(j1, [0, inf], period=2*pi)) 

Für $$$n = 1/2$ oder $$$n = -1/2$ Die Bessel-Funktion wird auf eine trigonometrische Funktion reduziert:

 from sympy import* from mpmath import* x = 10 print(besselj(0.5, x)) print(sqrt(2/(pi*x))*sin(x)) print(besselj(-0.5, x)) print(sqrt(2/(pi*x))*cos(x)) 

Derivate jeder Ordnung können berechnet werden, negative Ordnungen entsprechen der Integration :

 from mpmath import* mp.dps = 25 print(besselj(0, 7.5, 1)) print(diff(lambda x: besselj(0,x), 7.5)) print(besselj(0, 7.5, 10)) print(diff(lambda x: besselj(0,x), 7.5, 10)) print(besselj(0,7.5,-1) - besselj(0,3.5,-1)) print(quad(j0, [3.5, 7.5])) 

Die Differenzierung mit nicht ganzzahliger Ordnung ergibt eine gebrochene Ableitung im Sinne des Riemann-Liouville-Differentialintegrals, die unter Verwendung der Funktion berechnet wird $$$difint ()$ ::

 from mpmath import* mp.dps = 15 print(besselj(1, 3.5, 0.75)) print(differint(lambda x: besselj(1, x), 3.5, 0.75)) 

Andere Möglichkeiten, die Bessel-Funktion der ersten Art von Null und erster Ordnung aufzurufen
mpmath.j0 (x) - Berechnet die Bessel-Funktion $$$J_ {0} (x)$ ;;
mpmath.j1 (x) - Berechnet die Bessel-Funktion $$$J_ {1} (x)$ ;;

Bessel-Funktionen der zweiten Art
bessely (n, x, Ableitung = 0) Berechnet die Bessel-Funktion zweiter Art aus der Beziehung:

$$

$$Y_ {n} (x) = \ frac {J_ {n} (x) cos (\ pi \ cdot n) -J _ {- n} (x)} {sin (\ pi \ cdot n)}$$

Für eine ganze Zahl $$$n$ Die folgende Formel sollte als Grenze verstanden werden. Die Bessel-Funktion kann unterschieden werden $$$m$ Zeiten vorausgesetzt, dass die m-te Ableitung ungleich Null ist:
$$$\ frac {d ^ {m}} {dx ^ {m}} Y_ {n} (x)$
Bessel-Funktion der zweiten Art $$$Y_ {n} (x)$ für ganzzahlige positive Aufträge $$$n = 0,1,2,3$ .

 from sympy import* from mpmath import* y0 = lambda x: bessely(0,x) y1 = lambda x: bessely(1,x) y2 = lambda x: bessely(2,x) y3 = lambda x: bessely(3,x) plot([y0,y1,y2,y3],[0,10],[-4,1]) 

2. Art Bessel-Funktion $$$Y_ {n} (x)$ in der komplexen Ebene

 from sympy import* from mpmath import* cplot(lambda z: bessely(1,z), [-8,8], [-8,8], points=50000) 

Beispiele:
Einige Funktionswerte $$$Y_ {n} (x)$ ::

 from sympy import* from mpmath import* mp.dps = 25; mp.pretty = True print(bessely(0,0)) print(bessely(1,0)) print(bessely(2,0)) print(bessely(1, pi)) print(bessely(0.5, 3+4j)) 

Argumente können groß sein:

 from sympy import* from mpmath import* mp.dps = 25; mp.pretty = True print(bessely(0, 10000)) print(bessely(2.5, 10**50)) print(bessely(2.5, -10**50)) 

Derivate beliebiger Ordnung, einschließlich negativer, können berechnet werden:

 from sympy import* from mpmath import* mp.dps = 25; mp.pretty = True print(bessely(2, 3.5, 1)) print(diff(lambda x: bessely(2, x), 3.5)) print(bessely(0.5, 3.5, 1)) print(diff(lambda x: bessely(0.5, x), 3.5)) print(diff(lambda x: bessely(2, x), 0.5, 10)) print(bessely(2, 0.5, 10)) print(bessely(2, 100.5, 100)) print(quad(lambda x: bessely(2,x), [1,3])) print(bessely(2,3,-1) - bessely(2,1,-1)) 

Modifizierte Bessel-Funktion der ersten Art

 mpmath.besseli(n, x, derivative=0) 

Besseli (n, x, Ableitung = 0) modifizierte Bessel-Funktion der ersten Art

$$

$$I_ {n} (x) = \ mathit {i} ^ {- n} J_ {n} (ix)$$

$$

$$\ frac {d ^ {m}} {dx ^ {m}} I_ {n} (x)$$

Modifizierte Bessel-Funktion $$$I_n (x)$ für echte Bestellungen $$$n = 0,1,2,3$ ::

 from mpmath import* i0 = lambda x: besseli(0,x) i1 = lambda x: besseli(1,x) i2 = lambda x: besseli(2,x) i3 = lambda x: besseli(3,x) plot([i0,i1,i2,i3],[0,5],[0,5]) 

Modifizierte Bessel-Funktion $$$I_ {n} (x)$ in der komplexen Ebene

 from mpmath import* cplot(lambda z: besseli(1,z), [-8,8], [-8,8], points=50000) 

Beispiele:
Einige Bedeutungen $$$I_ {n} (x)$

 from mpmath import* mp.dps = 25; mp.pretty = True print(besseli(0,0)) print(besseli(1,0)) print(besseli(0,1)) print(besseli(3.5, 2+3j)) 

Argumente können groß sein:

 from mpmath import* mp.dps = 25; mp.pretty = True print(besseli(2, 1000)) print(besseli(2, 10**10)) print(besseli(2, 6000+10000j)) 

Für ganze Zahlen n gilt die folgende ganzzahlige Darstellung:

 from mpmath import* mp.dps = 15; mp.pretty = True n = 3 x = 2.3 print(quad(lambda t: exp(x*cos(t))*cos(n*t), [0,pi])/pi) print(besseli(n,x)) 

Derivate beliebiger Ordnung können berechnet werden:

 from mpmath import* mp.dps = 25; mp.pretty = True print(besseli(2, 7.5, 1)) print(diff(lambda x: besseli(2,x), 7.5)) print(besseli(2, 7.5, 10)) print(diff(lambda x: besseli(2,x), 7.5, 10)) print(besseli(2,7.5,-1) - besseli(2,3.5,-1)) print(quad(lambda x: besseli(2,x), [3.5, 7.5])) 

Modifizierte Bessel-Funktionen der zweiten Art,

 mpmath.besselk(n, x) 

besselk (n, x) modifizierte Bessel-Funktionen zweiter Art

$$

$$K_ {n} (x) = \ frac {\ pi} {4} \ frac {I _ {- n} (x) -I_ {n} (x)} {sin (\ pi \ cdot n)}$$

Für eine ganze Zahl $$$n$ Diese Formel sollte als Grenze verstanden werden.
Modifizierte Bessel-Funktion der 2. Art $$$K_ {n} (x)$ für Material $$$n = 0,1,2,3$ ::

 from mpmath import* k0 = lambda x: besselk(0,x) k1 = lambda x: besselk(1,x) k2 = lambda x: besselk(2,x) k3 = lambda x: besselk(3,x) plot([k0,k1,k2,k3],[0,8],[0,5]) 

Modifizierte Bessel-Funktion der 2. Art $$$K_ {n} (x))$ in der komplexen Ebene

 from mpmath import* cplot(lambda z: besselk(1,z), [-8,8], [-8,8], points=50000) 

Beispiele:
Komplizierte und komplexe Argumente:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselk(0,1)) print(besselk(0, -1)) print(besselk(3.5, 2+3j)) print(besselk(2+3j, 0.5)) 

Argumente sind große Zahlen

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselk(0, 100)) print(besselk(1, 10**6)) print(besselk(1, 10**6*j)) print(besselk(4.5, fmul(10**50, j, exact=True))) 

Merkmale des Verhaltens einer Funktion an einem Punkt $$$x = 0$ ::

 from mpmath import * print(besselk(0,0)) print(besselk(1,0)) for n in range(-4, 5): print(besselk(n, '1e-1000')) 

Bessel-Funktionsnullen

 besseljzero() mpmath.besseljzero(v, m, derivative=0) 

Für echte Ordnung $$$\ mathit {\ nu} \ geq 0$ und eine positive ganze Zahl $$$m$ kehrt zurück $$$j _ {\ nu, m}$ , die m-te positive Null der Bessel-Funktion der ersten Art $$$J _ {\ nu} (z)$ (siehe besselj () ). Alternativ mit $$$derivative = 1$ ergibt die erste nicht negative Primzahl Null $$${j} '_ {\ nu, m}$ von $$${J} '_ {\ nu} (z)$ . Indizierungsvereinbarungsbezeichnungen mit Abramowitz & Stegun und DLMF. Achten Sie auf einen Sonderfall. $$${j} '_ {0,1} = 0$ während alle anderen Nullen positiv sind.

In der Realität werden nur einfache Nullen berechnet (alle Nullen der Bessel-Funktionen sind einfach, außer wenn $$$z = 0$ ) und $$$j _ {\ nu, m}$ wird eine monotone Funktion von $$$\ nu$ und $$$m$ . Nullen wechseln sich je nach Ungleichung ab:

$$

$${j} '_ {\ nu, k} <j _ {\ nu, k} <{j}' _ {\ nu, k + 1}$$

$$

$$j _ {\ nu, 1} <j _ {\ nu + 1,2} <j _ {\ nu, 2} <j _ {\ nu + 1,2} <j _ {\ nu, 3} \ cdots$$

Beispiele:
Führende Nullen von Bessel-Funktionen $$$J_ {0} (z)$ , $$$J_ {1} (z)$ , $$$J_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0,1)) print(besseljzero(0,2)) print(besseljzero(0,3)) print(besseljzero(1,1)) print(besseljzero(1,2)) print(besseljzero(1,3)) print(besseljzero(2,1)) print(besseljzero(2,2)) print(besseljzero(2,3)) 

Führende Nullen von Ableitungen von Bessel-Funktionen $$${J} '_ {0} (z)$ , $$${J} '_ {1} (z)$ , $$${J} '_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0,1,1)) print(besseljzero(0,2,1)) print(besseljzero(0,3,1)) print(besseljzero(1,1,1)) print(besseljzero(1,2,1)) print(besseljzero(1,3,1)) print(besseljzero(2,1,1)) print(besseljzero(2,2,1)) print(besseljzero(2,3,1)) 

Nullen mit einem großen Index:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0,100)) print(besseljzero(0,1000)) print(besseljzero(0,10000)) print(besseljzero(5,100)) print(besseljzero(5,1000)) print(besseljzero(5,10000)) print(besseljzero(0,100,1)) print(besseljzero(0,1000,1)) print(besseljzero(0,10000,1)) 

Nullen von Funktionen mit einer großen Bestellung:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(50,1)) print(besseljzero(50,2)) print(besseljzero(50,100)) print(besseljzero(50,1,1)) print(besseljzero(50,2,1)) print(besseljzero(50,100,1)) 

Nullen von Funktionen mit gebrochener Ordnung:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besseljzero(0.5,1)) print(besseljzero(1.5,1)) print(besseljzero(2.25,4)) 

Und $$$J _ {\ nu} (z)$ . und $$${J} '_ {\ nu} (z)$ kann als unendliche Produkte an ihren Nullen ausgedrückt werden:

 from mpmath import * mp.dps = 6; mp.pretty = True v,z = 2, mpf(1) nprint((z/2)**v/gamma(v+1) * \ nprod(lambda k: 1-(z/besseljzero(v,k))**2, [1,inf])) print(besselj(v,z)) nprint((z/2)**(v-1)/2/gamma(v) * \ nprod(lambda k: 1-(z/besseljzero(v,k,1))**2, [1,inf])) print(besselj(v,z,1)) 

 besselyzero() mpmath.besselyzero(v, m, derivative=0) 

Für echte Ordnung $$$\ mathit {\ nu} \ geq 0$ und eine positive ganze Zahl $$$m$ kehrt zurück $$$y _ {\ nu, m}$ , $$$m$ mth positive Null der zweiten Art der Bessel-Funktion $$$Y _ {\ nu} (z)$ (siehe Bessely () ). Alternativ mit $$$derivative = 1$ gibt die erste positive Null $$${y} '_ {\ nu, m}$ von $$${Y} '_ {\ nu} (z)$ . Nullen wechseln sich je nach Ungleichung ab:

$$

$$y _ {\ nu, k} <{y} '_ {\ nu, k} <y _ {\ nu, k + 1}$$

$$

$$y _ {\ nu, 1} <y _ {\ nu + 1,2} <y _ {\ nu, 2} <y _ {\ nu + 1,2} <y _ {\ nu, 3} \ cdots$$

Beispiele:
Führende Nullen von Bessel-Funktionen $$$Y_ {0} (z)$ , $$$Y_ {1} (z)$ , $$$Y_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0,1)) print(besselyzero(0,2)) print(besselyzero(0,3)) print(besselyzero(1,1)) print(besselyzero(1,2)) print(besselyzero(1,3)) print(besselyzero(2,1)) print(besselyzero(2,2)) print(besselyzero(2,3)) 

Führende Nullen von Ableitungen von Bessel-Funktionen $$${Y} '_ {0} (z)$ , $$${Y} '_ {1} (z)$ , $$${Y} '_ {2} (z)$

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0,1,1)) print(besselyzero(0,2,1)) print(besselyzero(0,3,1)) print(besselyzero(1,1,1)) print(besselyzero(1,2,1)) print(besselyzero(1,3,1)) print(besselyzero(2,1,1)) print(besselyzero(2,2,1)) print(besselyzero(2,3,1)) 

Nullen mit einem großen Index:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0,100)) print(besselyzero(0,1000)) print(besselyzero(0,10000)) print(besselyzero(5,100)) print(besselyzero(5,1000)) print(besselyzero(5,10000)) print(besselyzero(0,100,1)) print(besselyzero(0,1000,1)) print(besselyzero(0,10000,1)) 

Nullen von Funktionen mit einer großen Bestellung:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(50,1)) print(besselyzero(50,2)) print(besselyzero(50,100)) print(besselyzero(50,1,1)) print(besselyzero(50,2,1)) print(besselyzero(50,100,1)) 

Nullen von Funktionen mit gebrochener Ordnung:

 from mpmath import * mp.dps = 25; mp.pretty = True print(besselyzero(0.5,1)) print(besselyzero(1.5,1)) print(besselyzero(2.25,4)) 

Bessel-Funktionsanwendungen
Die Bedeutung von Bessel-Funktionen beruht nicht nur auf dem häufigen Auftreten der Bessel-Gleichung in Anwendungen, sondern auch auf der Tatsache, dass die Lösungen vieler anderer linearer Differentialgleichungen zweiter Ordnung in Form von Bessel-Funktionen ausgedrückt werden können. Um zu sehen, wie sie aussehen, beginnen wir mit der Bessel-Ordnungsgleichung $$$p$ in Form von:

$$

$$z ^ {2} \ frac {d ^ {2} w} {dz ^ {2}} + z \ frac {dw} {dz} + (z ^ {2} -p ^ {2}) w = 0 , (1)$$

und hier ersetzen

$$

$$w = x ^ {- \ alpha}, z = kx ^ {\ beta}, (2)$$

Verwenden Sie dann (2) und führen Sie die Konstanten ein $$$A, B, C$ aus Gleichung (1) erhalten wir:

$$

$$x ^ {2} {y} '' + Ax {y} '+ (B + Cx ^ {q}) y = 0, (3)$$

$$

$$A = 1-2 \ alpha, B = \ alpha ^ {2} - \ beta ^ {2} p ^ {2}, C = \ beta ^ {2} k ^ {2}, q = 2 \ beta, (4)$$

Aus Gleichung (4) erhalten wir:

$$

$$\ left \ {\ begin {matrix} \ alpha = \ frac {1-A} {2}, \\ \ beta = \ frac {q} {2}, \\ k = \ frac {2 \ sqrt {C. }} {q} \\ p = \ frac {\ sqrt {(1-A ^ {2} -4B}} {q} \\ \ end {matrix} \ right. (5)$$

Wenn $$$C> 0$ , $$$q \ neq 0$ , $$$(1-A) ^ {2} \ geqslant 4B$ , dann die allgemeine Lösung (z $$$x> 0$ ) von Gleichung (3) hat die Form:

$$

$$y (x) = x ^ {\ alpha} \ left [c_ {1} J_ {p} (kx ^ {\ beta}) + c_ {2} J _ {- p} (kx ^ {\ beta}) \ rechts] (6)$$

wo: $$$\ alpha$ , $$$\ beta$ , $$$k$ werden aus System (5) bestimmt. Wenn $$$p$ Ist dann eine ganze Zahl $$$J_ {p}$ müssen ersetzt werden durch $$$Y_ {p}$ .

Längsbiegung der vertikalen Säule
Wir werden nun eine Aufgabe betrachten, die für praktische Anwendungen wichtig ist. Bei dieser Aufgabe muss bestimmt werden, wann eine gleichmäßige vertikale Säule unter ihrem eigenen Gewicht gebogen wird. Wir nehmen an $$$x = 0$ im freien oberen Ende der Spalte und $$$x = L> 0$ an seiner Basis; wir nehmen an, dass die Basis starr in die Basis (in den Boden) eingeführt (d. h. bewegungslos fixiert) ist, möglicherweise in Beton.

Bezeichnen Sie die Winkelabweichung der Säule am Punkt $$$x$ durch $$$\ theta (x)$ . Aus der Elastizitätstheorie unter diesen Bedingungen folgt:

$$

$$EI \ frac {d ^ {2} \ theta} {dx ^ {2}} + g \ rho x \ theta = 0, (7)$$

wo $$$E$ - Elastizitätsmodul des Säulenmaterials, $$$I$ - Trägheitsmoment seines Querschnitts, $$$\ rho$ - lineare Dichte der Säule und $$$g$ - Gravitationsbeschleunigung. Die Randbedingungen haben folgende Form:

$$

$${\ theta} '(0) = 0, \ theta (L) = 0, (8)$$

Wir werden das Problem mit (7) und (8) lösen mit:

$$

$$\ lambda = \ gamma ^ {2} = \ frac {g \ rho} {EI} (9)$$

Wir schreiben (7) unter Berücksichtigung von (9) unter Bedingung (8) neu:

$$

$$\ frac {d ^ {2} \ theta} {dx ^ {2}} + \ gamma ^ {2} x \ theta = 0; \ frac {d \ theta} {dx} = 0, \ theta (L) = 0. (10)$$

Eine Säule kann nur verformt werden, wenn es eine nicht triviale Lösung für das Problem gibt (10); Andernfalls bleibt die Säule in einer Position, die nicht von der Vertikalen abweicht (d. h. physisch nicht in der Lage ist, von der Vertikalen abzuweichen).
Die Differentialgleichung (10) ist eine Airy-Gleichung. Gleichung (10) hat die Form von Gleichung (3) für $$$A = B = 0$ , $$$C = \ gamma ^ {2}$ , $$$q = 3$ . Aus dem Gleichungssystem (5) erhalten wir $$$\ alpha = \ frac {1} {2}$ , $$$\ beta = \ frac {3} {2}$ , $$$k = \ frac {2} {3} \ gamma$ , $$$p = \ frac {1} {3}$ .
Daher hat die allgemeine Lösung die Form:

$$

$$\ theta (x) = x ^ {1/2} \ left [c_ {1} J_ {1/3} (\ frac {2} {3} \ gamma x ^ {3/2}) + c_ {2 } J _ {- 1/3} (\ frac {2} {3} \ gamma x ^ {3/2}) \ right]. (11)$$

Um die Anfangsbedingungen anzuwenden, ersetzen wir $$$p = \ pm \ frac {1} {3}$ in

$$

$$J_ {p} = \ sum_ {m = 0} ^ {\ infty} \ frac {(- 1) ^ {m}} {m! \ Gamma (p + m + 1)} \ left (\ frac {x } {2} \ right) ^ {2m + p} (12)$$

Nach der Transformation (12) erhalten wir unter Berücksichtigung der Lösung (11):

$$

$$\ theta (x) = \ frac {c_ {1} \ gamma ^ {1/3}} {3 ^ {1/3} \ Gamma (4/3)} \ left (x- \ frac {\ gamma ^ {2} x ^ {4}} {12} + \ frac {\ gamma ^ {4} x ^ {7}} {504} - \ cdot \ cdot \ cdot \ right) + \\ + \ frac {c_ { 2} 3 ^ {1/3}} {\ gamma ^ {1/3} \ Gamma (\ frac {2} {3})} \ left (1- \ frac {\ gamma ^ {2} x ^ {3 }} {6} + \ frac {\ gamma ^ {4} x ^ {6}} {180} - \ cdot \ cdot \ cdot \ right). (13)$$

Wird am Startpunkt bereitgestellt $$${\ theta} '(0) = 0$ wir bekommen $$$c_ {1} = 0$ , dann nimmt (11) die Form an:

$$

$$\ theta (x) = c_ {2} x ^ {1/2} J _ {- 1/3} (\ frac {2} {3} \ gamma x ^ {3/2}), (14)$$

Wird am Endpunkt bereitgestellt $$$\ theta (L) = 0$ , aus (14) erhalten wir:

$$

$$J _ {- 1/3} (\ frac {2} {3} \ gamma L ^ {3/2}) = 0 (15)$$

Es ist zu beachten, dass die Transformationen (13), (14) nicht durchgeführt werden könnten, wenn die Funktionsgraphen erstellt würden $$$J_ {1/3} (x), J _ {- 1/3} (x)$ Verwenden der berücksichtigten Funktionen des mpmath-Moduls:

 from mpmath import* mp.dps = 6; mp.pretty = True f=lambda x: besselj(-1/3,x) f1=lambda x: besselj(1/3,x) plot([f,f1], [0, 15]) 

Aus dem Diagramm folgt, dass für x = 0 die Funktion ist $$$J_ {1/3} (0) = 0$ und unter Berücksichtigung der Lösung (11) erhalten wir sofort die notwendige Gleichung (15), es bleibt nur z zu finden, wie unten gezeigt wird.

Somit wird die Säule nur dann verformt, wenn $$$z = \ frac {2} {3} \ gamma L ^ {3/2}$ Ist die Wurzel der Gleichung $$$J _ {- 1/3} (z) = 0$ . Erstellen Sie eine Funktion $$$J _ {- 1/3} (z)$ auf einem separaten Diagramm:

 from mpmath import* mp.dps = 6; mp.pretty = True f=lambda x: besselj(-1/3,x) plot(f, [0, 15]) 

Die Grafik zeigt, dass die erste Wurzel etwas kleiner als 2 ist. Suchen Sie die Wurzel $$$z0$ aus der Gleichung $$$J _ {- 1/3} (z) = 0$ Mit der Findroot-Funktion (f, z0) können Sie den Suchpunkt gemäß der Grafik akzeptieren $$$x0 = 1$ und sechs Dezimalstellen mp.dps = 6 :

 from mpmath import* mp.dps = 6; mp.pretty = True f=lambda x: besselj(-1/3,x) print("z0=%s"%findroot(f, 1) 

Wir bekommen:
$$$z0 = 1,86635$
Wir berechnen die kritische Länge, zum Beispiel einen Fahnenmast, nach der Formel (15):

Wir bekommen:
8,47 m
10,25 m

Ein hohler Fahnenmast kann höher sein als ein fester.

Wellenausbreitung in einer dünnen Membran.

Eine dünne Membran, wenn Schallwellen eintreten, schwingt nicht nur mit der Frequenz der Wellen. Die Form der Membranschwingungen kann in den Bessel-Funktionen gemäß der folgenden Auflistung unter Verwendung der Formeln besselj () und besseljzero () erhalten werden :

Alternative zum mpmath-Modul in speziellen Bessel-Funktionen der SciPy-Bibliothek

Ohne auf eine detaillierte Diskussion der Bessel-Funktionen aus der SciPy-Bibliothek [4] einzugehen, werde ich nur zwei Auflistungen zum Zeichnen von Funktionen der ersten und zweiten Art jv (v, x) , yv (v, x) geben :

Schlussfolgerungen:

Der Artikel beschreibt die Grundlagen der Arbeit mit Bessel-Funktionen unter Verwendung der Bibliotheken mpmath, sympy und scipy und enthält Beispiele für die Verwendung von Funktionen zum Lösen von Differentialgleichungen. Der Artikel kann nützlich sein, um die Gleichungen der mathematischen Physik zu studieren.

Referenzen:

1. Bessel-Funktionen
2. Verwenden der inversen Laplace-Transformation zur Analyse der dynamischen Verknüpfungen von Steuerungssystemen
3. Bessel-funktionbezogene Funktionen
4. Sonderfunktionen (scipy.special).