HILFE!! Pi-Berechnung - "unendliche reihe"

[LilKriztina]

Sooo.....also, ich bin in der 10ten KLasse eines Gymnasiums und hab einen großen Fehler gemacht, nämlich Infomatik gewählt, naja, da muss ich jetzt wohl noch nen halbes Jahr durch.
Aber ich brauch jetzt eure Hilfe, und ich hoffe die bekomm ich auch!!!!!!!

Wir müssen ein Programm schreiben, welches "pi" berechnet (gerundet, so ca. auf 15. Stellen) und zwar mit der Methode, die unser Lehrer "unendliche Reihe" benannt hat, ob die wirklich so heißt bezweifle ich einfach mal...
also, die geht nach diesem system:

pi/4= 1
pi = 1*4
Ergebnis: 4
schlechter wert...dann geht es weiter

pi/4= 1 - 1/3 | T
pi/4 = 2/3 |*4
pi = 2/3*4 | T
Ergebnis= 2,6
auch kein Guter wert aus diesem grund gehts immmmmeeeer weeeeiter:

pi/4= 1- 1/3 + 1/5 ; am ende wird sowas gerechnet wie pi/4= 1-1/3+1/5-1/7+1/9-1/11 (etc.)
und die ergebnisse nähern sich immer mehr dem richtigen wert "pi"

Das Prinzip lautet, dass sich Plus und Minus abwechseln, und dass zu dem Nenner immer 2 dazu gezählt werden...(nenner:=nenner +2; und die eine teilrechnung sollen wir mal (-1) nehmen (damit es negativ wird und das vorherige, falls negativ, wieder positiv, aber wie soll ich das inner for do schleife ausdrücken *ich-hab-doch-keine-ahnung* :wiejetzt: )

Im Formblatt sollen die Anzahl der Summanden angegeben und die Näherung für pi ausgegeben.
Ich habe keine Ahnung :gruebel: (man kann es nicht oft genug sagen), ich hab was gefunden mit Boolean, aber das dürfen wir nicht verwenden!!!! :cry:
Ich glaube zwar nicht,dass ich das hier einigermaßen erklären konnte, aber vielleicht kennt dieses programm ja einer und kann mir ein kleeeeeeeeeines bisschen helfen!!!!!!!!!!!!!!!!!! Danke!!!!

[Christian S.]

Hallo!

Also vorweg: das ist wirklich eine unendliche Reihe.

Du musst folgendes machen: Du baust Dir eine while-Schleife zusammen, die solange läuft, wie die gewünscht Genauigkeit nicht erreicht ist. Das überprüfst Du, indem Du Deinen berechneten Wert mit einem Literaturwert vergleichst. Oder dem Wert, der in Delphi drin ist. ;-)

Was soll nun in dieser Schleife passieren? Ganz einfach: Du addiest zu "Deinem" Pi immer den entsprechenden Summanden. Wie kommt man an den? Du machst Dir einfach eine Variable für den Nenner, startest damit bei 1 und erhöhst die bei jedem Schleifendurchlauf um 2. Außerdem multiplizierst Du sie bei jedem Schleifendurchlauf mit -1.

Ach ja, um im Formblatt die Anzahl der Summanden anzugeben, kannst Du auch den Wert der Nennenvariable auswerten.

Hoffe, das hat geholfen. :-)

MfG
Peter

[neolithos]

Bei 15 Stellen sollte man Double (oder gar Extended nehmen :gruebel: ). Wegen der internen Genauigkeit.

Bei Double sollte es sogar so gehen, das man den vorher berechneten Wert mit dem gerade berechneten Wert vergleicht. Wenn gleich dann ABBRUCH.

[LilKriztina]

Danke für euee Antworten, und

@Peter; Tut mir Leid, kenne mich noch nicht so gut aus :/!! Aber ich werde es mir merken!! Und deine Antwort hat mir auch geholfen, ich wollte nur mal sehen, was andere zu dem Thema sagen. Ich kann das jetzt auch nicht ausprobieren, da Delphi muckt.
Schreib mir jetzt was dazu auf und muss es dann in der Schule versuchen :( !!! Und wenn es dann nicht gleich funktioniert hab ich wohl ein großes Problem, deswegen wollte ich in dem anderen FORUM fragen, da dort vielleicht jemand das ganze Programm für mich hat, damit ich gar keine Fehler mehr machen kann.

Aber ich hab ja auch dieses hier:

Delphi-Quellcode:

var
 Form1: TForm1;
anzahl,code,i,y:integer;
p,piv:extended;
r:string;
test:boolean;


implementation

{$R *.dfm}

procedure TForm1.Button2Click(Sender: TObject);
begin
val(edit1.text,anzahl,code);
piv:=0;
y:=1;
test:=true;
for i :=1 to anzahl do
begin
if test=true then
begin
piv:=piv+(1/y);
test:=false;
end
else
begin
piv:=piv-(1/y);
test:=true;
end;
y:=y+2;
end ;
p:=piv*4;
str(p:1:15,r);
edit2.text:=r;

end;

end.

Wenn es nicht anders geht, nehm ich das, auch wenn es nicht ganz den Vorstellungen unseres Lehrers entspricht!!!

[edit=thomasdrewermann]DELPHITAGS ergänzt. Mfg, thomasdrewermann[/edit]

[neolithos]

Achtung C:

Code:

// pi/4= 1-1/3+1/5-1/7+1/9-1/11 

#include "stdio.h"

void main()
{
   printf("Calculate Pi...\n");

   double fQPi = 1;
   unsigned int iStep = 0;
   double fDiv = 3;
   double fOldPi = 0;
   double fPi = 1;

   while (fOldPi != fPi) // <-- hier 1
   {
      fOldPi = fPi;

      // Berechne Viertel Pi
      if (iStep % 2 == 1)
         fQPi += 1.L / fDiv;
      else
         fQPi -= 1.L / fDiv;
      fPi = fQPi * 4;

      // Nächster Schritt
      fDiv += 2;
      iStep += 1;

      // Text
      if (iStep % 10000000 == 0)
         printf("%12.0d - %12.0f - Pi ist %18.15f\n", iStep, fDiv, fPi);
   }
}

Diese Idee gibt zwar schöne Werte aus. Führt aber anscheinend in endlicher Zeit nicht zum Ende.

Erkenntnis:

15 Stellen Genauigkeit sind in endlicher Zeit nicht zu schaffen.

Achtung: Diese Schleife wird höchst wahrscheinlich kein Ende nehmen.

Zu 1, dort müsste ein Round hin um eine gültige Abbruchbedingung zu erhalten. Maximal 8-10 Nachkommastellen.

@LilKriztina:

Übrignes ich habe C gewählt damit du auch ein wenig grübeln darfst. Ich will ja nicht die Ausaufgaben Prühwarm servieren. Obwohl es fast schon so ist.

[Evian]

ich hab mich mal kurz rangesetzt und das ist bei rausgekommen:

Code:

function errechPI(x:integer ):Extended;
VAR
i, e : INTEGER;
pi : Extended;
BEGIN
  pi := 1; e := 1;
  FOR i := 1 TO x DO
  BEGIN
   e := e+2;
   IF i MOD 2 = 0 THEN
   pi := pi + 1 / e ELSE
   pi := pi - 1/e;
  END;
  result := pi * 4;
END;

ist schön kurz, funzt ohne BOOLEAN und geht 100 pro!

..EDIT.. falls´ dis als Prozedur brauchst:

Code:

VAR
x : Extended;                 // globale Deklaration

Procedure errechPI;
VAR
i, e : INTEGER;               //interne Deklaration
pi : Extended;
BEGIN
  pi := 1; e := 1;            // Initialisierung
  FOR i := 1 TO x DO  
  BEGIN
   e := e+2;
   IF i MOD 2 = 0 THEN        // Vergleich des Restkommawertes
   pi := pi + 1 / e ELSE
   pi := pi - 1/e;
  END;
  Edit1.text := floattostr(pi * 4);
END;

statt Extended könntest Du auch jeden anderen Gleitkommatyp nehmen, z.B. Real , ist halt die Frage... wie genau Du PI haben willst?!

[Evian]

Und is´s das Richtige?! Oder brauchst es anders?! ... *neugierig*
Jetzt wo ich mein Abi habe, gibts ja keinen Lehrer mehr.. der mir
so "geile" Aufgaben gibt :)

[LilKriztina]

Ich hab das jetzt alles schön ausgedruckt, ausprobieren kann ich es ja noch nicht :/!! Aber es sieht gut aus!!!! Danke noch mal an alle :thuimb: !!!!! :-D

@ Evian
Ich werde dir rechtzeitig Bescheid sagen, ob es das richtige war ;)!!!!

[Evian]

:)

mir is da noch was eingefallen, manche Lehrer sind da ja sehr
peniebel. So könntest Du noch ne Variabel sparen:

Code:

function errechPI(x:integer ):Extended; 
VAR 
i, e : INTEGER;  
BEGIN 
  result := 1; e := 1; 
  FOR i := 1 TO x DO 
  BEGIN 
   e := e+2; 
   IF i MOD 2 = 0 THEN 
   result := result + 1 / e ELSE 
   result := result - 1 / e; 
  END; 
  result := result * 4; 
END;

gruss

Evi

[ToZie]

Noch kürzer

Code:

function PiRauskriegen: double;
var
  Teiler, vz: integer;
  Pi: double;
begin
  Pi:=1; Teiler:=3; vz:=-1;
  while true do begin <-- hier muss eine Abbruchbedingung hin
    Pi:=Pi+vz/Teiler;
    Teiler:=Teiler+2;
    vz:=vz*-1;
  end;
  PiRauskriegen:=4*Pi;
end;

mit der Anzahl gefundener Nachkommastellen als Abbruchbedingung könnte es dann so aussehen

Code:

function PiRauskriegen(Genauigkeit: integer): double;
var
  Teiler, vz: integer;
  Pi, Pa, g: double;
begin
  Pi:=1; Pa:=3; Teiler:=3; vz:=-1;
  g:=power(10,Genauigkeit*-1)/4;
  while abs(pa-pi) > g do begin
    Pa:=Pi;
    Pi:=Pi+vz/Teiler;
    Teiler:=(Teiler+2);
    vz:=vz*-1;
  end;
  PiRauskriegen:=4*Pi;
end;