@c -----------------------------------------------------------------------------
@c File     : mnewton.de.texi
@c License  : GNU General Public License (GPL)
@c Language : German
@c Original : mnewton.texi revision 31.05.2011
@c Date     : 08.11.2010
@c Revision : 16.09.2011
@c 
@c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
@c -----------------------------------------------------------------------------

@menu
* Einf@"uhrung in mnewton::
* Funktionen und Variablen f@"ur mnewton::
@end menu

@c -----------------------------------------------------------------------------
@node Einf@"uhrung in mnewton, Funktionen und Variablen f@"ur mnewton, mnewton, mnewton
@section Einf@"uhrung in mnewton
@c -----------------------------------------------------------------------------

@c @code{mnewton} is an implementation of Newton's method for solving nonlinear
@c equations in one or more variables.

Das Paket mnewton implementiert das Newton-Verfahren mit der Funktion
@mref{mnewton} f@"ur das numerische L@"osen nichtlinear Gleichungen in einer
oder mehrerer Variablen.  Die Funktion @mref{newton} ist eine weitere
Implementierung, die im Paket newton1 enthalten ist.

@c -----------------------------------------------------------------------------
@node Funktionen und Variablen f@"ur mnewton,  , Einf@"uhrung in mnewton, mnewton
@section Funktionen und Variablen f@"ur mnewton
@c -----------------------------------------------------------------------------

@c --- 15.09.2011 DK -----------------------------------------------------------
@anchor{newtonepsilon}
@defvr {Optionsvariable} newtonepsilon
Standardwert: @code{1.0e-8}

@c Precision to determine when the @code{mnewton} function has converged
@c towards the solution. See also @code{mnewton}.

Genauigkeit mit der getestet wird, wie gut die Funktion @mref{mnewton} sich der
L@"osung angen@"ahert hat.  Unterschreitet die @"Anderung der Approximation
den Wert @code{newtonepsilon}, bricht der Algorithmus ab und gibt das Ergebnis
zur@"uck.
@end defvr

@c --- 15.09.2011 DK -----------------------------------------------------------
@anchor{newtonmaxiter}
@defvr {Optionsvariable} newtonmaxiter
Standardwert: @code{50}

@c Maximum number of iterations to stop the @code{mnewton} function if it does
@c not converge or if it converges too slowly. See also @code{mnewton}.

Obere Grenze f@"ur die Anzahl an Iterationen, falls die Funktion
@mref{mnewton} nicht oder sehr langsam konvergiert.
@end defvr

@c --- 15.09.2011 DK -----------------------------------------------------------
@anchor{function_mnewton}
@deffn {Funktion} mnewton (@var{FuncList}, @var{VarList}, @var{GuessList})

@c Multiple nonlinear functions solution using the Newton method. @var{FuncList}
@c is the list of functions to solve, @var{VarList} is the list of variable
@c names, and @var{GuessList} is the list of initial approximations.

Implementation des Newton-Verfahrens f@"ur das numerische L@"osen von
Gleichungen in mehreren Variablen.  Das Argument @var{FuncList} ist die Liste
der Gleichungen, f@"ur die eine numerische L@"osung gesucht wird.  Das Argument
@var{VarList} ist eine Liste der Variablen und das Argument @var{GuessList}
ist eine Liste mit den Startwerten des Newton-Verfahrens.

@c The solution is returned in the same format that @code{solve()} returns.
@c If the solution isn't found, @code{[]} is returned.

Die L@"osungen werden als eine Liste zur@"uckgegeben.  Kann keine L@"osung
gefunden werden, ist die R@"uckgabe eine leere Liste @code{[]}.

@c This function is controlled by global variables @code{newtonepsilon} and
@c @code{newtonmaxiter}.

@code{mnewton} wird von den Funktionen @mref{newtonepsilon} und
@mref{newtonmaxiter} kontrolliert.

@c To use this function write first @code{load("mnewton")}. See also 
@c @code{newtonepsilon} and @code{newtonmaxiter}.

Die Funktion wird mit dem Kommando @code{load("mnewton")} geladen.  Siehe die
Funktion @mref{newton} f@"ur eine alternative Implementierung des
Newton-Verfahrens.

Beispiele:

@example
(%i1) load("mnewton")$

(%i2) mnewton([x1+3*log(x1)-x2^2, 2*x1^2-x1*x2-5*x1+1],
              [x1, x2], [5, 5]);
(%o2) [[x1 = 3.756834008012769, x2 = 2.779849592817897]]
(%i3) mnewton([2*a^a-5],[a],[1]);
(%o3)             [[a = 1.70927556786144]]
(%i4) mnewton([2*3^u-v/u-5, u+2^v-4], [u, v], [2, 2]);
(%o4) [[u = 1.066618389595407, v = 1.552564766841786]]
@end example

@c The variable @code{newtonepsilon} controls the precision of the
@c approximations.  It also controls if computations are performed with
@c floats or bigfloats.

Die Optionsvariable @mref{newtonepsilon} kontrolliert die Genauigkeit der
Approximation.  Weiterhin kontrolliert die Optionsvariable, ob die Berechnung
mit Gleitkommazahlen in doppelter oder gro@ss{}er Genauigkeit durchgef@"uhrt
wird.

@example
(%i1) load("mnewton")$

(%i2) (fpprec : 25, newtonepsilon : bfloat(10^(-fpprec+5)))$

(%i3) mnewton([2*3^u-v/u-5, u+2^v-4], [u, v], [2, 2]);
(%o3) [[u = 1.066618389595406772591173b0, 
                               v = 1.552564766841786450100418b0]]
@end example
@end deffn

@c --- 16.09.2011 DK -----------------------------------------------------------
@anchor{newton}
@deffn {Funktion} newton (@var{expr}, @var{x}, @var{x_0}, @var{eps})

@c Returns an approximate solution of @code{@var{expr} = 0} by Newton's method,
@c considering @var{expr} to be a function of one variable, @var{x}.
@c The search begins with @code{@var{x} = @var{x_0}}
@c and proceeds until @code{abs(@var{expr}) < @var{eps}}
@c (with @var{expr} evaluated at the current value of @var{x}).

Die Funktion @code{newton} gibt eine N@"aherungsl@"osung der Gleichung
@code{@var{expr} = 0} zur@"uck, die mit dem Newton-Verfahren berechnet wird.
Der Ausdruck @var{expr} ist eine Funktion einer Variablen @var{x}.  Der
Anfangswert ist @code{ @var{x} = @var{x_0}}.  Der Algorithmus bricht ab, wenn
@code{abs(@var{expr}) < @var{eps}}, wobei der Ausdruck @var{expr} f@"ur den
aktuellen N@"aherungswert @var{x} ausgewertet wird.

@c @code{newton} allows undefined variables to appear in @var{expr},
@c so long as the termination test @code{abs(@var{expr}) < @var{eps}} evaluates
@c to @code{true} or @code{false}.
@c Thus it is not necessary that @var{expr} evaluate to a number.

@code{newton} erlaubt symbolische Variablen im Ausdruck @var{expr}, wenn der
Ausdruck @code{abs(@var{expr}) < @var{eps}} zu @code{true} oder @code{false}
ausgewertet werden kann.  Daher ist es nicht notwendig, dass der Ausdruck
@var{expr} zu einer Zahl ausgewertet werden kann.

@c @code{load("newton1")} loads this function.

Das Kommando @code{load("newton1")} l@"adt die Funktion.

@c See also @code{realroots}, @code{allroots}, @code{find_root}, and 
@c @code{mnewton}.

Siehe auch die Funktionen @mrefcomma{realroots} @mref{allroots} und
@mrefcomma{find_root} um numerische L@"osungen von Gleichungen zu finden.
Das Paket mnewton enth@"alt mit der Funktion @mref{mnewton} eine weitere
Implementation des Newton-Verfahrens.

Achtung: Auch mit @code{load("newton")} wird eine Funktion mit dem Namen
@code{newton} geladen, die sich jedoch in ihrer Syntax von der hier
beschriebenen Funktion unterscheidet und auch nicht dokumentiert ist.

Beispiele:

@example
(%i1) load ("newton1");
(%o1) /usr/share/maxima/5.10.0cvs/share/numeric/newton1.mac
(%i2) newton (cos (u), u, 1, 1/100);
(%o2)                   1.570675277161251
(%i3) ev (cos (u), u = %);
(%o3)                 1.2104963335033528E-4
(%i4) assume (a > 0);
(%o4)                        [a > 0]
(%i5) newton (x^2 - a^2, x, a/2, a^2/100);
(%o5)                  1.00030487804878 a
(%i6) ev (x^2 - a^2, x = %);
                                           2
(%o6)                6.098490481853958E-4 a
@end example
@end deffn

@c --- End of file mnewton.de.texi ---------------------------------------------

