Problem mit überlauf bzw. division durch null

[13Joe37]

Ahoihoi!!

ich sitz hier grad an nem kleinen Prog, das mir Pi "ausrechnet", nach folgender Methode: 1/1 + 1/4 + 1/9 + 1/16 + 1/25 + 1/36 .... 1/ n*n = Pi*Pi / 6
so, is auch alles kein Problem, bis ich n als ne sehr große zahl gesetzt hab, da bleibt das Program hängen bei ... + 1/65336 mit der fehlermeldung, ich solle doch bitte nicht durch null teilen :wiejetzt:??

will ich doch garnich, zuerst dachte ich, dass die Zahl vllt zu groß ist, es geht aber nur mit 65336 net, mit größeren gehts (also zumindestens mal bis 99999) :)

Also mit dem Quelltext gehts:

Delphi-Quellcode:

var i, n: longint;
begin
n:=strtoint(edit1.text);
x:=0;
memo1.lines.Clear;
memo1.lines.Add(' 1/' + '1²');
for i:=2 to n do
  begin
  //memo1.lines.Add('+1/' + inttostr(i)+ '²');
    if i = 65536 then else x:=x+(1/(i*i));
  end;
x:=x+1;
memo1.lines.add('=' + floattostr(x));
end;

ohne die if zeile (also nur x:=x+(1/(i*i))) bleibt er halt hängen...

wird mich wirklich ma interessieren, woran das liegt...
hm.. vllt weil 65336 = 265² = 2^16... keine Ahnung

Vielen Dank

13Joe37

[Helmi]

Hallo,

was ist denn das für ein Konstrukt?

Delphi-Quellcode:

    if i = 65536 then else x:=x+(1/(i*i));

Besser und übersichtlicher wäre das:

Delphi-Quellcode:

    if i <> 65536 then x:=x+(1/(i*i));

[13Joe37]

jaa... ist mir nachher auch aufgefallen...
der code da ist allgemein noch net so richtig, ich hab auch edit1 und Button1 so gelassen, wmach ich normal auch nicht...

[punkt21]

habs nich ausprobiert, aber versuch mal anstatt longint float zu benutzen.
vllt klappts damit

[HenKst]

Zitat:

Zitat von 13Joe37

Ahoihoi!!


wird mich wirklich ma interessieren, woran das liegt...
hm.. vllt weil 65336 = 265² = 2^16... keine Ahnung

Vielen Dank

13Joe37

2^16 is 65536 ;) nich 65336

aber so stehts ja auch im code

Und du benutzt ja LongInt und nicht word.
Bei word wäre 65535+1 = 0 und 0*0=0

Hast du vllt LongInt neu definiert? :)

[dominikkv]

ähm...ich hab das mal nachgeprüft:

Delphi-Quellcode:

showmessage(FloatToStr(1/(StrToInt(edt1.Text) * StrToInt(edt1.Text))));

Zuerst kam bei der Zahl 65536 (und nicht 65336) die Fehlermeldung Division durch 0, dann hab ich 35537 eingegeben -> geht.
Wenn ich jetzt aber wieder 65536 eingebe kommt die Meldung: INF (vllt Infinity?)

...komisch

[Helmi]

Hallo,

bei mir funktioniert folgender Code:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  i, n: longint;
  x   : Real;
begin
  n := StrToIntDef(Edit1.text, 10);
  x := 0;

  memo1.lines.Clear;

  memo1.lines.Add(' 1/' + '1²');

  for i := 2 to n do
    begin
      memo1.lines.Add('+1/' + inttostr(i)+ '²');
      If i < 65536 then
        x := x + (1 / (i * i))
      else
        break;
    end;

  x := x + 1;

  memo1.lines.add('=' + floattostr(x));
end;

[Edit]
Der Code geht nicht bei 65536 als Eingabe.
Division durch Null als Meldung

Ich hab auch rausgefunden warum:
65536 * 65536 = 4294967296

Und 4294967296 ist sogar für ein LongWord zu lang
ein LongWord geht von 0...4294967295

[HenKst]

;)

2^16*2^16 =2^32 = 0 :=)

also wenn i 65536 ist und mit sich selbst mutlipliziert wird kommt 2^32 raus
und da die oberen bits abgeschnitten werden ist das im longint nunmal leider 0^^

[nahpets]

Hallo,

da hast Du quasi einen Rechenfehler:

i ist ein LongInt und der kann Werte bis maximal 2147483647 annehmen.

65536 * 65536 ist aber 4294967296, das ist doch ein bisserl mehr, als in i reinpasst.
Weißt Du nun i einen Wert größer als 2147483647 zu, so tritt der Effekt auf, dass alle Bits, die zuviel sind, links rüberkippen und nicht berücksichtigt werden.

Schreib Dir mal 'ne Testprogramm mit folgendem Aufbau:

Delphi-Quellcode:

Var
          l : LongInt;
          d : Double;
begin
  // erster Test
  l := 2147483647;  // Mehr geht nicht in LongInt
  ShowMessage(IntToStr(l));
  l := l + 1;       // und jetzt tuen wir da einen mehr rein, als reingeht.
  ShowMessage(IntToStr(l));
  // zweiter Test
  l := 2147483647; // Mehr geht nicht in LongInt
  l := l + l;      // und das addieren wir zu uns selbst (= 2 * mehr geht nicht)
  ShowMessage(IntToStr(l));
  l := l + 2;      // und da tuen wir jetzt noch zwei drauf
  ShowMessage(IntToStr(l));
  // dritter Test
  d := 2147483647;     // Mehr geht nicht in LongInt
  d := d + 2147483647; // Mehr geht nicht in LongInt + Mehr geht nicht in LongInt
  d := d + 2;          // + 2
  ShowMessage(FloatToStr(d));
  // vierter Test
  d := 65536;          // unser Problemwert
  d := d * 65536;      // * unserem Problemwert
  ShowMessage(FloatToStr(d));
end;

und beobachte die angezeigten Ergebnisse. Danach wird Dir klar, warum 65536 * 65536 manchmal 0 ist.
Und überprüf' bei Gelegenheit mal, ob die Ergebnisse von Zahlen, die größer als 65536 bei Dir sind, wirklich stimmen.

[13Joe37]

Also zusammenfassend meint ihr, das 65536^2 = 0 ist, und wenn man halt 1/65536^2 macht, das das selbe ist wie 1/0 und das halt nicht geht?

Zitat:

Und überprüf' bei Gelegenheit mal, ob die Ergebnisse von Zahlen, die größer als 65536 bei Dir sind, wirklich stimmen

werd ich mal machen!
(versteh ich das jetzt richtig: wenn ich 65536^2 +1 eingebe, rechnet delphi praktisch mit 1, bei 65536^2 +2 = 2 usw? Dann sollte die genauigkeit des errechneten Pi's doch bei 65536^2-1 genau so groß sein wie bei 65536^2^2 oder noch gröeren Zahlen?) muss das mal gleich ausprobieren...