Guten Tag, ist es möglich ein dynamisches Array von 1..x mit x>2Milliarden zu erstellen? (Vom Typ Boolean)
also
var DasArray: Array of Boolean;
und dann
setlength(DasArray, 10000000000);// (10milliarden)

oder muss man dann ein 2D Array erstellen, dass je 1 bzw. 2 Millarde groß ist?
also
var DasArray: Array of Array of Boolean;

setlength(DasArray, ceil(10000000000/1000000000), 1000000000); //ceilceil(10000000000/1000000000)=10

Edit: und was ist wenn man ein Array > (2Millarden)² haben will? Muss man dann ein 3D Array anlegen?
und wenn ja, wie kann man direkt ein "unbegrenztes Array" erzeugen?

Edit2: Und wenn es möglich ist ein unendliches Array zu haben, geht dieses bei 4 Milliarden schon über die meisten Arbeitsspeicher hinnaus... ist es also möglich diese auf der Festplatte auszulagern? (wenn auch nur für wenige Sekunden)

Edit vom 16.04: Titel von "Unendliches Array möglich" in "Riesige Boolean-Array verkleinern" umgeschrieben

1. Unendlich geht nicht, weil unendlich als real nicht erreichbar definiert ist.
2. Jedes dynamische Array ist erstmal per Definitition unbegrenzt (allerding in den Grenzen des Endlichen)
3. Wenn eine Speicherbelegung den RAM überschreitet, wird eh (auf Platte) ausgelagert - auch schon vorher, weil ja noch etwas mehr im RAM ist als nur die eine Variable
4. kann man selbst ein Array so verwalten, daß es größer als der RAM ist - siehe früher bei Variablen > Segment.
5. Bloß wozu das? Bei solchen riesen Variablen lagert man gleich in eine db aus.

IhopeonlyReader hat folgendes geschrieben :

Guten Tag, ist es möglich ein dynamisches Array von 1..x mit x>2Milliarden zu erstellen? (Vom Typ Boolean) [...]

Solche Fragen zu beantworten ist Delphi selbst der kompetenteste Antwortgeber.

1. Danke also kein 1D Array ist als "unendliches Array" möglich
2. Logisch also begrenzt
3. Werde ich dann ausprobieren, ob ich auch mehr als 5 Milliarden Booleans (ca. 5 Milliarden Bit = ca. 4,66 GB benötigt) erzeugen kann (bei 4 GB Ram)
4. siehe 3.
5. db = database? dann werde ich www.delphi-treff.de/...nwendung-mit-delphi/ mal durchgehen

Edit: @Delphi-Laie: Ich meine damit, ob es möglich ist (wie durch ein 2D Array) das eigentliche Maximum zu übergehen...

Lösungsvorschlag:


type
TUnendlichesArray = class
NochGroesser: Array of TUnendlichesArray;
IntergerVar: Array of Integer;
end;

Und dann für ceil(X/MaxArray) das UendlichArray um 1 Array erhöhen... Wäre das Möglich?

Zum Indizieren der Arrayelemente werden integre Datentypen verwandt - diese können schließlich auch nicht unendlich groß sein.

Ich würde ein Array of Integer wählen. Dann kommt man mit einem Bruchteil des Speichers aus. Man kann ja sagen, dass ein gesetztes Bit true, ein nicht gesetztes Bit false entsprechen soll. Ein Integer ist 32 Bit groß und kann somit 32 verschiedene Bit-Werte speichern. Es ist allerdings ein wenig Rechnerei erforderlich, um z. B. das 20.000ste Bit anzusprechen.
Siehe auch www.delphipraxis.net...oolean-so-gross.html zum Platzbedarf.

Geht Round(ExtendedVar) nicht als Indexangabe?

Edit:

funktioniert bei mir wunderbar

Wäre gut, wenn du uns mitteilst wofür du denn das Riesenarray eigentlich nutzen willst, 2+ Milliarden Einträge schreit nach Designfehler oder DB.

Laut Profil Delphi 7, also auf jeden Fall eine 32-Bit-Anwendung. Also ist die Größe des verfügbaren Speichers für die Anwendung auf 2GB beschränkt (mit Tricks auch 3, iirc). Da kannst du dir 128 TB RAM in den Rechner packen, deine Delphi-Anwendung kommt über die 2GB nicht hinaus.

Da ein Array auch zusammenhängend im Speicher liegen muss, ist in der Regel bei ~1.5GB Schluss.

Gausi hat folgendes geschrieben :

Laut Profil Delphi 7

Richtig

Gausi hat folgendes geschrieben :

Da ein Array auch zusammenhängend im Speicher liegen muss, ist in der Regel bei ~1.5GB Schluss.

Das habe ich auch schon gemerkt.. 1.587.604 KB (also 1.515 GB) ist Ende... mehr kriege ich nicht hin
Und wie wäre es möglich mehr als diese 1,5 GB zu nutzen? (du erwähntest "mit Tricks auch 3").. diese 3 würde ich gerne voll nutzen

Näheres dazu weiß ich nicht...wie man das hinbekommt, weiß ich nicht. Es bleibt aber immer noch das Problem, dass das Array zusammenhängend im Speicher liegen muss. Das ist ein zusätzliches Problem.

Mein Tipp: Konzept ändern oder auf 64 Bit wechseln.

Edit: Oder den Hinweis von Gerd Kayser umsetzen.

Erzähl doch mal, was du eigentlich damit vor hast. Sicher findet sich dann eine gangbare Möglichkeit. Schließlich wurdest du jetzt schon dreimal danach gefragt und bist die Antwort schuldig geblieben.

Und eines ist sicher:
Nimmt man Deinen Titel, so ist die Frage wohl nur rhetorisch.

Ein unendlich großes Array ist definitiv nicht nur wegen der zu kleinen Integer-Größe der Indizierung, sondern wegen des viel zu kleinen Speicherplatzes selbst aller Rechner dieser Erde nicht möglich. Du könntest selbst alle Computer oder was auch immer des Universums zusammenschalten und dann wärst Du nicht mal bei 0,000000000001% des Wertes für unendlich.

Was ich damit sagen will: Es gibt nichts im Universum, was unendlich ist, also erst Recht nichts auf dieser viel kleineren Erde. Unendlich ist bloß ein Konstrukt, um etwas darzustellen, was es nicht gibt: 1/0.

Und dann ist das, was Du im Text fragst, was ganz anderes, als das, was Du im Titel schreibst.


Und ich denke schon, dass das möglich ist, aber sicher - wenn Du ein so großes Array überhaupt nutzen willst, schon fast etwas für Datenbankanwendugnen. Da aber wenig über den Zweck des Ganzen klar ist, kann man nur spekulieren, und das ist wenig sinnvoll.

Allgemein: Booleans zusammenfassen um Speicher zu sparen (Ram)

Genaues Beispiel: Zur Zeit Sieb des Eratosthenes... wenn ich Primzahlen bis 2 Milliarden errechnen will, so erstellt er ein Array bis 2Milliarden (zur Zeit ca 1,7GB Groß [2 Millarden Byte])... allerdings hat Gerd Kayser mich daran erinnert, das Booleans (true, False) eigentlich nur 2 Werte speichern -> 1Bit aber um schneller zu sein 8 Bit (1Byte) groß sind.. (0-255) hierbei enspricht 0= True 1-255 = False...


Meine Überlegung:
Ein Array of Byte anzulegen und dieses nur 1/8 mal so groß zu gestalten wie das voherige Boolean-Array...

Dann gäbe es eine Procedure SetzteBoolean(Zahl: Integer; Wert: Boolean);
Das aus floor(ln(Zahl)/ln(2)) ausrechnet, in welchem Byte es stehen müsste, und dann mit
Function GibBoolen(Zahl: Integer): Boolean;
Result := power(2, ln(zahl) mod ln(2))>=Byte[floor(ln(Zahl)/ln(2))] //wenn es eintrifft dann ist die Zahl (Boolean) = True, sonst false..

wenn GibBoolean=Wert ist dann nichts machen sonst Byte[floor(ln(Zahl)/ln(2))] - power(2, ln(zahl) mod ln(2))



das ist alles eine theoretische Überlegung.. der Code ist jetzt einfach mal so aus dem Kopf... Aber ich denke er zeigt, wie in 8Bit 8Booleans gespeichert/ausgelesen werden können

.. Wenn ich Zeit habe, werde ich mein Sieb mal umprogrammieren

Das geht doch viel einfacher... Einfach nur die Primzahlen, die man bis zur Zahl n gefunden hat, einem Array hinzufügen. Dann kann die Abfrage vereinfacht so ausschauen:

If ( zuTestendeZahl in primzahlArray) then istPrimzahl:= true else istPrimzahl:= false;

Dann brauchst du ja nur Einträge für die Primzahlen und du kannst einen wesentlich größeren Zahlenbereich abdecken.

@platztwart... bis zu der Zahl 1,5 Milliarden gibt es 74.726.528 Primzahlen(ca 75 Millionen)
also wäre das Integer Array (nach dem du verlangst) 75 Millionen* 32 (= 2,4 Milliarden) Bit groß..
das ist 1. wesentlich größer als 1*1,5Millarden Bit und würde somit MEHR Ram benötigen.. und
2. Wäre der Rechenaufwand für istPriemzahl := (zuTestendeZahl) in PrimzahlenArray)
soweit ich weiß ebenfalls größer -> dauert länger

Und 3. Das Sieb des Eratosthenes schließt zahlen aus! somit müsste man von Anfang an Ein Array mit ALLEN zahlen erzeugen, und dann zahl für zahl löschen.. das heißt dein Array wäre am Anfang 1,5Miliiarden*32Bit groß.. selbst wenn man die geraden zahlen am Anfang ausschließen würde (bis auf 2) wäre es noch (1,5Milliarden/2 +1) *32 (=1,2 Milliarden + 32) Bit groß

Edit: Eine Variante, die Zahl für Zahl durchgeht und einen Teiler sucht (bis Wurzel(Zahl)) habe ich auch schon programmiert, braucht aber ungefäht 100x so lange wie das Sieb

Edit 2: Der einzige Vorteil deiner Methode liegt darin, dass man jede einzelne Primzahl ausrechen würde, bei mir immer auf das nächste vielfache von 8.
so würdest du z.B. für Primzahlen Bis 9 am Anfang ein Array[1..9] of Integer anlegen und ich ein [1,..2] of Byte und würde damit sozusagen bis 16 die Primzahlen ausrechnen

Wenn Du mit einfacher "platzsparender" meinst, dann ist das eine Milchmädchen-Rechnung: Es gibt 105097565 Primzahlen <= MaxLongint, diese verbrauchen 4*105097565 = 420390260 Bytes in einem Array of longint. Speichert man als Bitmuster braucht man naiv 268435455 Bytes (also schon mal weniger); da aber alle Primzahlen bis auf eine ungerade sind, kommt man mit der Hälfte = MaxLongint div 16 = 134217727 aus, also mit ca 32% des Primzahlarrays.

Du sprichst ja hier von "ins Unendliche". Dann mach die Rechnung mal mit 64-Bit Integer auf, dann schau das schon ganz anders aus...

Aber nur wenn Du mir verrätst, wie Du die ca 425656284014012096 64-Bit Primzahlen in ein Array packst.

Vielleicht könnte man eine Menge Speicherplatz sparen, wenn man wie folgt speichert:

1: 1 1. Primzahl
2: 1 = 2 - 1
3: 1 = 3 - 2
4: 2 = 5 - 3
5: 2 = 7 - 5
6: 4 = 11 - 7

Also ab der 1. Primzahl (Meinetwegen kann es auch die 2 sein), nur noch die Differenz zwischen der vorherigen und der aktuellen Primzahl. Das werden selbst bei sehr hohen Primzahlen immer noch wesentlich kleinere Werte als die Primzahlen selber sein.

Dann kommt man möglicherweise schon mit Longint (4 Byte Integer) aus. Aber sicher wird die Grenze nur qweiter nach vorne geschoben.