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

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

Lineare OptimierungInhalt

3.9.10 Fortgeschrittenes Thema: Funktionen mit sensitiver Abhängigkeit von ihrer Eingabe

Der Wert einer Funktion, die durch einfache algebraische Formeln gegeben ist, ändert sich zumeist nur wenig, wenn ihre Argumente nur leicht geändert werden. Funktionen, die stattdessen auf der Ausführung von Prozeduren basieren, zeigen häufig beinahe beliebig sensitive Abhängigkeit von ihren Eingangsgrößen. In der Regel hat dieses Phänomen den Grund, daß die Prozedur zunehmend immer weniger signifikante Stellen in den Eingangsgrößen „ausgräbt".

Dies zeigt aufeinanderfolgende Schritte in einer einfachen iterativen Prozedur mit der Eingangsgröße 0.1111.

In[1]:= NestList[FractionalPart[2 #]&, 0.1111, 10]

Out[1]=

Hier ist das Ergebnis mit der Eingangsgröße 0.1112. Eine progressive Divergenz vom Ergebnis mit der Eingangsgröße kann festgestellt werden.

In[2]:= NestList[FractionalPart[2 #]&, 0.1112, 10]

Out[2]=

Die Wirkung von FractionalPart[2 x] ist besonders einfach ersichtlich, wenn man die Binärziffern der Zahl x betrachtet: Die erste Ziffer wird jeweils fallengelassen und die restlichen nach links verschoben. Nach mehreren Schritten führt dies dazu, daß die Ergebnisse, die man erhält, unweigerlich sensitiv werden für Stellen, die sehr weit zur Rechten liegen, und die einen extrem kleinen Einfluß auf den ursprünglichen Wert von x haben.

Dies zeigt den Verschiebungsprozeß, der durch FractionalPart[2 x] in den ersten 8 Binärziffern von x erreicht wird.

In[3]:= RealDigits[Take[%, 5], 2, 8, -1]

Out[3]=

Wenn die Eingabe nur mit einer bestimmten Präzision erfolgt, wird im Grunde nur eine bestimmte Anzahl Stellen angegeben. Und sobald diese Stellen abgearbeitet sind, erhält man keine akkuraten Ergebnisse mehr, da dazu mehr Stellen Ihrer ursprünglichen Eingabe bekannt sein müßten. Solange Sie beliebig präzise Zahlen einsetzen, führt Mathematica automatisch Buch über diese Art der Verminderung in der Präzision.

Aufeinanderfolgende Schritte führen zu zunehmend geringerer Präzision, und schließlich ist überhaupt keine Präzision mehr übrig.

In[4]:= NestList[FractionalPart[40 #]&, N[1/9, 20], 20]

Out[4]=

Dies fragt nach der Präzision jeder Zahl. Mathematica erzeugt eine Warnung für Zahlen, bei denen keine Präzision übrig ist.

In[5]:= Map[Precision, %]

Out[5]=

Dies zeigt, daß das exakte Ergebnis eine periodische Folge ist.

In[6]:= NestList[FractionalPart[40 #]&, 1/9, 10]

Out[6]=

Man sollte sich bewußt machen: Wenn beliebige Gleitpunktzahlen verwendet werden, dann wird man in einem Beispiel wie dem obigen schließlich immer die gesamte Präzision verlieren. Solange man aber Zahlen mit beliebiger Präzision verwendet, wird Mathematica explizit jede auftretende Abnahme der Präzision zeigen. Wenn man jedoch Zahlen mit Maschinenpräzision verwendet, dann wird Mathematica die Präzision nicht verfolgen, und man wird nicht sagen können, wann die Ergebnisse völlig wertlos werden.

Wenn man Zahlen mit Maschinenpräzision verwendet, wird Mathematica die Abnahme der Präzision nicht verfolgen.

In[7]:= NestList[FractionalPart[40 #]&, N[1/9], 20]

Out[7]=

Durch Iteration der Operation FractionalPart[2 x] werden aufeinanderfolgende Binärziffern in jeder beliebigen Zahl, mit der man startet, herausgezogen. Und wenn diese Ziffern zufällig erscheinen—wie in einer Zahl wie —dann werden die Ergebnisse entsprechend zufällig sein. Wenn die Ziffern jedoch ein einfaches Muster haben—wie in jeder rationalen Zahl—dann werden die Ergebnisse entsprechend simpel sein.

Durch Iteration einer Operation wie FractionalPart[3/2 x] ist es jedoch möglich, scheinbar zufällige Folgen zu erhalten, sogar mit sehr einfacher Eingabe. Dies ist ein Beispiel eines sehr allgemeinen Phänomens, das ich zuerst in den frühen 80er Jahren identifiziert habe und welches mit einer sensitiven Abhängigkeit von der Eingabe direkt nichts zu tun hat.

Dies erzeugt eine scheinbar zufällige Folge, sogar bei einem simplen Startwert.

In[8]:= NestList[FractionalPart[3/2 #]&, 1, 15]

Out[8]=

Nachdem die Werte berechnet worden sind, kann man sicher numerische Approximationen für sie finden.

In[9]:= N[%]

Out[9]=

Hier sind die letzten 5 Ergebnisse nach 1000 Iterationen, die mit exakten Zahlen berechnet wurden.

In[10]:= Take[N[NestList[FractionalPart[3/2 #]&, 1, 1000]], -5]

Out[10]=

Bei Zahlen mit Maschinenpräzision ergeben sich vollständig inkorrekte Ergebnisse.

In[11]:= Take[NestList[FractionalPart[3/2 #]&, 1., 1000], -5]

Out[11]=

Viele Arten iterativer Prozeduren ergeben Funktionen, die empfindlich von den Eingangswerten abhängen. Derartige Funktionen tauchen auch auf, wenn man Lösungen von Differentialgleichungen betrachtet. Die Variation eines unabhängigen Parameters in der Differentialgleichung ist eine stetiges Analogon für den Übergang von einem Schritt zum nächsten in einer iterativen Prozedur.

Hiermit wird eine Lösung der Duffing-Gleichung mit der Anfangssteigung 1 ermittelt.

In[12]:= NDSolve[{x''[t] + 0.15 x'[t] - x[t] + x[t]^3 == 0.3 Cos[t],
x[0] == -1, x'[0] == 1}, x, {t, 0, 50}]

Out[12]=

Hier ist ein Diagramm der Lösung.

In[13]:= Plot[Evaluate[x[t] /. %], {t, 0, 50}]

Out[13]=

Hier ist dieselbe Gleichung mit Anfangssteigung 1.001.

In[14]:= NDSolve[{x''[t] + 0.15 x'[t] - x[t] + x[t]^3 == 0.3 Cos[t],
x[0] == -1, x'[0] == 1.001}, x, {t, 0, 50}]

Out[14]=

Die Lösung divergiert zunehmend von der oben gezeigten.

In[15]:= Plot[Evaluate[x[t] /. %], {t, 0, 50}]

Out[15]=

Lineare OptimierungInhalt