Newton_Verfahren
2009-05-11 14:12:42

F3 is nicht zu beachten (aus aldeee prograaam)



--  FILE:    newton_verfahren.adb
--
--  PROJECT: Einfuehrung in die Informatik, Uebungsblatt5, Aufgabe 3c
--  VERSION: 1
--  DATE:    27.11.2008
--  AUTOR:   Gruppe 5
--
-------------------------------------------------------------------------------
--
--  PROCEDURE Newton_Verfahren
--

--
with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Float_Text_IO;
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;

procedure Newton_Verfahren is

   --  Die Funktiton f_1(x)
   function F1 (X : Float) return Float is
   begin
      return (((1.0/2.0)*(X**3.0))-((3.0/8.0)*(X**2.0))-(2.0*X)+(1.0));
   end F1;

   --  Die Ableitung der Funktiton f_1(x)
   function F1_Strich (X : Float) return Float is
   begin
      return ((3.0/2.0)*(x**2.0)-(6.0/8.0)*x-2.0);
   end F1_Strich;

   --  Die Funktiton f_2(x)
   function F2 (X : Float) return Float is
   begin
      return  ((x**3.0)-((x**2.0)/2.0)-(x+1.0));
   end F2;

   --  Die Ableitung der Funktiton f_2(x)
   function F2_Strich (X : Float) return Float is
   begin
      return  ((3.0*(x**2.0))-((2.0*x)/2.0)-1.0);
   end F2_Strich;

   --  Die Funktiton f_3(x)
   function F3 (X : Float) return Float is
   begin
      return ((x**(3)) - (2.0 * (x**(2))) - (2.0 * x) + (2.0) + (1.0 / x));
   end F3;

   --  Die Ableitung Funktiton f_3(x)
   function F3_Strich (X : Float) return Float is
   begin
      return ((3.0 * ((X)**(2))) - (4.0 * X) - (2.0) - ((X)**(-2)));
   end F3_Strich;

   --  Das Newton-Verfahren um Nullstellen zu berechen. Falls die Folge der
   --  errechneten Werte gegen einen Wert konvergiert, ist dies eine Nullstelle
   --  der Funktion.
   function Verfahren (Xn : Float; Fkt_X : Float; Fkt_Strich_X : Float)
     return Float is
   begin
      return ((Xn) - (Fkt_X / Fkt_Strich_X));
   end Verfahren;

   Eingabe : Positive;
   Xn, Xn_Plus_Eins : Float;
begin
   Ada.Text_IO.Put ("Bitte waehlen Sie eine Funktion aus: ");
   Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("1) ");
   Ada.Text_IO.New_Line;
   Ada.Text_IO.Put ("2) ");
   Ada.Text_IO.New_Line;
   Ada.Integer_Text_IO.Get (Eingabe);

   -- f_1(x)
   if Eingabe = 1 then
      Ada.Text_IO.Put ("Bitte geben Sie den Startwert ein: ");
      Ada.Float_Text_IO.Get (Xn);

      -- Erster Wert berechnen
      Xn_Plus_Eins := Verfahren (Xn, F1 (Xn), F1_Strich (Xn));

      --  Folgende Werte berechnen, bis die Folge konvergiert oder
      --  die Grenzen von Float erreicht werden.
      while Xn /= Xn_Plus_Eins
        and Xn_Plus_Eins < Float'Last
        and Xn_Plus_Eins > Float'First loop
         Ada.Float_Text_IO.Put (Xn, 2, 8, 0);
         Ada.Text_IO.Put (" : ");
         Ada.Float_Text_IO.Put (Xn_Plus_Eins, 2, 8, 0);
         Ada.Text_IO.New_Line;

         Xn := Xn_Plus_Eins;
         Xn_Plus_Eins := Verfahren (Xn, F1 (Xn), F1_Strich (Xn));

      end loop;

      --  Wenn die Loesung innerhalb der Grenzen von Float liegt,
      --  ist die Loesung richtig.
      if Xn_Plus_Eins < Float'Last and Xn_Plus_Eins > Float'First then
         Ada.Text_IO.Put (" Nullstelle bei: ");
         Ada.Float_Text_IO.Put (Xn_Plus_Eins, 2, 8, 0);
      else
         Ada.Text_IO.Put ("Berechnung der Nullstelle nicht Moeglich!");
         Ada.Text_IO.Put ("Bitte geben Sie einen anderen Startwert ein.");
      end if;

   -- f_2(x)
   elsif Eingabe = 2 then

      Ada.Text_IO.Put ("Bitte geben Sie den Startwert ein: ");
      Ada.Float_Text_IO.Get (Xn);

      -- Erster Wert berechnen
      Xn_Plus_Eins := Verfahren (Xn, F2 (Xn), F2_Strich (Xn));

      --  Folgende Werte berechnen, bis die Folge konvergiert oder
      --  die Grenzen von Float erreicht werden.
      while Xn /= Xn_Plus_Eins
       and Xn_Plus_Eins < Float'Last
       and Xn_Plus_Eins > Float'First loop
         Ada.Float_Text_IO.Put (Xn, 2, 8, 0);
         Ada.Text_IO.Put (" : ");
         Ada.Float_Text_IO.Put (Xn_Plus_Eins, 2, 8, 0);
         Ada.Text_IO.New_Line;


         Xn := Xn_Plus_Eins;
         Xn_Plus_Eins := Verfahren (Xn, F2 (Xn), F2_Strich (Xn));

      end loop;

      --  Wenn die Loesung innerhalb der Grenzen von Float liegt,
      --  ist die Loesung richtig.
      if Xn_Plus_Eins < Float'Last and Xn_Plus_Eins > Float'First then
         Ada.Text_IO.Put (" Nullstelle bei: ");
         Ada.Float_Text_IO.Put (Xn_Plus_Eins, 2, 8, 0);
      else
         Ada.Text_IO.Put ("Berechnung der Nullstelle nicht Moeglich!");
         Ada.Text_IO.Put ("Bitte geben Sie einen anderen Startwert ein.");
      end if;

   --f_3(x)
   elsif Eingabe = 3 then

      Ada.Text_IO.Put ("Bitte geben Sie den Startwert ein: ");
      Ada.Float_Text_IO.Get (Xn);

      -- Erster Wert berechnen
      Xn_Plus_Eins := Verfahren (Xn, F3 (Xn), F3_Strich (Xn));

      --  Folgende Werte berechnen, bis die Folge konvergiert oder
      --  die Grenzen von Float erreicht werden.
      while Xn /= Xn_Plus_Eins
        and Xn_Plus_Eins < Float'Last
        and Xn_Plus_Eins > Float'First loop
         Ada.Float_Text_IO.Put (Xn, 2, 8, 0);
         Ada.Text_IO.Put (" : ");
         Ada.Float_Text_IO.Put (Xn_Plus_Eins, 2, 8, 0);
         Ada.Text_IO.New_Line;

         Xn := Xn_Plus_Eins;
         Xn_Plus_Eins := Verfahren (Xn, F3 (Xn), F3_Strich (Xn));
      end loop;

      --  Wenn die Loesung innerhalb der Grenzen von Float liegt,
      --  ist die Loesung richtig.
      if Xn_Plus_Eins < Float'Last and Xn_Plus_Eins > Float'First then
         Ada.Text_IO.Put (" Nullstelle bei: ");
         Ada.Float_Text_IO.Put (Xn_Plus_Eins, 2, 8, 0);
      else
         Ada.Text_IO.Put ("Berechnung der Nullstelle nicht Moeglich!");
         Ada.Text_IO.Put ("Bitte geben Sie einen anderen Startwert ein.");
      end if;

   else
      Ada.Text_IO.Put ("Fehlerhafte Eingabe!");
   end if;
end Newton_Verfahren;