wenn INT64 voll ist

[DerKapitalist]

Hi!

ich hab da mal ne theoretische Frage. Angenommen ich hab ein Programm, das z.B. Daten mitließt, einen Netzwerkscanner zum Beispiel, und fuer jedes Byte das vorbeisaust mach ich position := position + 1. Wenn jetzt irgendwann in ferne zukunft mein position: int64 voll sein sollte, was mach ich dann eigtl.? kann man das noch erweitern?

ich hab mir schon gedacht ein dynamisches Array aus lauter int64 aufbauen, aber damit rechnen is ja auch nicht gerade schoen. gibt es ne möglichkeit, die ordinalen Datentypen so zu erweitern, dass ich sie immernoch ganz normal verwenden kann, so sagen wir, bis der speicher voll ist *g*?

wie wuerdet ihr das lösen,

ohjee jetzt is schon wieder spät.. gut, dann stoert mich niemand :-)

!danke!

[RomanK]

Such in delphi mal nach Extended, das sind Fließkommazahlen, die aber auch eine weiteren Zahlenbereich haben

[sakura]

Zitat:

Zitat von FuckRacism

Such in delphi mal nach Extended, das sind Fließkommazahlen, die aber auch eine weiteren Zahlenbereich haben

Diese sind aber zu ungenau, da kann man nicht, ab einer bestimmten Größe, um einzelne Positionen zählen. Such mal mit Google nach der "Hugh Numbers" Library (o.ä.), damit kommst Du ein ganzes Ende weiter.

[DerKapitalist]

gut, danke, werd ich mal schaun.


gibt es einen größeren Datentyp (vorzugsweise unsigned) als int64? (ausser extended, der ja nich richtig funktionieren soll) Er muss einfach genauso funktionieren wie ein stinknormaler integer, und er sollte nich "irgndwann mal ungenau" werden.


danke!

[sakura]

Noch gibt es nichts größeres in Delphi, da müssen wir erst auf eine 64-bit Version warten, welche dann auch 128-bit Integer unterstützen könnte.

[fiasko]

Zitat:

Zitat von sakura

Noch gibt es nichts größeres in Delphi, da müssen wir erst auf eine 64-bit Version warten, welche dann auch 128-bit Integer unterstützen könnte.

Naja für Verschlüsselung braucht man ja wesentlich größere Zahlen... so gleich mal paar 1024Bits... dafür gibts spezielle Bibliotheken. Für FPascal & Delphi z.B. unter http://triade.studentenweb.org/.
Allerdings rechnet das dann die CPU nich mehr direkt, so daß es langsamer geht.


Thomas

[sakura]

@fiasko: Bevor Du mich aus dem Zusammenhang ins Falsche hinein interpretierst, lies bitte alles. Mein erster Beitrag hat auch auf Ausweichmöglichkeiten hingewiesen ;)

[DerKapitalist]

@fiasko:

weißt du wie das arbeitet? wird dann eine sagen wir 1024bit CPU auf die gängigen 32 Bit emuliert? Ist das dann 1024/36 mal langsamer?



danke

[braingrenade]

Moin !

mach doch einfach ne zeite varible , die sobald position 10000
erreicht um eins eröht wird , und dann setzt du position wieder auf 0 und machst weiter!

[DerKapitalist]

danke fuer den tip.

es geht aber darum, das delphi-kompatibel zu lösen. Was nutzt mir das, wenn ich die variable extern weiterverabeiten muss (als Beispiel). Bei dem was du meinst bietet sich wohl ein dynamisches array am ehesten an...

ich denke die librarys bieten da die beste lösung. Oder meint ihr man könnte dem Compiler 128 bit beibringen *gg*

gruss

[sakura]

Zitat:

Zitat von DerKapitalist

ich denke die librarys bieten da die beste lösung. Oder meint ihr man könnte dem Compiler 128 bit beibringen *gg*

Nee, der Compiler arbeitet für 32-bit Systeme. 32-bit System unterstützen, von Haus aus, 64-bit Berechnung über das zusammenführen zweier Register. D.h., Delphi setzt auch nur auf diese Funktionalität auf. Die Prozessoren machen nicht mehr.

Wenn Du mehr haben willst, dann bleibt Dir nur der Umweg über oben genannte Bibliotheken.

[Christian Seehase]

Moin Kapitalist,

die Idee von Braingrenade stellt im Prinzip nichts anderes dar, als Du mit den Bibliotheken wirst erreichen können (mal abgesehen davon, dass seine Variante wohl deutlich schneller sein dürfte).

Da ja der Compiler maximal mit Int64 umgehen kann wirst Du es innerhalb einer Bibliothek für längere Werte kaum anders machen können, als bei Überlauf den nächsten Int64 um eins zu erhöhen.

Wahrscheinlich wird's sogar oft so ablaufen, dass es für jede Dezimalstelle ein Byte geben wird, so dass die Zahlen intern als dynamisches Byte Array abgebildet werden.

Einfach so als z.B. int64 angeben und dann einfach mit +/- rechnen wird bei solchen Datentypen nicht gehen, da es sich um Objekte handeln dürfte, mit Methoden die das Rechnen übernehmen, und das überladen von Operatoren kennt Pascal ja nun nicht.

Auch wenn's unwahrscheinlich ist, aber:
Eventuell würden solche Objekte in weiteren Delphi Versionen nicht mehr funktionieren, wohingegen das aufaddieren von int Typen wohl auch dort noch funktionieren sollte.

[MatrixStormProgrammierer]

Wie es auf dem PC so üblich geworden ist, kann man alles mögliche emulieren. Da nun unsere CPUs nun "nur" 32 Bit Register besitzen, ist theoretisch eine Berechnung in größeren Wertebereichen scheinbar unmöglich...

1.) Tatsache ist jedoch, das es Int64 (64 Bit groß) gibt...
Int64 wird teilweise emuliert und teilweise vom CPU unterstüzt,
indem z.B. der Assemblebefehl "mul" Produkte in eax und edx
aufteilt...

2.) Was ist nun wenn der Int64-Bereich zu Ende geht?
Naja, jede Rechenoperation ist ein Algorithmus (nicht umgekehrt!).
Es gibt also tatsächlich eine Möglichkeit größere Zahlen zu
verwenden. Ein einfaches Beispiel für eine 2048 Bit große Zahl
möchte ich kurz für den Befehl "inc" erläutern, bei weiteren Fragen
schreibt mir einfach per ICQ, 70036952.

Um alle Daten einer 2048 Bit (256 Byte) großen Zahl zu erfassen benötigen wir ein Feld aus Bytes... (ich empfehle Bytes, und nicht etwas größere Zahlentypen).

Delphi-Quellcode:

                 type mynumber = array[0..$ff] of byte;

Ein Befehl inc für den Typ "mynumber" würde also z.B. so aussehen:

Delphi-Quellcode:

procedure inc(var num : mynumber;BytesSummand : byte); overload;
var
    i,
    zwischenerg : word; // besser, falls jemand größere Zahlen nimmt
begin
 zwischenerg:=word(ByteSummand); 
 for i:=0 to sizeof(mynumber)-$1 do
  begin
   zwischenerg:=(zwischenerg and $ff) + num[i];
   num[i]:=zwischenerg and $ff;
   zwischenerg:=zwischenerg shr $8;
   if (zwischenerg = 0) then break; // kein Rest da...
  end;
end;

ps: hab das eben auf "die Schnelle" geschrieben, falls es nicht funzt, meldet euch bitte...

cu sagt MatrixStormProgrammierer...

[Illuminator-23-5]

es gibt auch eine andere, lustige methode, mit großen zahlen exakt zu rechnen: ein string ist 255 Zeichen lang. Wenn man eine 255-Stellige zahl hat, wie weit kann man damit zählen? und eins dazuaddieren ist auch ganz einfach :

i := length(zahl);
while zahl[i] = 'F' do begin
Zahl[i] := '0';
dec(i);
end;

Zahl[i] := IntToStr(StrToInt(zahl[i])+1);

[Christian Seehase]

Moin Illuminator,

Zitat:

Zitat von Illuminator-23-5

ein string ist 255 Zeichen lang.

Ein ShortString schon, aber der übliche HugeString kann, theoretisch, bis zu ca. 2GB Zeichen aufnehmen.