Simulation und Wissenschaftliches Rechnen 1 - Exam

Aufgabe 1)

Ein Forscherteam möchte die Ausbreitung eines chemischen Schadstoffes in einem Fluss systematisch untersuchen. Dazu soll eine Simulation entwickelt werden, die das Verhalten des Schadstoffes über einen bestimmten Zeitraum analysiert. Die Modellierung soll sowohl stochastische als auch deterministische Elemente enthalten, um unterschiedliche Szenarien und Unsicherheiten abzudecken.

b)

Implementiere das von Dir entwickelte mathematische Modell in einer Programmiersprache Deiner Wahl (z.B. Python). Führe die Simulation für ein festgelegtes Szenario durch, bei dem der Schadstoff bei einem konstanten Flussvolumen von 200 m³/s freigesetzt wird. Analysiere die Ergebnisse und stelle sie grafisch dar.

import numpy as npimport matplotlib.pyplot as plt# Beispielcode zur Implementierung des Modells# Definiere Parameterfluss_speed = 200  # in m³/szeit = np.linspace(0, 100, 500)  # Zeitpunkte# Initialbedingungenschadstoff_start = 0# Simulationschadstoff_konz = np.zeros_like(zeit)schadstoff_konz[0] = schadstoff_start# Einfache Modellierung der Ausbreitungfor t in range(1, len(zeit)):    schadstoff_konz[t] = schadstoff_konz[t-1] + fluss_speed * 0.01  # Annahme: lineare Zunahme# Ergebnisse plottenplt.plot(zeit, schadstoff_konz)plt.xlabel('Zeit (s)')plt.ylabel('Schadstoffkonzentration (mg/m³)')plt.title('Ausbreitung des Schadstoffes im Fluss')plt.show()

Lösung:

Um das mathematische Modell zur Beschreibung der Schadstoffausbreitung im Fluss zu implementieren und die Simulation durchzuführen, verwenden wir die Programmiersprache Python. Zunächst importieren wir die notwendigen Bibliotheken und definieren die Parameter. Anschließend setzen wir die Advektions-Diffusions-Reaktions-Gleichung um und führen die Simulation durch. Wir visualisieren die Ergebnisse grafisch.

Hier ist der vollständige Python-Code zur Implementierung des Modells und zur Durchführung der Simulation:

import numpy as npimport matplotlib.pyplot as plt# Parameterdefinierungfluss_speed = 200  # in m/sdiffusionskoeffizient = 0.1  # Diffusionskoeffizient in m²/sreaktionsrate = -0.01  # Abbaurate/chemische Reaktion in 1/squellterm = 0.5  # Quelle des Schadstoffes in mg/(m³·s)stochastischer_impact = 0.05  # Stochastische Schwankungen im Systemzeit = np.linspace(0, 100, 500)  # Zeitpunkte in Sekundenx_position = np.linspace(0, 100, 100)  # Positionen im Fluss in Metern# Initialbedingungenschadstoff_konz = np.zeros((len(zeit), len(x_position)))schadstoff_konz[0, 0] = 1  # Anfangskonzentration# Simulationsdurchführungfor t in range(1, len(zeit)):    for x in range(1, len(x_position)):        advektion = -fluss_speed * (schadstoff_konz[t-1, x] - schadstoff_konz[t-1, x-1])        diffusion = diffusionskoeffizient * (schadstoff_konz[t-1, x-1] - 2 * schadstoff_konz[t-1, x] + schadstoff_konz[t-1, x+1])        reaktion = reaktionsrate * schadstoff_konz[t-1, x]        quelle = quellterm        stochastisch = stochastischer_impact * np.random.randn()        schadstoff_konz[t, x] = schadstoff_konz[t-1, x] + (advektion + diffusion + reaktion + quelle + stochastisch)# Ergebnisse plottenplt.imshow(schadstoff_konz, extent=[0, 100, 0, 100], aspect='auto', origin='lower', cmap='viridis')plt.colorbar(label='Schadstoffkonzentration (mg/m³)')plt.xlabel('Position x (m)')plt.ylabel('Zeit (s)')plt.title('Ausbreitung des Schadstoffes im Fluss')plt.show()

Erklärung des Codes:

• Wir definieren die relevanten Parameter für die Simulation, wie die Flussgeschwindigkeit, den Diffusionskoeffizienten, die Reaktionsrate, den Quellterm und die stochastischen Schwankungen.
• Wir initialisieren das Konzentrationsprofil des Schadstoffes entlang der Zeit und der Position im Fluss.
• Während der Simulation berechnen wir die Advektion, Diffusion, Reaktion, den Quellterm und den stochastischen Einfluss für jeden Zeitschritt und jede Position im Fluss.
• Wir addieren diese Beiträge zur Konzentration, um die Ausbreitung des Schadstoffes zu modellieren.
• Zum Schluss visualisieren wir die Ergebnisse der Simulation als farbcodiertes Bild, das die Schadstoffkonzentration an verschiedenen Positionen über die Zeit zeigt.

Ein solches Modell erlaubt es, die Ausbreitung und das Verhalten des Schadstoffes im Fluss detailliert zu untersuchen und Szenarien sowie Unsicherheiten abzubilden.

Aufgabe 2)

Fehleranalyse und numerische StabilitätFehleranalyse untersucht, wie Rundungsfehler, Abschneidefehler und Modellierungsfehler die Genauigkeit von numerischen Berechnungen beeinflussen. Numerische Stabilität hingegen beschreibt, wie sensibel ein Algorithmus auf kleine Änderungen in den Eingabewerten reagiert.

• Rundungsfehler: Fehler durch begrenzte Präzision im Computer
• Abschneidefehler: Fehler durch die Approximation von unendlichen Reihen oder Integralen
• Modellierungsfehler: Diskrepanz zwischen realem Problem und dessen numerischem Modell
• Absolute Fehler: \( |x - \tilde{x}| \)
• Relative Fehler: \( \frac{|x - \tilde{x}|}{|x|} \)
• Voraussetzung für Stabilität: Algorithmus bleibt für kleine Eingangsänderungen robust
• Vorwärtsfehleranalyse: Untersucht, wie Fehler in den Eingabewerten das Ergebnis beeinflussen
• Rückwärtsfehleranalyse: Untersucht, wie Eingabewerte geändert werden müssten, um das exakte Ergebnis zu erhalten

a)

Gegeben sei die Berechnung der Funktion \( f(x) = e^x \). Betrachte man die Approximation \( \tilde{f}(x) \) mit einem Rundungsfehlerparameter \(\epsilon\). Bestimme den relativen Fehler \( \frac{|f(x) - \tilde{f}(x)|}{|f(x)|} \), wenn \( \tilde{f}(x) = (1 + \epsilon)f(x) \).

Lösung:

Fehleranalyse und numerische StabilitätFehleranalyse untersucht, wie Rundungsfehler, Abschneidefehler und Modellierungsfehler die Genauigkeit von numerischen Berechnungen beeinflussen. Numerische Stabilität hingegen beschreibt, wie sensibel ein Algorithmus auf kleine Änderungen in den Eingabewerten reagiert.

• Rundungsfehler: Fehler durch begrenzte Präzision im Computer
• Abschneidefehler: Fehler durch die Approximation von unendlichen Reihen oder Integralen
• Modellierungsfehler: Diskrepanz zwischen realem Problem und dessen numerischem Modell
• Absolute Fehler: \( |x - \tilde{x}| \)
• Relative Fehler: \( \frac{|x - \tilde{x}|}{|x|} \)
• Voraussetzung für Stabilität: Algorithmus bleibt für kleine Eingangsänderungen robust
• Vorwärtsfehleranalyse: Untersucht, wie Fehler in den Eingabewerten das Ergebnis beeinflussen
• Rückwärtsfehleranalyse: Untersucht, wie Eingabewerte geändert werden müssten, um das exakte Ergebnis zu erhalten

• 1. Gegebene Funktionen:
  • Originalfunktion: \( f(x) = e^x \)
  • Approximation: \( \tilde{f}(x) = (1 + \epsilon) f(x) \)
• 2. Bestimmung des absoluten Fehlers:Der absolute Fehler (\( \tilde{f}(x) \)) ist:
  • \( |f(x) - \tilde{f}(x)| = |e^x - (1 + \epsilon)e^x| \)
  • \( = |e^x - e^x - \epsilon e^x| \)
  • \( = |-\epsilon e^x| \)
  • \( = \epsilon e^x \)
• 3. Bestimmung des relativen Fehlers:Davon ausgehend berechnen wir den relativen Fehler:
  • \( \frac{|f(x) - \tilde{f}(x)|}{|f(x)|} = \frac{\epsilon e^x}{e^x} \)
  • \( = \epsilon \)
• 4. Ergebnis: Somit beträgt der relative Fehler \( \epsilon \).

b)

Betrachte die Näherung der Berechnung eines Integrals mittels einer numerischen Summationstechnik (z.B. Trapezregel). Analysiere den Abschneidefehler für das Integral \( \int_0^1 e^x \, dx \), wenn das Integral durch eine endliche Summe angenähert wird. Bestimme den absoluten und relativen Fehler dieser Näherung.

Lösung:

Fehleranalyse und numerische StabilitätFehleranalyse untersucht, wie Rundungsfehler, Abschneidefehler und Modellierungsfehler die Genauigkeit von numerischen Berechnungen beeinflussen. Numerische Stabilität hingegen beschreibt, wie sensibel ein Algorithmus auf kleine Änderungen in den Eingabewerten reagiert.

• Rundungsfehler: Fehler durch begrenzte Präzision im Computer
• Abschneidefehler: Fehler durch die Approximation von unendlichen Reihen oder Integralen
• Modellierungsfehler: Diskrepanz zwischen realem Problem und dessen numerischem Modell
• Absolute Fehler: \( |x - \tilde{x}| \)
• Relative Fehler: \( \frac{|x - \tilde{x}|}{|x|} \)
• Voraussetzung für Stabilität: Algorithmus bleibt für kleine Eingangsänderungen robust
• Vorwärtsfehleranalyse: Untersucht, wie Fehler in den Eingabewerten das Ergebnis beeinflussen
• Rückwärtsfehleranalyse: Untersucht, wie Eingabewerte geändert werden müssten, um das exakte Ergebnis zu erhalten

• 1. Exakte Berechnung des Integrals:Die exakte Lösung des Integrals ist gegeben durch:
  • \( \int_0^1 e^x \, dx \)
  • \( = [e^x]_0^1 \)
  • \( = e^1 - e^0 \)
  • \( = e - 1 \)
• 2. Näherung mittels Trapezregel:Die Trapezregel für ein Integral von 0 bis 1 mit \( n \) gleichmäßig verteilten Intervallen lautet:
  • \( T_n = \frac{1}{n} \left( \frac{e^0 + e^1}{2} + \sum_{i=1}^{n-1} e^{i/n} \right) \)
• 3. Abschneidefehler bestimmen:Der Abschneidefehler ist die Differenz zwischen dem exakten Integral und der Näherung.
  • \( E_n = \left| \int_0^1 e^x \, dx - T_n \right| \)
  Da der Abschneidefehler bei der Trapezregel proportional zu \( 1/n^2 \) ist, können wir schreiben:
  • \( E_n \approx \frac{K}{n^2} \), wobei \( K \) eine Konstante ist, die vom Integral abhängt.
• 4. Absoluter und relativer Fehler:Um den absoluten und relativen Fehler zu berechnen, setzen wir den bekannten Fehler in die Formel ein:
  • Absoluter Fehler: \( E_n \)
  • Relativer Fehler: \( \frac{E_n}{|e-1|} \)
• Wenn für \( n \) 100 gewählt wird (angenommen), der Fehler dann nähert sich:\(E_n \approx \frac{K}{100^2} = \frac{K}{10000}\)

• Daher der absolute Fehler: \(E_n \approx \frac{K}{10000}\)
• Der relative Fehler: \(\frac{E_n}{e-1} \approx \frac{K}{10000|e-1|} \)

c)

Ein Algorithmus zur Lösung eines linearen Gleichungssystems ist gegeben. Führe eine Rückwärtsfehleranalyse durch, um zu bestimmen, wie die Eingabewerte \( A \) und \( \textbf{b} \) geändert werden müssten, damit das exakte Ergebnis \( \textbf{x} \) gegeben wird. Nutze hierfür die Formel \( A\textbf{x} = \textbf{b} \).

Lösung:

Fehleranalyse und numerische StabilitätFehleranalyse untersucht, wie Rundungsfehler, Abschneidefehler und Modellierungsfehler die Genauigkeit von numerischen Berechnungen beeinflussen. Numerische Stabilität hingegen beschreibt, wie sensibel ein Algorithmus auf kleine Änderungen in den Eingabewerten reagiert.

• Rundungsfehler: Fehler durch begrenzte Präzision im Computer
• Abschneidefehler: Fehler durch die Approximation von unendlichen Reihen oder Integralen
• Modellierungsfehler: Diskrepanz zwischen realem Problem und dessen numerischem Modell
• Absolute Fehler: \( |x - \tilde{x}| \)
• Relative Fehler: \( \frac{|x - \tilde{x}|}{|x|} \)
• Voraussetzung für Stabilität: Algorithmus bleibt für kleine Eingangsänderungen robust
• Vorwärtsfehleranalyse: Untersucht, wie Fehler in den Eingabewerten das Ergebnis beeinflussen
• Rückwärtsfehleranalyse: Untersucht, wie Eingabewerte geändert werden müssten, um das exakte Ergebnis zu erhalten

• 1. Gegebenes Problem:Das lineare Gleichungssystem lautet:
  • \( A\textbf{x} = \textbf{b} \)
• 2. Definitionsgemäß genaue Lösung:Angenommen, wir haben bereits eine Lösung \( \tilde{\textbf{x}} \) gefunden. Dann muss näherungsweise gelten:
  • \( A\tilde{\textbf{x}} \approx \textbf{b} \)
• 3. Bestimmung des Rückwärtsfehlers:Um den Rückwärtsfehler zu analysieren, bestimmen wir, wie \( A \) und \( \textbf{b} \) geändert werden müssten, damit \( \tilde{\textbf{x}} \) exakt ist. Hierfür setzen wir an:
  • \( (A + \delta A) \tilde{\textbf{x}} = \textbf{b} + \delta \textbf{b} \)
• 4. Beziehung für die Änderung:Falls \( \textbf{x} \) die exakte Lösung ist, muss gelten:
  • \( A\textbf{x} = \textbf{b} \)
  Indem wir dies für \( \tilde{\textbf{x}} \) aufschreiben und umformen, erhalten wir:
  • \( A(\tilde{\textbf{x}} - \textbf{x}) = \delta \textbf{b} - \delta A \tilde{\textbf{x}} \)
• 5. Residualvektor:Der Residualvektor \( \textbf{r} \) kann definiert werden als:
  • \( \textbf{r} = \textbf{b} - A\tilde{\textbf{x}} \)
• 6. Berechnung der Änderungen:Der Rückwärtsfehler \( \delta \textbf{b} \) und \( \delta A \) kann dann wie folgt berechnet werden:
  • \( \delta \textbf{b} = \textbf{r} + \delta A \tilde{\textbf{x}} \)
  wobei \( \delta A \) typischerweise klein ist. Wir können auch schreiben:
  • \( \delta A = A\tilde{\textbf{x}} - A\textbf{x} \)
• 7. Schlussfolgerung:Die Änderungen \( \delta A \) und \( \delta \textbf{b} \) geben uns Auskunft darüber, wie stark die Matrix \( A \) und der Vektor \( \textbf{b} \) verändert werden müssten, um das exakte Ergebnis \( \textbf{x} \) zu erhalten.

Aufgabe 3)

Angenommen, Du hast eine Funktion f(x), die durch die folgende Tabelle von Werten gegeben ist:

• f(0) = 1
• f(1) = 1.5
• f(2) = 2.2
• f(3) = 3.1
• f(4) = 4.5

Verwende die angegebenen numerischen Methoden zur Approximation und Beantwortung der folgenden Aufgaben:

a)

1. Bestimme das Integral der Funktion f(x) von x=0 bis x=4 unter Verwendung der Trapezregel. Gib das Ergebnis in korrekter mathematischer Notation an.

Lösung:

Um das Integral der Funktion f(x) von x=0 bis x=4 unter Verwendung der Trapezregel zu bestimmen, folgen wir diesen Schritten:

• Die Trapezregel berechnet eine Näherung des Integrals durch das Aufteilen des Integrationsbereichs in kleinere Trapeze statt Rechtecke. Jedes Trapez wird durch zwei aufeinanderfolgende Punkte gebildet.

Die Trapezregel ist gegeben durch:

\[ \text{Integral} \, \text{via} \, \text{Trapezregel} \approx \frac{h}{2} \, \left[ f(x_0) + 2 \, \sum_{i=1}^{n-1} f(x_i) + f(x_n) \right] \]

• Hier ist h die Breite jedes Unterintervalls, und n ist die Anzahl der Unterintervalle.

In unserem Fall ist h konstant und beträgt 1 (weil x in gleichen Schritten von 0 bis 4 zunimmt). Die n ist 4, weil wir vier Unterintervalle zwischen 5 Punkten haben.

Also, setzt sich unser Ausdruck wie folgt zusammen:

\[\text{Integral} \approx \frac{1}{2} \, \left[ f(0) + 2 \, (f(1) + f(2) + f(3)) + f(4) \right]\]

Setze die Werte von f(x) ein:

• f(0) = 1
• f(1) = 1.5
• f(2) = 2.2
• f(3) = 3.1
• f(4) = 4.5

Erhalten wir:

\[\text{Integral} \approx \frac{1}{2} \, \left[ 1 + 2 \, (1.5 + 2.2 + 3.1) + 4.5 \right]\]

Zuerst berechnen wir den Wert innerhalb der Klammern:

• 1 + 2 \, (1.5 + 2.2 + 3.1) + 4.5
• 1 + 2 \, (6.8) + 4.5
• 1 + 13.6 + 4.5 = 19.1

Jetzt die endgültige Berechnung:

\[ \frac{1}{2} \, \times 19.1 = 9.55 \]

Daher ist das Integral der Funktion f(x) von x=0 bis x=4 unter Verwendung der Trapezregel:

\[ \int_{0}^{4} f(x) \, dx \approx 9.55 \]

b)

2. Approximiert die Ableitung der Funktion f(x) an der Stelle x=2 unter Verwendung des Vorwärtsdifferenzenquotienten mit h=1. Gebe das Ergebnis als numerischen Wert an.

Lösung:

Um die Ableitung der Funktion f(x) an der Stelle x=2 unter Verwendung des Vorwärtsdifferenzenquotienten mit h=1 zu approximieren, folgen wir diesen Schritten:

• Der Vorwärtsdifferenzenquotient ist eine Methode zur numerischen Berechnung der Ableitung. Der geeignete Ausdruck lautet:

\[ f'(x) \approx \frac{f(x+h) - f(x)}{h} \]

• In unserem Fall ist x=2 und h=1.

Setzen wir die Werte ein:

\[ f'(2) \approx \frac{f(2+1) - f(2)}{1} = \frac{f(3) - f(2)}{1} \]

Verwenden wir die gegebenen Werte für f(3) und f(2):

• f(3) = 3.1
• f(2) = 2.2

Erhalten wir:

\[ f'(2) \approx \frac{3.1 - 2.2}{1} = 0.9 \]

Daher beträgt die approximierte Ableitung der Funktion f(x) an der Stelle x=2:

\[ f'(2) \approx 0.9 \]

c)

3. Vergleiche die Ergebnisse des Vorwärtsdifferenzenquotienten und des Zentraldifferenzenquotienten, indem Du die Ableitung der Funktion f(x) an der Stelle x=2 unter Verwendung beider Methoden mit h=1 berechnest. Wie unterscheiden sich die Ergebnisse und warum könnten sie unterschiedlich sein?

Lösung:

Um die Ableitung der Funktion f(x) an der Stelle x=2 mit dem Vorwärtsdifferenzenquotient und dem Zentraldifferenzenquotient zu berechnen und zu vergleichen, gehen wir wie folgt vor:

Vorwärtsdifferenzenquotient

Wie bereits in der vorherigen Aufgabe berechnet, ist der Vorwärtsdifferenzenquotient gegeben durch:

\[ f'(x) \approx \frac{f(x+h) - f(x)}{h} \]

Für x=2 und h=1:

\[ f'(2) \approx \frac{f(3) - f(2)}{1} = \frac{3.1 - 2.2}{1} = 0.9 \]

Zentraldifferenzenquotient

Der Zentraldifferenzenquotient wird verwendet, um eine präzisere Näherung der Ableitung zu erhalten. Er wird durch den Ausdruck:

\[ f'(x) \approx \frac{f(x+h) - f(x-h)}{2h} \]

Für x=2 und h=1:

\[ f'(2) \approx \frac{f(3) - f(1)}{2 \, \times \, 1} = \frac{3.1 - 1.5}{2} = \frac{1.6}{2} = 0.8 \]

Vergleich der Ergebnisse

Die berechneten Werte für die Ableitung an der Stelle x=2 sind:

• Vorwärtsdifferenzenquotient: 0.9
• Zentraldifferenzenquotient: 0.8

Unterschiede und Gründe

Die beiden Methoden liefern leicht unterschiedliche Ergebnisse für die Ableitung. Dies liegt an der Art und Weise, wie die Differenzenquotienten berechnet werden:

• Vorwärtsdifferenzenquotient: Diese Methode nutzt die Differenz zwischen dem Punkt x und dem nächsten Punkt x+h. Diese Methode kann weniger genau sein, da sie nur eine Seite der Werte betrachtet.
• Zentraldifferenzenquotient: Diese Methode berücksichtigt sowohl den Punkt x-h als auch den Punkt x+h. Dadurch wird eine symmetrische Differenz gebildet, die in der Regel eine genauere Näherung der Ableitung liefert.

Zusammenfassend lässt sich sagen, dass der Zentraldifferenzenquotient in der Regel präzisere Ergebnisse liefert, da er eine Mittelung der Werte um den Punkt x vornimmt. Der Vorwärtsdifferenzenquotient könnte weniger genau sein, vor allem wenn der größte Teil der Änderung außerhalb des betrachteten Intervalls liegt.

Aufgabe 4)

Löseverfahren für lineare und nichtlineare Gleichungssysteme: Du hast es mit einem linearen Gleichungssystem der Form Ax = b zu tun. Dabei ist A eine quadratische Matrix der Dimension n \times n und b ein Vektor der Dimension n. Weiterhin musst Du ein nichtlineares Gleichungssystem der Form f(x) = 0 lösen. Bei beiden Gleichungssystemen sollen Stabilität, Konvergenzgeschwindigkeit und Konditionierung berücksichtigt werden.

• Lineare Gleichungssysteme: Ax = b
• Methoden: Direkte Verfahren (z.B. Gauss, LU-Zerlegung) und Iterative Verfahren (z.B. Jacobi, Gauss-Seidel, Conjugate Gradient)
• Nichtlineare Gleichungssysteme: f(x) = 0
• Methoden: Newton-Verfahren, Modifizierte Newton-Verfahren, und Broyden-Verfahren
• Beachte Konditionierung und Stabilität
• Bedeutung der Konvergenzgeschwindigkeit
• Anwendung in Simulationen und wissenschaftlicher Berechnung

a)

Die quadratische Matrix A und der Vektor b sind wie folgt gegeben:

A = [[4, 1, 2],  [1, 3, 1],  [0, 1, 1]]b = [4, 5, 3]

Lösung:

Solve the linear system Ax = b using the Gauss method. Follow these detailed steps:

• Step 1: Write the augmented matrix [A|b]

  A = [[4, 1, 2],     [1, 3, 1],     [0, 1, 1]]b = [4, 5, 3][ A | b ] =[ 4, 1, 2 | 4 ][ 1, 3, 1 | 5 ][ 0, 1, 1 | 3 ]

• Step 2: Forward Elimination
  • Eliminate the element in the first column of the second row:

  R2 = R2 - (1/4) * R1-> [ 4, 1, 2 | 4 ]   [ 0, 11/4, 1/2 | 4 ]   [ 0, 1, 1 | 3 ]

• Eliminate the element in the first column of the third row:

(No change needed since the element is already zero)

R3 = R3 - (4/11) * R2-> [ 4, 1, 2 | 4 ]   [ 0, 11/4, 1/2 | 4 ]   [ 0, 0, 4/11 | 20/11 ]

4/11 * x3 = 20/11-> x3 = 5

11/4 * x2 + 1/2 * 5 = 4-> 11/4 * x2 + 5/2 = 4-> 11/4 * x2 = 3/2-> x2 = 6/11 * 3/2 = 3/2

4 * x1 + 1 * (3/2) + 2 * 5 = 4-> 4 * x1 + 11 = 4-> 4 * x1 = -7-> x1 = -7/4

x = [-7/4,     3/2,     5]

b)

Implementiere das Jacobi-Verfahren in Python, um das obige Gleichungssystem Ax = b iterativ zu lösen. Setze eine maximale Anzahl von Iterationen auf 100 fest und den Toleranzwert auf \(\text{tol} = 1e-5\).Achte darauf, dass der Code korrekt formatiert ist und die Ergebnisse schrittweise ausgegeben werden.

def jacobi(A, b, x0, max_iter, tol):    n = len(b)    x = x0.copy()    x_new = x0.copy()    for k in range(max_iter):        for i in range(n):            s = sum(A[i][j] * x[j] for j in range(n) if j != i)            x_new[i] = (b[i] - s) / A[i][i]        if all(abs(x_new[i] - x[i]) < tol for i in range(n)):            return x_new        x = x_new.copy()    return xA = [[4, 1, 2], [1, 3, 1], [0, 1, 1]]b = [4, 5, 3]x0 = [0, 0, 0]max_iter = 100tol = 1e-5solution = jacobi(A, b, x0, max_iter, tol)

Lösung:

Implementierung des Jacobi-Verfahrens in Python:

def jacobi(A, b, x0, max_iter, tol):    n = len(b)    x = x0.copy()    x_new = x0.copy()    for k in range(max_iter):        for i in range(n):            s = sum(A[i][j] * x[j] for j in range(n) if j != i)            x_new[i] = (b[i] - s) / A[i][i]        if all(abs(x_new[i] - x[i]) < tol for i in range(n)):            print(f'Konvergiert nach {k+1} Iterationen: {x_new}')            return x_new        x = x_new.copy()        print(f'Iteration {k+1}: {x_new}')    return xA = [[4, 1, 2], [1, 3, 1], [0, 1, 1]]b = [4, 5, 3]x0 = [0, 0, 0]max_iter = 100tol = 1e-5solution = jacobi(A, b, x0, max_iter, tol)print(f'Lösung: {solution}')

• Das Jacobi-Verfahren konvergiert, wenn die Matrix A streng diagonal dominant ist oder eine positiv definite Matrix (auch wenn es nicht notwendigerweise eine Voraussetzung ist).
• Die Konvergenzgeschwindigkeit wird stark von der Struktur und den Werten der Matrix A beeinflusst. Eine schlecht konditionierte Matrix kann die Konvergenz verlangsamen.
• Da wir ein Kriterium für die Toleranz von tol = 1e-5 und eine maximale Iterationszahl von 100 gesetzt haben, garantiert dies, dass wir entweder eine Lösung mit hoher Genauigkeit oder eine Lösung nach 100 Iterationen erhalten.
• Für die gegebene Matrix A und den Vektor b wird das Jacobi-Verfahren in der Regel schnell konvergieren, da A in diesem Fall eine gut konditionierte Matrix zu sein scheint.
• In den Ausgaben des oben implementierten Codes werden die Zwischenschritte bei jeder Iteration angezeigt, wodurch die Konvergenz über die Iterationen beobachtet werden kann.