Newton Iteration

[BlackJack]

@MagBen: Ich sehe nicht das er da irgendeinen Algorithmus *selbst* implementiert hat. Fremden Quelltext hernehmen und an einer Stelle eine Funktion ändern kann man auch ohne vorher verstanden zu haben was der Rest macht.

[Justifiez]

Ok, inwieweit verändert denn das math.exp(x) die letztendliche Lösung? Kann man das überhaupt in einer Zahl ausdrücken?

Ich habe auch gesehen, dass bei Linearen Funktionen das math.exp(x) die Lösung leicht verändert. Je größer der Anstieg der Funktion wird, desto niedriger wird der Fehler, ist aber trotzdem meisten noch zu hoch:

Code: Alles auswählen

def F(x):
    f = math.exp(x) + 100*x + 1
    df = math.exp(x) + 100
    return (f, df)

Code: Alles auswählen

Iteration Nr.:       Root value:     Value of f(x):
I    0:              -0.01980198,       0.00019477
I    1:              -0.01980391,       0.00000000
----------
Ungefähre Nullstelle:-0.019803909002865445

Auch wenn sich das "n" (bei einer linearen Funktion: y = m*x + n) ändert, sinkt der Fehler. Vielleicht ist das aber auch zu subjektiv

Code: Alles auswählen

def F(x):
    f = math.exp(x) + 100*x + 100
    df = math.exp(x) + 100
    return (f, df)

Code: Alles auswählen

Iteration Nr.:       Root value:     Value of f(x):
I    0:              -1.00000000,       0.36787944
I    1:              -1.00366531,       0.00000247
I    2:              -1.00366534,       0.00000000
----------
Ungefähre Nullstelle:-1.0036653350790592

@Blackjack: Korrigiere mich bitte, wenn ich falsch liege. Ich war aber der Meinung, dass das Tangentenverfahren von Newton zur Nullstellenberechnung war.
Mit dieser entscheidenden Formel:

x(n+1) = x(n) - f(x(n))/f'(x(n))

[MagBen]

Fremden Quelltext hernehmen und an einer Stelle eine Funktion ändern kann man auch ohne vorher verstanden zu haben was der Rest macht.

Eben!

[BlackJack]

@MagBen: Häh? :K

[Justifiez]

Heißt das math.exp(x) , das in die Nullstellenberechnung jedesmal ein e^x einfließt?

Das kann ich mir irgendwie nicht vorstellen, würde aber Sinn machen, weil es in der Ableitung wieder vorkommt.

[MagBen]

Häh? :K

Erst schlägst Du vor er soll den Algorithmus erst verstehen bevor er ihn implementiert, dann sagst Du es geht auch ohne Verständnis (wenn man fremden Quelltext nimmt).

Ok, inwieweit verändert denn das math.exp(x) die letztendliche Lösung? Kann man das überhaupt in einer Zahl ausdrücken?

Ja
korrekte Lösung: x=sqrt(7)
um wieviel verändert math.exp(x) den Funktionswert an dieser Stelle?
Um: math.exp( sqrt(7) )
und das ist recht viel, wenn man Nullstellen sucht.

Heißt das math.exp(x) , das in die Nullstellenberechnung jedesmal ein e^x einfließt?

Du definierst die Funktion, die Du an Newton übergibst und alles was in dieser Funktion drin steht beeinflusst die Lösung. Warum sollte Newton da was weglassen?

[BlackJack]

@MagBen: Das eine ist was man machen sollte, das zweite ist was gemacht wurde und da gehört noch der Satz davor dazu:

Ich sehe nicht das er da irgendeinen Algorithmus *selbst* implementiert hat. Fremden Quelltext hernehmen und an einer Stelle eine Funktion ändern kann man auch ohne vorher verstanden zu haben was der Rest macht.

[Justifiez]

Ah, gut, ok.
Das macht natürlich Sinn. Dann macht es auch umso mehr Sinn, das der Fehler kleiner wird, je größer der Anstieg (oder Stauchung) ist.

Cool, danke.

Ich habe mir jetzt mal den Fehler durch math.exp() ausgegeben. Und zumindest bei linearen Funktionen kann man den Fehler auf die ungefähre Nullstelle addieren und kommt dann auf den richtigen Wert:

Code: Alles auswählen

def F(x):
    f = math.exp(x) + x + 2
    df = math.exp(x) + 1
    return (f, df)

Weiter unten im Code steht dann:

Code: Alles auswählen

 print ("-" * 10)
    print(str(math.exp(x)))
    print("Ungefähre Nullstelle:" + str(x))
    print ("-" * 10)

Ausgabe:

Code: Alles auswählen

Iteration Nr.:       Root value:     Value of f(x):
I    0:              -1.50000000,       0.72313016
I    1:              -2.09121276,       0.03232446
I    2:              -2.11998303,       0.00005064
I    3:              -2.12002824,       0.00000000
----------
0.12002823900078922
Ungefähre Nullstelle:-2.1200282388781004

Für quadratische Gleichungen funktioniert das dann leider nicht mehr:

Code: Alles auswählen

def F(x):
    f = math.exp(x) + x**2 - 4
    df = math.exp(x) + 2*x
    return (f, df)

Ausgabe:

Code: Alles auswählen

Iteration Nr.:       Root value:     Value of f(x):
I    0:              3.00000000,       25.08553692
I    1:              2.03833542,       7.83262949
I    2:              1.37198323,       1.82550114
I    3:              1.09899598,       0.20894346
I    4:              1.05880792,       0.00400649
I    5:              1.05800671,       0.00000157
I    6:              1.05800640,       0.00000000
----------
2.880622455251378
Ungefähre Nullstelle:1.0580064010906844
----------

[MagBen]

Ich würde math.exp lieber weglassen und die Null-Division abfangen anstatt den Fehler abzuschätzen, den Du selbst eingebaut hast.

Quick-and-Dirty-Lösung:
Verschieb einfach den Startwert, wenn eine Null-Division auftritt.