function []=startnewton(fktname,x0,gradname,hessname,nlines);
% ======================================================================
% Newton-Verfahren.
%
% Erstellt fuer die Veranstaltung
% Weiterbildenes Studium fuer Ingenieure WS 98/99
%
% S.F.
% ----------------------------------------------------------------------
% Aufrufparameter:
%  
% fktname : Name der Funktion F, deren Minimum bestimmt 
%   werden soll. An <fktname> wird ein Spaltenvektor(!) uebergeben. 
%   F ist eine Funktion von R^n -> R. Standard : 'testfunktion'
% x0 : Spaltenvektor der Dimension n. Standard: [1; 0.01]
% gradname : Name der Gradientenfunktion zu fktname.
% hessname : Name der Hesse-Matrix zu fktname.
% nlines : Anzahl der zu zeichnenden Hoehenlinien. Standard: 40
%
%% Initialisierung 
% xmin haelt fuer jede Dimension die kleinste waehrend der Iteration
%      auftretende Zahl fest.
% xmax haelt fuer jede Dimension die groesste waehrend der Iteration
%      auftretende Zahl fest.
% xmin und xmax werden benoetigt um den richtigen Bildschirmausschnitt
% bei der Darstellung des Iterationsverlaufes anzuzeigen.
global xmin
global xmax

% Anzahl der Funktionsauswertungen
global nfc 
nfc = 0;

% Anzahl der Hoehenlinien
if nargin < 5, nlines = 40; end;

iterationmax = 30;

% Name der Hessematrix zu fktname
if nargin < 4, hessname = 'hessetestfunktion'; end;

% Name der Gradientenfunktion zu fktname
if nargin < 3, gradname = 'gradienttestfunktion'; end;

% Startvektor
if nargin < 2, x0 = [1; 0.01]; end
n = size(x0,1);

% Name der zu minimierenden Funktion
if nargin < 1, fktname = 'testfunktion'; end

%------------------------------------------------------------------
%	Testen der Ableitungen:
testgrad(fktname,x0,gradname);
testhess(gradname,x0,hessname);

%-------------------------------------------------------------------

% Name der Ausgaberoutine
outputname = '';

  % Konstanten
  xpoints = 21;   % Anzahl der Gitterpunkte in x Richtung fuer contour-plot
  ypoints = 21;   % Anzahl der Gitterpunkte in y Richtung fuer contour-plot

% Im Fall n==2 kann eine graphische Ausgabe erfolgen. Dafuer sind einige
% Vorarbeiten noetig, die fuer die eigentliche Minimierung keine Rolle
% spielen. Der gesamte 'if'-Block dient ausschliesslich diesen Vorbereitungen.
if n==2 
   % Fuer xmin (xmax) werden die groesstmoeglichen (kleinstmoeglichen) Zahlen
   % vorgegeben. Dient nur dazu einen Vektor in entsprechender
   % Groesse bereitzustellen.
   xmin = ones(n,1)*realmax;
   xmax = -ones(n,1)*realmax;

   outputname = 'minmax';
   % Der erste Durchlauf ist nur zur Bestimmung von xmin und xmax gedacht.
   [lsg,wert,iterationen,nfc,ngc] = ...
     newton(fktname,x0,gradname,hessname,iterationmax,outputname);
  
   if sum(isnan(lsg))>0, lsg; return; end;
   if iterationen == 0, return; end;
   nfc = 0; ngc = 0;
   
   % Beobachtungsfenster festlegen, um 10% groesser als ermittelte Werte.
   xlaenge = (xmax-xmin)/2; xmitte = (xmax+xmin)/2;
   xmin = xmitte -(xlaenge* 1.1);
   xmax = xmitte + (xlaenge*1.1);

   % Einheitliches Koordinatensystem und Graphikausgabe in ein Fenster
   clf;
   axis([xmin(1), xmax(1), xmin(2), xmax(2)]);
   hold on
      
   %% Hoehenlinien einzeichnen
   % Gitter erzeugen; zu den Knoten wird der Funktionswert ermittelt.
   xrange = xmin(1):(xmax(1)-xmin(1))/(xpoints-1):xmax(1);
   yrange = xmin(2):(xmax(2)-xmin(2))/(ypoints-1):xmax(2);
   [xgitter,ygitter] = meshgrid(xrange,yrange);
   for i=1:xpoints
      [zgitter(i,1:ypoints)] = ...
	  feval(fktname,[xrange(i)*ones(1,ypoints);yrange(1:ypoints)]);     
   end 
   nfc = 0;
   
   % Erzeugung der Hoehenlinien
   contour(xgitter,ygitter,zgitter',nlines);
   
   % Erlaeuterungen in die Zeichnung einfuegen
   title('Newton-Verfahren');
   % nur wenn ein Minimum gefunden wurde, wird es eingezeichnet
   if iterationen < iterationmax 
      plot(lsg(1),lsg(2),'g*');	% Minimum einzeichnen
      legend('berechnetes Minimum');
   end
   
   outputname = 'zeichnung'; % Name der Ausgaberoutine

   % fuer die Zeichenroutine
   global letzterx; letzterx = x0;

end 	% 	Ende der Vorbereitungen für Ausdruck.

% Der Durchlauf, bei dem in jedem Iterationsschritt eine Ausgabe
% erfolgen kann.
[lsg,wert,iterationen,nfc,ngc] = ...
     newton(fktname,x0,gradname,hessname,iterationmax,outputname);

if n==2, 
  if iterationen < iterationmax 
      plot(lsg(1),lsg(2),'g*');	% Minimum nochmal einzeichnen
    end
hold off; end;


% Ergebnisse anzeigen
disp('Loesungsvektor')
disp(lsg)
disp('Der Funktionswert im Minimum betraegt')
disp(wert)
disp(sprintf('\nAnzahl der Iterationen: %d',iterationen ))
disp(sprintf('%s\n%s %d %s', 'Fuer einen Durchlauf des Newton-Verfahrens',' wurden',nfc,'Funktionsauswertungen benoetigt.'))
if iterationen>=iterationmax
   disp('ACHTUNG!!! Maximale Anzahl der Iterationen erreicht!')
end




