[Bockfett]

Moin ich habe jetzt mal mit Pascal angefangen zu programmieren, da ich es so wie so nächstes Jahr in die Schule brauchen werde und mir C++ zu schwer für den Einstieg war.

Heute habe ich also mein erstes, kleines, komplett selbs konzipiertes Programm geschrieben (bis auf die Formel aus dem Matheunterricht) und habe auch schon gleich ein paar Fragen.

Da es, wie gesagt, mein erstes Programm ist, wundert euch bitte nicht über den wahrscheinlich _etwas_ unkonventionellen Lösungsweg. ^^

1. Problem: Ich kann Pi auf höchstens 14 Stellen hinter dem _Komma_ berechnen ansonsten erhalte ich 0 als Ergebnis.
2. Die weiter hinteren Stellen stimmen bereits nach kurzer Zeit nicht mehr.
3. Muss man die Prozedur "zwisch" wirklich so kompliziert angehen?

Dazu habe ich die Formel mal angehängt als Bild - Schön mit Paint gemacht ^^
(Ausgegangen wird bei der Gleichung durch eine Schrittweise Näherung: erst 6, dann 12, dann 24 Ecken...)

Program Pi;
Uses CRT;
VAR Sn, enderg: extended;
       X: Byte;
       Y: Word;
    
  procedure zaehler;     
  begin
  X:= X - 1;             {Gib die Anzahl der Stellen hinterm Komma an}  
  Y:= Y * 2;             {Gibt die Anzahl der Ecken an}
  end;
  
 
  procedure zwisch;       {Ist ein Zwischenergebnis}
  begin
  SN:= Sn * Sn;
  SN:= SN / 4;
  SN:= 1-SN;
  SN:= sqrt (sn);
  SN:= 2 * SN;
  SN:= 2 - SN;
  SN:= sqrt (SN);
  end;
  
  
  procedure ergebnis;
  begin
  enderg:= y * SN;
  end;
  
   
  
begin
  highvideo;
  writeln ('==============================================
==');
  writeln ('=                                              =');
  writeln ('=   Programm zur Berechnung der Kreiszahl Pi   =');
  writeln ('=                                              =');
  writeln ('==============================================
==');
  writeln;
  writeln;
  writeln;
  normvideo;
  write ('Bitte geben sie die die gewünschte Anzahl der Stellen hinter dem Komma an...');
  highvideo;
  SN:= 1;
  Y:= 3;
  read (X);
  normvideo;
 repeat
  zaehler;
  zwisch;
  ergebnis;
  writeln (enderg);
 until X = 0;
  writeln ('Bitte bedenke, dass die Zahlen nur bis zur gewünschten Stelle korekt sind...');
  readkey;
  
  
end.  
  

Angehängte Datei(en)

•  Unbenannt.bmp (6,5K)
  Anzahl der Downloads: 127
•  Pi.exe (22K)
  Anzahl der Downloads: 46

[Foxhound]

Hi

vielleicht solltest du erstmal dein prog überarbeiten, da es irgendwie net funzt....
gibt man eine Zahl ein, so zeigt dir das prog so oft pi an wie die zahl ist....
Sollte die Zahl nicht eigentlich die rundungstellen nach dem komma angeben?


edit: obwohl nichma das, da die zahlen sich verändern....ich kapier den Sinn in dem prog net

Dieser Beitrag wurde von Foxhound bearbeitet: 14. Dezember 2004 - 19:56

[Bockfett]

Das ist so weit alles richtig...
Wenn du z.B 3 eingibst, wird beim ersten Mal ein exakter Wert für die erste Nachkommastelle angegeben (alle nachfolgenden Zahlen sind nicht genau), beim zweiten Mal ein exakter Wert für die 1. und 2. Nachkommastelle usw...
Das die Zahl indem Fall 3x angegeben wird, soll nur die Schrittweise Näherung andeuten. (Der Algorithmus ist so aufgebaut, dass er bei jedem Durchgang die Zahl Pi um eine Stelle nach dem Komma genauer darstellen sollte...)

Dieser Beitrag wurde von Bockfett bearbeitet: 14. Dezember 2004 - 20:11

[Rika]

Warum implementierst du nicht eine Arcustangens-Reihe mit schnellerer Konvergenz, z.B. nach Gauss mit pi=48arctan(1/18)+32arctan(1/57)-20arctan(1/239) und arctan(x)=\sum(n=1,\infinite, ((-1)^n*x^(2n-1))/(2n-1)) ?

sint16 a=1,b=1; double pi=0;
for(n=1;n<=100;n+=2,a=2-a,b+=4) {
pi+=a/b*(48*(1/17)**b+32*(1/57)**b-20*(1/239)**b));
}

[Dante33]

Zitat (Bockfett: 14.12.2004, 18:36)

1. Problem: Ich kann Pi auf höchstens 14 Stellen hinter dem _Komma_ berechnen ansonsten erhalte ich 0 als Ergebnis.
2. Die weiter hinteren Stellen stimmen bereits nach kurzer Zeit nicht mehr.
3. Muss man die Prozedur "zwisch" wirklich so kompliziert angehen?

<{POST_SNAPBACK}>

1.) Pascal ist nicht genauer, da würde auch das ändern einer Variable nichts ändern... Um genau zu sein liegt es an der Genauigkeit der CPU die maximal 14 nachkommastellen genau berechnet. Das ist eine Limitierung durch PC und Sprache.

2.) siehe 1.)

3.) Pascal ist von sich kompliziert und dumm.
Dafür lässt der Compiler absolut null Fehler zu!

[Rika]

Ja und warum programmiert er dann auch so einen komplizierten Algorithmus, wie er benannte? Also mir fiele da als erstes die Eulersche Summenformel ein. pi²/6=\sum(n=1,\infinite, 1/n²) und damit pi=sqrt(6*\sum(n=1,\infinite, 1/n²)).

Uses Crt;
VAR
pi: Extended;
n: DWord;

pi:=0;
BEGIN; {program}
  FOR n:=1 TO 10000000 DO
    pi:=pi+1/(n*n);
  pi:=sqrt(pi*6);
  Write("Pi is ");Write(pi);ReadLn;
END. {program}

Dieser Beitrag wurde von Rika bearbeitet: 14. Dezember 2004 - 21:23

[Dante33]

Wenn ich mich richtig entsinne ist pi ein fester begriff in pascal für die Zahl selbst.
Ausserdem fehlt für das For ein End oder nicht`

Aber da lass ich mich ruhig schlagen, Pascal ist ne Weile her...

Dieser Beitrag wurde von Dante33 bearbeitet: 14. Dezember 2004 - 21:35

[Bockfett]

Okay dann wären ja 1 und 2 geklärt - wollte schon gleich die Flinte ins Korn werfen
Vielleicht könnte mir ja auch einer zu 3 noch Auskunft geben ^^

Außerdem habe ich noch zwei weitere Fragen...
1. Wie ist es möglich größere Werte, als die einen longint zur Verfügung stellt, zu verwenden.
2. Meine Prozedur "zaehler" war nur improvisiert...
Gibt einen Pascal dazu auch andere Möglichkeiten?
3. (Jetzt sind es doch so viele geworden)
Was haltet ihr zum Thema Pascal vom Buch "Turbo Pascal 7.0 - Das Kompendium"?

@ Rika
Ich habe nicht nach einem möglichst effizienten Algorithmus gesucht, sondern den einzigen mir bisher bekannten benutzt, da ich erst in der 10. Klasse bin und Algorithmen nächstes Halbjahr kommen
Außerdem muss ich ihn ja auch verstehen und das habe ich in diesem Fall.
Außerdem war es ja wie gesagt mein erstes Programm ^^.

Edit: Vielleicht könnte mir einer einen _mathematischen_, nicht gleich einen _pascal_code_ ,Algorithmus zur Aufspürung von Primzahlen verraten. (Daher brauche ich auch größere Zahlen als sie mir longint zur Verfügung stellt)

Dieser Beitrag wurde von Bockfett bearbeitet: 14. Dezember 2004 - 21:53

[Dante33]

1.) Nein
2.) Nein, Pascal kennt keine Incrementations
3.) Ja, das ist gut, schau mal bei www.Terrashop.de !
Aber ältere Fassunge nreiche nfür die Schule mehr als aus!

[Rika]

Zitat

Ausserdem fehlt für das For ein End oder nicht`

Nein. Entweder Begin End; oder - bei einzelnen Instruktionen - gar nichts.

Zitat

1. Wie ist es möglich größere Werte, als die einen longint zur Verfügung stellt, zu verwenden.

Ja, aber nicht ohne deine eigene Implementierung dafür zu schreiben.
Deshalb lieber C, dort hast du uint128.

Zitat

Vielleicht könnte mir einer einen _mathematischen_, nicht gleich einen _pascal_code_ ,Algorithmus zur Aufspürung von Primzahlen verraten. (Daher brauche ich auch größere Zahlen als sie mir longint zur Verfügung stellt)

Erzeugen von beliebigen Primzahlen ohne Vollständigkeit, Erzeugen aller Primzahlen bis zu einer bestimmten Grenze oder prüfen, ob eine bestimmte Zahl eine Primzahl ist bzw. ob sie keine ist?

[Bockfett]

2. Also das z.B der Benutzer die Zahl 2000000 eingibt und ALLE Primzahlen angezeigt werden, am besten noch in eine Textdatei, wenn die nicht Rahmen sprengt...
Ansonsten falls das den Rahmen sprengen sollte, dass jeweils nur die größtmögliche des Suchsbereich angezeigt wird und/oder das man einen gewissen Bereich scannen kann, z.B alle Primzahlen von 500-1000.

[Rika]

Sieb des Erathosthenes...

CONST MAX=2000000;
VAR
a:ARRAY [1..MAX] OF Byte;
m,n:LONGINT;

BEGIN; {program}

  {Feld loeschen}
  FOR m:=2 TO MAX DO
  a[m]:=0;

  {1 faellt raus}
  a[1]:=1;

  n:=2;
  WHILE (n<=sqrt(MAX)) DO BEGIN

    Write(n);WriteLn("is a prime.");

    {alle Vielfachen der Primzahl löschen);
    FOR m:=2n TO MAX STEP n DO
      a[m]:=1;

    {nächste Primzahl suchen, d.h. noch nicht gelöschte Zahl}
    WHILE (a[n]=1) DO
       n:=n+1;

  END; {while}

END. {program}

(Ich weiß, es ging effizienter, indem man nur noch über der reduzierten Menge filtert, aber es ist ja ein Array und kein HashSet.)

Dieser Beitrag wurde von Rika bearbeitet: 14. Dezember 2004 - 22:29

[fens]

Zitat (Rika: 14.12.2004, 22:27)

Sieb des Erathosthenes...

CONST MAX=2000000;
VAR
a:ARRAY [1..MAX] OF Byte;
m,n:LONGINT;

BEGIN; {program}

  {Feld loeschen}
  FOR m:=2 TO MAX DO
  a[m]:=0;

  {1 faellt raus}
  a[1]:=1;

  n:=2;
  WHILE (n<=sqrt(MAX)) DO BEGIN

    Write(n);WriteLn("is a prime.");

    {alle Vielfachen der Primzahl löschen);
    FOR m:=2n TO MAX STEP n DO
      a[m]:=1;

    {nächste Primzahl suchen, d.h. noch nicht gelöschte Zahl}
    WHILE (a[n]=1) DO
       n:=n+1;

  END; {while}

END. {program}

(Ich weiß, es ging effizienter, indem man nur noch über der reduzierten Menge filtert, aber es ist ja ein Array und kein HashSet.)
<{POST_SNAPBACK}>

Ich finde Rika einfach geil. Da will ein Schüler ein wenig Pascal proggen in der 10. Klasse und er fängt mit "effizienter Progr." und "HashSet" an. immer wieder ein Lacher