_____________________________________________________________________________________
Inhalt....: Prozeduren und Experimente zum Newtonverfahren
Kategorie.: Unterrichtsmaterial
Mathematik: Analysis, Programmierung
MuPAD.....: 3.1.0
Datum.....: 2006-10-24
Autoren...: August Barkhausen <abarkhausen@gmx.de>
Funktionen: solve, float, matrix, DIGITS, Domain, Dom::Real, print, for, plot
Funktionen: proc, local, if, abs, plot::Funktion2d, plot::line2d
_____________________________________________________________________________________
Prozeduren und Experimente zum
Newtonverfahren.
Im folgenden geht es um das Newtonsche Näherungsverfahren zur Bestimmung von Nullstellen.
Es existieren bereits mehrere Notebooks in der Materialsammlung, die sich mit dem Newton-
verfahren beschäftigen.
In der Einführung in das Newtonverfahren von Alessandro Dell'Aere in dieser Materialsammlung
findet sich nach einer ausführlichen Erklärung des Algorithmus eine Prozedur zur iterativen
Berechnung der Nullstellen - dies jedoch ohne eine kompakte tabellarische Darstellung. In dem
Notebook von Vera Verspohl geht es um eine Veranschaulichung des Newtonverfahrens anhand
graphischer Darstellungen. Insbesondere findet sich dort eine Animation zur Veranschaulichung
des Newtonverfahrens.
In diesem Notebook geht es abweichend von den oben angesprochenen vorhandenen Note-
books nicht um eine Einführung des Verfahrens. Vielmehr sollen auf der Grundlage des bereits
bekannten Algorithmus folgende Aspekte berücksichtigt werden:
1) Die Ergebnisse der Einzeliterationen werden kompakt in einer
__Tabelle/ Matrix wiedergegeben. Die Ergebnisse der Iterationen
__sind graphisch darstellbar.
2) Die Durchführung der Rechnungen geschieht in einer Prozedur.
3) In einer weiteren Prozedur wird optional eine Veranschaulichung
__durch graphische Darstellungen der Iterationen realisiert.
4) Die Prozeduren werden benutzt, um anhand von Beispielen die
__Einsatzmöglichkeiten des Näherungsverfahrens exemplarisch zu
__demonstrieren und Grenzen der Einsatzmöglichkeiten aufzuzeigen.
5) In den Anregungen am Ende des Notebooks werden weitere An-
__regungen für die Arbeit mit dem Newtonverfahren geliefert.
6) Die Benutzung von Prozeduren stellt jetzt durch die Möglichkeit,
__komplexe Funktionen durch kompakte Befehle aufzurufen, eine
__Plattform für eigene Experimente mit dem Newtonschen Algo-
__rithmus bereit, ohne die konkrete Realisierung der Prozeduren
__in MuPAD im Detail nachvollziehen zu müssen.
Die Ergebnisse der Prozeduren wurden mit dem Programm Turboplot, das einen
Unterpunkt zum Newtonverfahren besitzt, getestet. Siehe auch unter www.turboplot.de
Für die tabellarische Darstellung der Ergebnisse bietet sich die Nutzung von Matrizen als
Speichermedium an, da hier sowohl eine tabellarische Ausgabe als auch eine Wiederver-
wendung der Daten möglich ist.
Grundkenntnisse über Matrizen sind insofern vorteilhaft, jedoch nicht notwendig, da keinerlei
Rechnungen mit den Matrizen verbunden sind. Ist der Begriff der Matrix nicht geläufig, kann
man Matrizen als die Realisation von Tabellen in MuPAD ansehen. Aus diesem Grund beginnt
das Notebook zunächst mit einer Kurzeinführung in den Umgang mit Matrizen, soweit wie dies
für die Zwecke des Notebooks sinnvoll ist wird . Wenn man sich nur für die Ergebnisse des
Algorithmus interessiert, kann diese Kurzeinführung übersprungen werden.
In diesem Notebook sind Links und Verweise auf andere Seiten im Internet angegeben.
Hiermit distanziere ich mich ausdrücklich von den Inhalten der angegebenen Seiten
und sämtlicher mit diesen Seiten verlinkten Quellen im Internet.
Benötigte Grundlagen zu Matrizen
Eine Matrix ist ein rechteckiges Schema aus Zeilen und Spalten. In MuPAD wird eine
Matrix aus zwei Spalten und drei Zeilen wie folgt definiert:
A:=matrix(2,3)
Die Elemente der Matrix sind zunächst mit Nullen vorinitalisiert und können wie folgt
überschrieben werden:
A:=matrix([[1,2,3],[4,5,6]])
Natürlich kann die Matrix A auch direkt wie vorstehend definiert werden. Für die Zwecke
dieses Notebook ist es erforderlich, Elemente einzeln ein- und auszulesen. Im folgenden
wird das zweite Element der ersten Zeile und zweiten Spalte ausgelesen:
A[1,2]
Analog lassen sich das Elemente überschreiben. Der Doppelpunkt verhindert die Ausgabe.
A[1,2]:=neu:
A[2,3]:=alt:
Nun wird die überschriebene Matrix ausgegeben. Offensichtlich ist auch Text darstellbar.
A
Teilmatrizen können wie folgt ausgelesen werden. Im konkreten Fall werden die ersten zwei
Zeilen und die zweite und dritte Spalte ausgelesen.
A[1..2,2..3]
Der benutzte Algorithmus
Dem Newtonschen Verfahren und damit der Prozedur Newton liegt folgende Formel
zugrunde:
Definition von Konstanten für die Programmsteuerung
Nach diesen einleitenden Bemerkungen werden im folgenden einige Konstanten für den
weiteren Gebrauch initialisiert.
- Wenn der Betrag von (Xn-1 - Xn) kleiner als die Genauigkeit ist, wird die weitere Rechnung
abgebrochen. Dieser Wert kann als Parameter an die Prozedur übergeben werden.
- Der Befehl DIGITS gibt die Anzahl der relevanten von 0 verschiedenen Nachkommastellen
an.
- Die Variable Startwert ist der Startwert des Newtonverfahrens in der Prozedur Newton
und kann als Parameter an die Prozedur übergeben werden.
- Die Variablen Oben, Unten, Links und Rechts geben die Größe des Koordinatensystems an,
das in der Prozedur GraphNewton erzeugt wird.
Genauigkeit := 1/1000:
DIGITS := 4:
Startwert := 8:
Links := -10:
Rechts := 10:
Oben := 20:
Unten := -20:
Definition der Prozeduren
Die Prozedur Newton wird definiert. In dieser Prozedur werden bzw. wird:
- die Berechnungen iterativ durchgeführt
- die Daten in die Ausgabematrix geschrieben
- die Ausgabematrix ausgelesen.
- Die Ausgabematrix nimmt die berechneten Daten auf. Da die Anzahl der Iterationen
anfangs nicht bekannt ist, ist eine dynamische Anpassung der Zeilenzahl der Ausgabematrix
nicht möglich. Die Ausgabematrix wird mit n_max Zeilen erzeugt und mit Nullen
vorinitialisiert. Während der Iterationen werden die benötigten Zeilen überschrieben.
Die Berechnungen werden abgebrochen, wenn entweder die Differenz der des Betrages
von (Xn+1 - Xn) kleiner als die Genauigkeit ist oder andererseits die Anzahl der
Iterationen n_max -1 übersteigt.
Newton := proc( f, Startwert, Genauigkeit)
save F, Xn, n;
local k, n_max, Ausgabematrix, Anz_Zeilen, x1;
begin
delete F, Xn, n;
x1:=Startwert:
n_max := 15: // maximale Zeilenzahl
k := 2: // Laufvariable initialisiert
if f(x1) = 0 then
print(Unquoted,"Die Nullstelle ist gefunden und lautet:");
print(Unquoted, "x1 = ".expr2text(float(x1)));
return():
else
Ausgabematrix:=matrix(n_max,6); //Die Kopfzeile der Matrix wird
Ausgabematrix[1,1]:=n: //definiert.
Ausgabematrix[1,2]:=Xn:
Ausgabematrix[1,3]:=F(Xn):
Ausgabematrix[1,4]:=F'(Xn):
Ausgabematrix[1,5]:=F(Xn)/F'(Xn):
Ausgabematrix[1,6]:=Xn+1:
Ausgabematrix[2,1]:=1: // Die zweite Zeile mit den Startwerten
Ausgabematrix[2,2]:=float(x1): // wird beschrieben.
Ausgabematrix[2,3]:=float(f(x1)):
Ausgabematrix[2,4]:=float(f'(x1)):
if Ausgabematrix[2,4] = 0
then
print(Unquoted,"Die Ableitung hat eine Nullstelle");
print(Unquoted,
"Eine Division durch Null ist mathematisch unmöglich");
print(Unquoted,"Versuchen Sie es mit einem neuen Startwert");
return();
else
Ausgabematrix[2,5]:=float(f(x1)/f'(x1)):
end_if;
Ausgabematrix[2,6]:=float(x1-Ausgabematrix[2,5]):
k:=2:
Anz_Zeilen:=2:
for k from 2 to n_max-1 do
if abs(Ausgabematrix[k,2]-Ausgabematrix[k,6])>Genauigkeit
then
Ausgabematrix[k+1,1]:=k:
Ausgabematrix[k+1,2]:=float(Ausgabematrix[k,6]):
Ausgabematrix[k+1,3]:=float(f(Ausgabematrix[k+1,2])):
Ausgabematrix[k+1,4]:=float(f'(Ausgabematrix[k+1,2])):
if Ausgabematrix[k+1,4] = 0
then
print(Unquoted,"Die Ableitung hat eine Nullstelle");
print(Unquoted,
"Eine Division durch Null ist mathematisch unmöglich");
print(Unquoted,"Versuchen Sie es mit einem neuen Startwert");
return();
else
Ausgabematrix[k+1,5]:=
float(f(Ausgabematrix[k+1,2])/f'(Ausgabematrix[k+1,2])):
end_if;
Ausgabematrix[k+1,6]:=
float((Ausgabematrix[k+1,2]-Ausgabematrix[k+1,5])):
Anz_Zeilen:=Anz_Zeilen+1:
// Die Zeilen werden iterativ beschrieben.
// Abbruchkriterien: Die Genauigkeit ist erreicht
else
k:=n_max-1:
// Die maximale Zeilenzahl ist erreicht.
end_if;
end_for;
Anz_Zeilen;
if Anz_Zeilen = n_max //Ausgabe der Daten
then
print(Unquoted,
"Eine existierende Nullstelle kann nicht gefunden werden");
print(Unquoted,"oder eine Nullstelle existiert nicht") ;
else
print(Unquoted, "Die Nullstelle ist bei x1 = ".
expr2text(float(Ausgabematrix[Anz_Zeilen,2])));
print(Unquoted, "Die maximale Abweichung beträgt ".
expr2text(float(Genauigkeit)));
print(Unquoted,
"Die Ergebnisse der Einzelschritte werden nun ausgegeben");
end_if;
Ausgabematrix[1..Anz_Zeilen,1..6];
end_if:
end_proc:
Die Prozedur GraphNewton wird definiert. In dieser Prozedur werden Ergebnisse der Berechnungen
der Prozedur Newton graphisch ausgewertet. Die Funktion GraphNewton greift dabei auf die
Ergebnisse der Ausgabematrix zurück, die in der Prozedur Newton erzeugt wurde.
Der Aufruf der Funktion GraphNewton hat somit immer nach dem Aufruf der Prozedur Newton
zu geschehen. Die Entkopplung der Prozeduren ermöglicht einen Aufruf der Prozeduren
nach Wahl mit durch den Benutzer bestimmter Wahl des Koordinatensystems.
GraphNewton := proc(f, Links,Rechts,Unten,Oben,Ausgabematrix)
save x;
local Anz_Zeilen, fgraph, i, links, m, normgraph, rechts, tangente, tangraph;
begin
delete x;
Anz_Zeilen:= linalg::nrows(Ausgabematrix);
normgraph[1]:=plot::Line2d([Ausgabematrix[2,2],f(Ausgabematrix[2,2])]
,[Ausgabematrix[2,2], 0], Color=RGB::Green):
for m from 2 to Anz_Zeilen-1 do
links:=min(Ausgabematrix[m,2],Ausgabematrix[m+1,2]):
rechts:=max(Ausgabematrix[m,2],Ausgabematrix[m+1,2]):
tangente[m]:=
f'(Ausgabematrix[m,2])*x-f'(Ausgabematrix[m,2])*Ausgabematrix[m+1,2];
tangraph[m]:=plot::Function2d(tangente[m], x=links..rechts,
ViewingBoxYRange=Unten..Oben,
Color=RGB::Red):
normgraph[m]:=
plot::Line2d([Ausgabematrix[m+1,2],f(Ausgabematrix[m+1,2])]
,[Ausgabematrix[m+1,2], 0], Color=RGB::Green):
end_for;
fgraph:=plot::Function2d(f, x=Links..Rechts,
ViewingBoxYRange=Unten..Oben,
Color=RGB::Blue):
plot(tangraph[i] $ i = 2..Anz_Zeilen-1,
fgraph,
normgraph[i] $ i = 1..Anz_Zeilen-1)
end_proc:
Anwendung der Prozeduren auf konkrete Probleme
Zu einem ersten Test der Prozedur wird eine zu untersuchende Funktion definiert.
f := x -> x^2-4:
Die Nullstellen lassen sich leicht ermitteln.
solve(f(x)=0,x)
Die Prozedur wird mit mit den vordefinierten Konstanten als Parameter aufgerufen.
tabelle:= Newton(f,4,Genauigkeit)
Die Nullstelle ist bei x1 = 2.001
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
Offensichtlich wurde eine Nullstelle mit der angegebenen Genauigkeit erkannt.
GraphNewton(f,-1,5,-6,13,tabelle)
Es ist aber auch möglich, Zahlen statt der Konstanten einzugeben.
Newton(f,2,1/10)
Die Nullstelle ist gefunden und lautet:
x1 = 2.0
Nachdem die grundsätzliche Funktionalität der Programme Newton und GraphNewton geklärt
ist, kann mit der mathematischen Analyse des Newtonverfahrens begonnen werden.
Eine erste interessante Frage ist, wie der Algorithmus reagiert, wenn eine Funktion
mehrere Nullstellen hat. Betrachten wir die Funktion
f := x ->x^3-9*x
Die Nullstellen lassen sich konventionell berechnen:
solve(f(x),x)
Es wird mit dem Startwert 8 begonnen:
tabelle:= Newton(f,2.2,Genauigkeit)
Die Nullstelle ist bei x1 = 3.0
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
GraphNewton(f,-1,5,-15,23,tabelle)
Nun der Versuch mit dem Startwert 3.
tabelle:= Newton(f,4,Genauigkeit)
Die Nullstelle ist bei x1 = 3.001
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
GraphNewton(f,-1,5,-15,20,tabelle)
Das gleiche mit Startwert 1
tabelle:= Newton(f,1,Genauigkeit)
Die Nullstelle ist bei x1 = -1.387e-7
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
Und nun noch Startwert -7
Newton(f,-7,Genauigkeit)
Die Nullstelle ist bei x1 = -3.0
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
Offensichtlich liefert der Algorithmus je nach Startwert unterschiedliche Nullstellen.
Im konkreten Fall wurden alle drei Nullstellen mit der angegebenen Genauigkeit
gefunden. Dabei variiert die Anzahl der Iterationen in Abhängigkeit vom Startwert.
Im konkreten Fall weiß man, dass eine ganzrationale Funktion dritten Grades maximal
drei Nullstellen hat. Insofern hat man nun alle Nullstellen gefunden. Der Newtonsche
Algorithmus macht aber keine Aussage über die Anzahl der Nullstellen. Letzlich ist so
auch kein Nachweis möglich, dass es keine Nullstellen gibt, wenn das Verfahren
nicht konvergiert.
Eine interessante Frage ist: Wie reagiert der Algorithmus, wenn die Funktion keine
Nullstellen hat.
f:= x -> x^2+3:
Diese Funktion hat bekanntlich keine reellen Nullstellen.
solve(f(x),x)
Das zunächst unerwartete Ergebnis : Es scheint zwei Nullstellen zu geben.
Andererseits sind die Nullstellen imaginär. Die reelle Lösung zeigt keine Nullstellen, was
man auch mit MuPAD nachweisen kann, wenn man den Definitionsbereich entsprechend
einschränkt.
solve(f(x), x, Domain = Dom::Real)
Nun Beginn der Iterationen mit Startwert 8.
tabelle:= Newton(f,Startwert,Genauigkeit)
Eine existierende Nullstelle kann nicht gefunden werden
oder eine Nullstelle existiert nicht
GraphNewton(f,-5,8,-5,70,tabelle)
Offensichtlich konvergiert der Algorithmus nicht. Dies korrelliert mit der nicht vorhandenen
Nullstelle.
Eine Besonderheit tritt auf, wenn man als Startwert 1 wählt.
tabelle:= Newton(f,1,Genauigkeit)
Eine existierende Nullstelle kann nicht gefunden werden
oder eine Nullstelle existiert nicht
GraphNewton(f,-2,2,-1,5,tabelle)
Die Argumente oszillieren zwischen den Werten -1 und 1.
Nun soll eine gebrochenrationale Funktion untersucht werden.
f:=x -> (x^3-4*x-7.5)/(x^2-3)
tabelle:= Newton(f,1,Genauigkeit)
Die Nullstelle ist bei x1 = 2.62
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
GraphNewton(f,-10,10,-10,10,tabelle)
Nun ein anderer Startwert:
tabelle:= Newton(f,19,Genauigkeit)
Eine existierende Nullstelle kann nicht gefunden werden
oder eine Nullstelle existiert nicht
GraphNewton(f,-10,10,-10,10,tabelle)
Offensichtlich kommt man bei den gewählten Voreinstellungen zu keiner Lösung.
In solchen Fällen bietet es sich an, für einen ersten Eindruck den Graphen der Funktion
darzustellen. Wenn im Graph eine Nullstelle erkennbar ist, sollte man entweder einen
anderen Startwert wählen oder in diesem Notebook die maximale Anzahl von Iterationen
heraufzusetzen. Schließlich ist es auch möglich, sich nur auf den Zähler zu beziehen
und die Nullstellen des Zählers mit dem Newtonverfahren zu bestimmen. Auf diese
Untersuchungen wird in diesem Notebook verzichtet.
Bei der folgenden Funktion ist eine Lösung in geschlossener Form nicht mehr möglich.
f:=x -> 7-2^x-3^x
Der Befehl solve liefert kein sinnvolles Ergebnis.
solve(f(x)=0,x)
Unterstützung erhält man durch den Befehl float. Wenn es nur um das Ergebnis geht,
reicht dieser Befehl zur Erlangung des Ergebnisses natürlich aus.
float(solve(f(x)=0,x))
Nun wird das Newtonverfahren mit Startwert -1 durchgeführt.
tabelle:= Newton(f,-1,Genauigkeit)
Die Nullstelle ist bei x1 = 1.357
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
GraphNewton(f,-4,8,-500,10,tabelle)
Die bereits bekannte Nullstelle wird erkannt.
Newton(f,1,Genauigkeit)
Die Nullstelle ist bei x1 = 1.357
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
Nun noch der natürliche Logarithmus
f:=x -> ln(x):
Newton(f,2,Genauigkeit)
Die Nullstelle ist bei x1 = 1.0
Die maximale Abweichung beträgt 0.001
Die Ergebnisse der Einzelschritte werden nun ausgegeben
Diese Nullstelle ist als Eigenschaft der Logarithmusfunktion bekannt.
Nun ein eigentlich einfaches Beispiel:
f:=x -> x^2-6*x:
Newton(f,3,Genauigkeit)
Die Ableitung hat eine Nullstelle
Eine Division durch Null ist mathematisch unmöglich
Versuchen Sie es mit einem neuen Startwert
Diese in der Prozedur Newton implementierte Fehlermeldung ist zu interpretieren.
Eine Betrachtung der Nullstellen der Ableitung weist die Behauptung der Nullstelle der
Ableitung nach.
solve(f'(x)=0,x)
Die Ableitung hat eine Nullstelle beim Startwert. Verallgemeinert: Startwerte mit waagerechter
Tangente sind nicht möglich. Nicht erlaubt sind somit:
- Extremstellen
- Sattelpunkte
Andererseits ist es auch theoretisch möglich, dass während der Iterationen zufällig eine
Nullstelle der Ableitung getroffen wird. Auch in diesem Fall bricht die Prozedur Newton
ab. Entfernt man die entsprechenden Überprüfung aus der Prozedur, wird von MuPAD
mit einer Fehlermeldung abgebrochen. Allerdings werden dann nachfolgende Befehle
bei einer Evaluation der Befehle nicht weiter beachtet.
Einige Anregungen zur selbstständigen Weiterarbeit:
1. Teil: Verbesserungen der Prozeduren:
a) Man kann bei der Prozedur GraphNewton eine dynamische Anpassung des Zeichenbereichs an
die konkret vorliegenden Werte vornehmen. Welche Nachteile hat dies Verfahren?
b) In diesem Notebook wird als Genauigkeit die der Betrag von Xn+1-Xn angenommen.
Dieser Genauigkeitsbegriff ist unvorteilhaft bei sehr großen Steigungen nahe der Nullstelle.
Es ist aber auch möglich, als Genauigkeit den Abstand von der x-Achse zu wählen.
Siehe dazu auch das Notebook von Alessandro Dell'Aere. Dieser Genauigkeitsbegriff
ist nachteilig, wenn man sehr flache Graphen im Bereich der Nullstelle hat. Optimal wäre
ein Genauigkeitsbegriff, der beide Genauigkeitsbegriffe geeignet miteinander verbindet.
Hier sind verschiedene Formen der Realisierung möglich. Man sollte einen erweiterten
Genauigkeitsbegriff definieren und implementieren.
2. Teil: Experimente mit dem Newtonverfahren
a) Experimentieren Sie bei selbstgewählten Funktionen mit verschiedenen Startwerten.
b) Man sollte versuchen, oszillierendes Verhalten in anderen Fällen zu realisieren. Welche
mathematischen Bedingungen liegen bei Ihrem Beispiel vor?
c) Können Sie auch ein Beispiel finden, bei dem die Oszillationen Perioden von mehr
als zwei Schritten haben?
d) Können Sie ein Beispiel finden, bei dem die Funktion Nullstellen hat, obwohl der
Algorithmus nicht konvergiert? Wenn Sie kein Beispiel finden: In welcher Situation
könnte dies passieren?
e) Wie geht man bei einer gebrochenrationalen Funktion vor, wenn der Startwert auf einer
Definitionslücke liegt und man trotzdem den Startwert beibehalten möchte?
f) Welche Möglichkeiten, das Newtonverfahren einzusetzen hat man, wenn die Funktion
das Produkt einer ganzrationalen Funktion mit einer e-Funktion ist? Geben Sie ein
Beispiel an.
g) Welche Möglichkeiten, das Newtonverfahren einzusetzen hat man, wenn die Funktion
das Produkt einer gebrochenrationalen Funktion mit einer e-Funktion ist? Erläutern Sie
anhand eines Beispiels.
h) Wenn man bei der Funktion f:=x -> 7-2^x-3^x Startwerte wählt, die weit links liegen,
erhält man eine relativ große Anzahl von Iterationen. Probieren Sie dies aus und
begründen Sie anschaulich.
j) Sie sollten überprüfen, inwieweit bei Funktionen mit eingeschränktem Definitionsbereich
(z.B. Logarithmusfunktion, Wurzelfunktion) die Einschränkungen erkannt werden.
k) Wenn man beim natürlichen Logarithmus den Startwert 20 wählt, ergibt sich ein
"merkwürdiges Ergebnis". Erklären Sie, was das Ergebnis bedeutet und wie es
zustandekommt.
________________________________________________________________________________
Anmerkungen:
1. Weitere Anregungen finden Sie in der Unterrichsmaterialsammlung unter schule.mupad.de. In diesen
Notebooks werden eine Vielzahl unterschiedlichster mathematischer Probleme mit MuPAD Pro gelöst.
2. Die Handreichung Mathematik 1 x anders, Band 11 von Patricia Rudawski, kostenfrei erhälicht als PDF
Dokument unter schule.mupad.de, ist ebenfalls dem Newton-Verfahren gewidmet.
3. In der Materialsammlung des MuPAD Servers finden sich bislang zwei andere Notebooks zum
Newtonverfahren, die den Schwerpunkt auf die Einführung bzw. Visualisierung des Newtonverfahrens
legenund die Ergebnisse der Rechnungen anders präsentieren.
_______________________________________________________________________________