This is documentation for Mathematica 4, which was
based on an earlier version of the Wolfram Language.
View current documentation (Version 11.1)

 Documentation /  Mathematica /  Das Mathematica Buch /  Höhere Mathematik in Mathematica /  Numerische Operationen mit Funktionen /

Numerische NullstellensucheNumerische Minimierung

3.9.7 Numerische Lösung von Differentialgleichungen

Mit der Funktion NDSolve (siehe Abschnitt 1.6.4) können Sie numerische Lösungen für Differentialgleichungen finden. NDSolve kann sowohl mit einzelnen Differentialgleichungen als auch mit Systemen simultaner Differentialgleichungen umgehen. Es kann eine große Zahl gewöhnlicher Differentialgleichungen sowie einige partielle Differentialgleichungen bearbeiten. Bei einem System gewöhnlicher Differentialgleichungen kann es eine beliebige Anzahl unbekannter Funktionen geben, aber alle diese Funktionen müssen von nur einer „unabhängigen Variablen" x abhängen, die für jede Funktion dieselbe ist. Partielle Differentialgleichungen enthalten zumindest zwei unabhängige Variablen.

Finden numerischer Lösungen für gewöhnliche Differentialgleichungen

NDSolve präsentiert Lösungen für die Funktionen als InterpolatingFunction-Objekte. Die InterpolatingFunction-Objekte bieten Annäherungen an die über den Wertebereich xmin bis xmax für die unabhängige Variable x.

NDSolve bestimmt die Lösungen iterativ. Es startet an einem bestimmten Wert von x, geht eine Anzahl Schritte und versucht, am Ende den gesamten Bereich xmin bis xmax abzudecken.

Um beginnen zu können, benötigt NDSolve entsprechende „Anfangs- oder Randbedingungen" für die und ihre Ableitungen. Diese Bedingungen spezifizieren Werte für [x] und vielleicht Ableitungen '[x] für bestimmte Werte von x. Zumindest für gewöhnliche Differentialgleichungen können die Anfangsbedingungen im allgemeinen für jeden Wert von x angegeben werden: NDSolve wird automatisch schrittweise den Bereich xmin bis xmax abdecken.

Dies findet eine Lösung für y, wobei x im Bereich von 0 bis 2 liegt, unter Verwendung einer Anfangsbedingung für y[0].

In[1]:= NDSolve[{y'[x] == y[x], y[0] == 1}, y, {x, 0, 2}]

Out[1]=

Dies findet immer noch eine Lösung, wobei x im Bereich von 0 bis 2 liegt, aber nun ist die Anfangsbedingung für y[3] gegeben.

In[2]:= NDSolve[{y'[x] == y[x], y[3] == 1}, y, {x, 0, 2}]

Out[2]=

Hier ist ein einfaches Randwertproblem.

In[3]:= NDSolve[{y''[x] + x y[x] == 0, y[0] == 1, y[1] == -1},
y, {x, 0, 1}]

Out[3]=

Wenn Sie NDSolve einsetzen, müssen Ihre Anfangs- oder Randbedingungen zur vollständigen Bestimmung der Lösungen für die ausreichen. Wenn Sie mit DSolve symbolische Lösungen für Differentialgleichungen suchen, können Sie dies auch durch Angabe von weniger Anfangsbedingungen tun. Dies geht, weil DSolve automatisch beliebige Konstanten C[i] einfügt, die Freiheitsgrade repräsentieren, die mit Anfangsbedingungen verknüpft sind, die Sie nicht explizit spezifiziert haben. Da NDSolve eine numerische Lösung liefern muß, kann es diese zusätzlichen Freiheitsgrade nicht darstellen. Deshalb müssen Sie alle Anfangs-oder Randbedingungen, die zur Bestimmung der Lösung benötigt werden, explizit angeben.

Wenn Sie in einem typischen Fall Differentialgleichungen bis zur -ten Ableitung haben, dann müssen Sie Anfangsbedingungen bis zu den -ten Ableitungen oder Randbedingungen für Punkte spezifizieren.

Bei einer Gleichung dritter Ordnung müssen Sie Anfangsbedingungen bis zur zweiten Ableitung angeben.

In[4]:= NDSolve[
{ y'''[x] + 8 y''[x] + 17 y'[x] + 10 y[x] == 0,
y[0] == 6, y'[0] == -20, y''[0] == 84},
y, {x, 0, 1} ]

Out[4]=

Dies zeichnet die erhaltene Lösung.

In[5]:= Plot[Evaluate[ y[x] /. % ], {x, 0, 1}]

Out[5]=

Für eine Differentialgleichung dritter Ordnung können auch Randbedingungen für drei Punkte angegeben werden.

In[6]:= NDSolve[
{ y'''[x] + Sin[x] == 0,
y[0] == 4, y[1] == 7, y[2] == 0 }, y, {x, 0, 2}]

Out[6]=

Mathematica erlaubt jede geeignete Linearkombination von Funktionswerten und Ableitungen als Randbedingungen.

In[7]:= NDSolve[{ y''[x] + y[x] == 12 x,
2 y[0] - y'[0] == -1, 2 y[1] + y'[1] == 9},
y, {x, 0, 1}]

Out[7]=

In den meisten Fällen müssen alle Ihre Anfangsbedingungen denselben Wert von x, beispielsweise , enthalten. Deshalb können Sie es vermeiden, sowohl xmin als auch xmax explizit anzugeben. Wenn Sie Ihren x-Bereich als x, spezifizieren, dann wird Mathematica automatisch eine Lösung über dem Bereich bis erzeugen.

Dies erzeugt eine Lösung über dem Bereich 0 bis 2.

In[8]:= NDSolve[{y'[x] == y[x], y[0] == 1}, y, {x, 2}]

Out[8]=

Sie können Anfangsbedingungen als Gleichungen beliebiger Art angeben. In einigen Fällen mögen diese Gleichungen mehrfache Lösungen haben. Dann wird NDSolve entsprechend mehrfache Lösungen erzeugen.

Die Anfangsbedingungen führen in diesem Fall zu mehrfachen Lösungen.

In[9]:= NDSolve[{y'[x]^2 - y[x]^2 == 0, y[0]^2 == 4},
y[x], {x, 1}]

Out[9]=

Hier ist ein Diagramm aller Lösungen.

In[10]:= Plot[Evaluate[ y[x] /. % ], {x, 0, 1}]

Out[10]=

Mit NDSolve lassen sich Systeme gekoppelter Differentialgleichungen lösen.

Dies findet eine numerische Lösung für ein Paar gekoppelter Gleichungen.

In[11]:= sol = NDSolve[
{x'[t] == -y[t] - x[t]^2, y'[t] == 2 x[t] - y[t],
x[0] == y[0] == 1}, {x, y}, {t, 10}]

Out[11]=

Dies zeichnet die aus diesen Gleichungen gewonnene Lösung für y.

In[12]:= Plot[Evaluate[y[t] /. sol], {t, 0, 10}]

Out[12]=

Dies erzeugt ein parametrisches Diagramm, das sowohl x als auch y zeigt.

In[13]:= ParametricPlot[Evaluate[{x[t], y[t]} /. sol],
{t, 0, 10}, PlotRange -> All]

Out[13]=

Unbekannte Funktionen in Differentialgleichungen müssen nicht notwendigerweise durch einzelne Symbole dargestellt werden. Wenn Sie eine große Anzahl unbekannter Funktionen haben, werden Sie es häufig als zweckmäßiger empfinden, daß man den Funktionen zum Beispiel Namen wie y[i] geben kann.

Dies konstruiert ein System von fünf gekoppelten Differentialgleichungen und Anfangsbedingungen.

In[14]:= gln = Join[
Table[ y[i]'[x] == y[i-1][x] - y[i][x], {i, 2, 4} ],
{y[1]'[x] == -y[1][x], y[5]'[x] == y[4][x],
y[1][0] == 1},
Table[ y[i][0] == 0, {i, 2, 5}]
]

Out[14]=

Dies löst die Gleichungen.

In[15]:= NDSolve[gln, Table[y[i], {i, 5}], {x, 10}]

Out[15]=

Hier ist ein Diagramm der Lösungen.

In[16]:= Plot[ Evaluate[Table[y[i][x], {i, 5}] /. %],
{x, 0, 10} ]

Out[16]=

Optionen für NDSolve

Mit NDSolve kann die gewünschte Präzision oder Genauigkeit des Ergebnisses spezifiziert werden. Im allgemeinen verkleinert NDSolve die Schritte, bis die Lösung, die es erhält, entweder das angegebene AccuracyGoal oder das PrecisionGoal erfüllt. Im Grunde bestimmt die Einstellung für AccuracyGoal den absoluten Fehler, der in der Lösung erlaubt wird, während die Einstellung für PrecisionGoal den relativen Fehler vorgibt. Sobald man in die Nähe einer Lösung gelangt, deren Wert ungefähr Null wird, wird in der Regel die Einstellung für AccuracyGoal erhöht werden müssen. Durch die Festlegung AccuracyGoal -> Infinity wird NDSolve angewiesen, nur PrecisionGoal zu verwenden.

Die Mathematica-Funktion NDSolve legt mit Ihrer Einstellung von WorkingPrecision die Gesamtanzahl der Stellen fest, die bei ihren internen Berechnungen verwendet werden sollen. Spezifizieren Sie große Werte für AccuracyGoal oder PrecisionGoal, dann müssen Sie in der Regel einen etwas größeren Wert für WorkingPrecision angeben. Mit der Voreinstellung Automatic sind sowohl AccuracyGoal als auch PrecisionGoal gleich der Einstellung für WorkingPrecision abzüglich 10 Stellen.

Dies erzeugt eine Lösung hoher Präzision für eine komplexe Differentialgleichung.

In[17]:= NDSolve[{y'[x] == I/4 y[x], y[0] == 1}, y, {x, 1},
AccuracyGoal -> 20, PrecisionGoal -> 20,
WorkingPrecision -> 25]

Out[17]=

Hier ist eine mit der Lösung gefundene Näherung für .

In[18]:= y[1] /. %

Out[18]=

Wie bereits erwähnt, bewegt sich NDSolve in einer Folge von Schritten in der unabhängigen Variablen x fort. Zur Bestimmung der Schrittgröße setzt NDSolve ein adaptives Verfahren ein. Allgemein gilt dabei: Wenn die Lösung in einem bestimmten Gebiet schnell zu variieren scheint, dann wird NDSolve die Schrittgröße reduzieren, um der Lösung besser auf der Spur bleiben zu können.

Dies löst eine Differentialgleichung, in der die Ableitung eine Unstetigkeit hat.

In[19]:= NDSolve[
{y'[x] == If[x < 0, 1/(x-1), 1/(x+1)],
y[-5] == 5},
y, {x, -5, 5}]

Out[19]=

Um den Knick akkurat zu reproduzieren, hat NDSolve die Schrittgröße um reduziert.

In[20]:= Plot[Evaluate[y[x] /. %], {x, -5, 5}]

Out[20]=

Das adaptive Verfahren ermöglicht es NDSolve, „steife" Differentialgleichungen zu lösen. In diesen Gleichungen gibt es mehrere Komponenten, die bezüglich x sehr unterschiedlich variieren.

In diesen Gleichungen variiert y sehr viel schneller als z.

In[21]:= sol = NDSolve[
{y'[x] == -40 y[x], z'[x] == -z[x]/10,
y[0] == z[0] == 1},
{y, z}, {x, 0, 1}]

Out[21]=

NDSolve verfolgt trotzdem beide Komponenten erfolgreich.

In[22]:= Plot[Evaluate[{y[x], z[x]} /. sol], {x, 0, 1},
PlotRange -> All]

Out[22]=

NDSolve geht nach dem allgemeinen Verfahren vor, die Schrittgröße so lange zu reduzieren, bis es die Lösungen akkurat verfolgt. Es gibt jedoch ein Problem, wenn die wahre Lösung eine Singularität hat. Dann kann es dazu kommen, daß NDSolve die Schrittgröße immer weiter reduziert und damit nicht aufhört. Um dies zu vermeiden, kann mit der Option MaxSteps die maximale Schrittzahl begrenzt werden, die NDSolve beim Versuch, eine Lösung zu finden, jemals nehmen wird. Für gewöhnliche Differentialgleichungen ist die Voreinstellung MaxSteps -> 1000.

NDSolve bricht nach 1000 Schritten ab.

In[23]:= NDSolve[{y'[x] == -1/x^2, y[-1] == -1}, y[x], {x, -1, 0}]

Out[23]=

Es gibt tatsächlich eine Singularität in der Lösung bei .

In[24]:= Plot[Evaluate[y[x] /. %], {x, -1, 0}]

Out[24]=

Die Voreinstellung MaxSteps -> 1000 sollte für die meisten Gleichungen mit glatten Lösungen ausreichend sein. Haben Lösungen jedoch eine komplizierte Struktur, so müssen Sie eventuell manchmal für MaxSteps größere Einstellungen wählen. Mit der Einstellung MaxSteps -> Infinity gibt es keine obere Schranke für die Anzahl der verwendeten Schritte.

Um die vollständige Struktur der Lösung der Lorenz-Gleichungen zu reproduzieren, müssen Sie eine größere Einstellung für MaxSteps angeben.

In[25]:= NDSolve[ {x'[t] == -3 (x[t] - y[t]),
y'[t] == -x[t] z[t] + 26.5 x[t] - y[t],
z'[t] == x[t] y[t] - z[t],
x[0] == z[0] == 0, y[0] == 1},
{x, y, z}, {t, 0, 20}, MaxSteps->3000 ]

Out[25]=

Hier ist ein parametrisches Diagramm der Lösung in drei Dimensionen.

In[26]:= ParametricPlot3D[Evaluate[{x[t], y[t], z[t]} /. %],
{t, 0, 20}, PlotPoints -> 1000]

Out[26]=

Wenn NDSolve ein bestimmtes System von Differentialgleichungen löst, versucht es immer, eine für diese Gleichungen geeignete Schrittgröße zu wählen. Mitunter mag der allererste Schritt von NDSolve zu groß sein, und es kann eine wichtige Eigenschaft der Lösung verlorengehen. Um dieses Problem zu vermeiden, können Sie explizit mit der Option StartingStepSize die Größe des ersten Schrittes festlegen.

Numerische Lösungen für partielle Differentialgleichungen finden

Hiermit wird eine numerische Lösung der Wellengleichung gefunden. Das Ergebnis ist eine zweidimensionale Interpolationsfunktion.

In[27]:= NDSolve[{D[y[x, t], t, t] == D[y[x, t], x, x],
y[x, 0] == Exp[-x^2], Derivative[0,1][y][x, 0] == 0,
y[-5, t] == y[5, t]}, y, {x, -5, 5}, {t, 0, 5}]

Out[27]=

Dies erzeugt ein Diagramm des Ergebnisses.

In[28]:= Plot3D[Evaluate[y[x, t] /. First[%]],
{x, -5, 5}, {t, 0, 5}, PlotPoints->30]

Out[28]=

Dies ermittelt eine numerische Lösung der nichtlinearen Sinus-Gordon-Gleichung.

In[29]:= NDSolve[{D[y[x, t], t, t] == D[y[x, t], x, x] + Sin[y[x, t]],
y[x, 0] == Exp[-x^2], Derivative[0,1][y][x, 0] == 0,
y[-5, t] == y[5, t]}, y, {x, -5, 5}, {t, 0, 5}]

Out[29]=

Hier ist ein Diagramm des Ergebnisses.

In[30]:= Plot3D[Evaluate[y[x, t] /. First[%]],
{x, -5, 5}, {t, 0, 5}, PlotPoints->30]

Out[30]=

Numerische NullstellensucheNumerische Minimierung