Meine alten Sachen aus RALV

Numerische_Integration/num_int_runge_kutta.py

@@ -0,0 +1,62 @@
+def verfahren(funktionen: list, startwerte: list, weite: float, schritte: int) -> list:
+    """
+    Runge-Kutta-Verfahren für ein beliebiges DGLS
+    :param funktionen: Liste mit allen Funktionen
+    :param startwerte: Liste mit allen Startwerten der Variablen
+    :param weite: gesamte Weite über die integriert werden soll
+    :param schritte: Anzahl der Schritte über die gesamte Weite
+    :return: Liste mit Listen für alle Wertepaare
+    """
+    h = weite / schritte
+    werte = [startwerte]
+    for i in range(schritte):
+
+        zuschlaege_grob = zuschlaege(funktionen, werte[-1], h)
+        werte_grob = [werte[-1][j] if j == 0 else werte[-1][j] + zuschlaege_grob[j - 1]
+                      for j in range(len(startwerte))]
+
+        zuschlaege_fein_1 = zuschlaege(funktionen, werte[-1], h / 2)
+        werte_fein_1 = [werte[-1][j] + h/2 if j == 0 else werte[-1][j]+zuschlaege_fein_1[j-1]
+                        for j in range(len(startwerte))]
+
+        zuschlaege_fein_2 = zuschlaege(funktionen, werte_fein_1, h / 2)
+        werte_fein_2 = [werte_fein_1[j] + h/2 if j == 0 else werte_fein_1[j]+zuschlaege_fein_2[j-1]
+                        for j in range(len(startwerte))]
+
+        werte_korr = [werte_fein_2[j] if j == 0 else werte_fein_2[j] + 1/15 * (werte_fein_2[j] - werte_grob[j])
+                      for j in range(len(startwerte))]
+
+        werte.append(werte_korr)
+    return werte
+
+
+def zuschlaege(funktionen: list, startwerte: list, h: float) -> list:
+    """
+    Berechnung der Zuschläge eines einzelnen Schritts
+    :param funktionen: Liste mit allen Funktionen
+    :param startwerte: Liste mit allen Startwerten der Variablen
+    :param h: Schrittweite
+    :return: Liste mit Zuschlägen für die einzelnen Variablen
+    """
+    werte = [wert for wert in startwerte]
+
+    k1 = [h * funktion(*werte) for funktion in funktionen]
+
+    werte = [startwerte[i] + (h / 2 if i == 0 else k1[i - 1] / 2)
+             for i in range(len(startwerte))]
+
+    k2 = [h * funktion(*werte) for funktion in funktionen]
+
+    werte = [startwerte[i] + (h / 2 if i == 0 else k2[i - 1] / 2)
+             for i in range(len(startwerte))]
+
+    k3 = [h * funktion(*werte) for funktion in funktionen]
+
+    werte = [startwerte[i] + (h if i == 0 else k3[i - 1])
+             for i in range(len(startwerte))]
+
+    k4 = [h * funktion(*werte) for funktion in funktionen]
+
+    k_ = [(k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]) / 6 for i in range(len(k1))]
+
+    return k_

Numerische_Integration/num_int_trapezformel.py

@@ -0,0 +1,46 @@
+def f(xi, yi):
+    ys = xi + yi
+    return ys
+
+
+# Gegeben:
+x0 = 0
+y0 = 0
+h = 0.2
+xmax = 0.4
+Ey = 0.0001
+
+x = [x0]
+y = [[y0]]
+
+n = 0
+while x[-1] < xmax:
+    x.append(x[-1]+h)
+    fn = f(x[n], y[n][-1])
+    if n == 0:
+        y_neu = y[n][-1] + h * fn
+    else:
+        y_neu = y[n-1][-1] + 2*h * fn
+    y.append([y_neu])
+    dy = 1
+    while dy > Ey:
+        y_neu = y[n][-1] + h/2 * (fn + f(x[n+1], y[n+1][-1]))
+        y[-1].append(y_neu)
+        dy = abs(y[-1][-2]-y[-1][-1])
+    n += 1
+
+print(x)
+print(y)
+
+werte = []
+for i in range(len(x)):
+    werte.append((x[i], y[i][-1]))
+
+for paar in werte:
+    print(f"({round(paar[0], 5)}, {round(paar[1], 5)})")
+
+integral = 0
+for i in range(len(werte)-1):
+    integral += (werte[i+1][1]+werte[i][1])/2 * (werte[i+1][0]-werte[i][0])
+
+print(f"Integral = {round(integral, 5)}")

Numerische_Integration/rk_DGLS_1Ordnung.py

@@ -0,0 +1,7 @@
+import num_int_runge_kutta as rk
+
+f = lambda ti, xi, yi: yi - ti
+g = lambda ti, xi, yi: xi + yi
+
+funktionswerte = rk.verfahren([f, g], [0, 0, 1], 0.6, 3)
+print(funktionswerte)

Numerische_Integration/rk_DGL_1Ordnung.py

@@ -0,0 +1,6 @@
+import num_int_runge_kutta as rk
+
+f = lambda xi, yi: xi + yi
+
+funktionswerte = rk.verfahren([f], [0, 0], 1, 5)
+print(funktionswerte)

Numerische_Integration/rk_DGL_2Ordnung.py

@@ -0,0 +1,10 @@
+import numpy as np
+import num_int_runge_kutta as rk
+
+f = lambda ti, ui, phii: -4 * np.sin(phii)
+g = lambda ti, ui, phii: ui
+
+funktionswerte = rk.verfahren([f, g], [0, 1, 0], 0.6, 3)
+
+for wert in funktionswerte:
+    print(f"t = {round(wert[0],1)}s -> phi = {round(wert[2],5)}, phip = {round(wert[1],5)}, v = {round(2.45 * wert[1],5)}")

Numerische_Integration/rk_DGL_2Ordnung_2.py

@@ -0,0 +1,7 @@
+import num_int_runge_kutta as rk
+
+f = lambda xi, yi, ui: ui
+g = lambda xi, yi, ui: 4 * ui - 4 * yi
+
+funktionswerte = rk.verfahren([f, g], [0, 0, 1], 0.6, 2)
+print(funktionswerte)