Passender Variablen-Typ gesucht

[Nikolas]

Ich will in einem Projekt recht viele (~ 50. - 100.000) Punkte im R² speichern und bearbeiten, d.h. lesen und ein paar Berechnungen durchführen. Da ich leider für meine aktuelle Idee jeden Punkt sehr oft auslesen muss, suche ich jetzt nach dem besten Datentyp dafür. Mir kommst da hauptsächlich auf die Leseperformance und den Speicherverbrauch an. Da ich jetzt nicht weiss, ob es teilweise schneller geht, einen Integer-Typ zu nehmen und die letzten paar Stellen als Nachkommastellen anzusehen, wollte ich hier mal fragen, ob da schon jemand Tests gemacht hat.

Vielen Dank

[Oxmyx]

Du hast wenig Auswahl: Wenn du Ganzzahlen willst, nimmst du Integer, wenn du Fließkommazahlen willst, nimmst du Single. Beides sind 32-Bit-Typen, 100.000 Variablen belegen also rund 400 KB im Speicher.
Du könntest einen 16-Bit-Typ nehmen um die Hälfte an Speicher zu belegen, aber ein Prozessor rechnet lieber mit 32-Bit-Werten als mit 16-Bit-Werten.

[Christian Seehase]

Moin Toxman,

welchen Wertebereich, und welche Genauigkeit willst/musst Du abdecken?

[dizzy]

\\edit: Nö, habbich mich vertan... sorry

[Nikolas]

@ Christian:

Die Werte werden wahrscheinlich nicht größer als 1.000.000 und als Genauigkeit sollten 3-4 Nachkommastellen gut ausreichen.

Vielen Dank schonmal.

[Christian Seehase]

Moin Toxman,

bei 3 Nachkommastellen, solltest Du mit integer klarkommen, bei 4 dann eben mit int64.
Nur nicht vergessen, dass die letzten Ziffern als Nachkommastellen anzusehen sind

[choose]

Bei diesem Ansatz, also dem "gedanklichen Verschieben" von Zahlenbereichen, musst Du allerdings bei arithmetischen Operationen Vorsicht walten lassen: Stellest Du Dir, wie von Christian beschrieben, eine Zahl n so vor, dass die letzten 3 Stellen (dezimal) als Nachkommastellen der darzustellenden Zahl [i9x[/i] interpretiert werden, gilt demnach Formal:

Code:

 n = x * 1000

oder, mit einem beliebigen "Faktor der Verschschiebung" f

Code:

 n = x * f

Bei der Addition/Subtraktion zweier Zahlen x1 und x2 mit

Code:

 x1 + x2 = x
 x1 - x2 = x

gilt

Code:

 x1*f + x2*f  =  f * (x1+x2)  =  f * x  =  n
 x1*f - x2*f  =  f * (x1-x2)  =  f * x  =  n

so dass Du bei der diesen Operationen keine besonderen Maßnahmen ergreiben musst.
Anders sieht dies aus, wenn Du zB multiplizierst oder dividierst:

Code:

 x1 * x2 = x
 x1 / x2 = x

wird zu

Code:

 (x1*f) * (x2*f)  =  f² * (x1*x2)  =  f*n
 (x1*f) / (x2*f)  =  x1/x2         =  n/f

so dass das Ergebnis anschließend (oder für eine höhere Genauigkeit ggf auch vorher) korrigiert werden muss!

Ist denn der Speicherbedarf tatsächlich das Problem, wenn Du mit 100.000 Double-Werten im R² arbeitest, sollten das ein Datenaufkommen von

Code:

 100.000*SizeOf(Double)*2 < 2MB

verursachen. Durch eine Abbildung mit dem Typ Integer gewinnst Du dabei lediglich Speicher um den Faktor 2. Interessant könnten Datenstrukturen wir QuadTrees oder Bäume i.A. sein, die je nach anschließender Verarbeitung nicht nur einen Vorteil in Sachen Performance mit sich bringen sollten sondern darüber hinaus auch Cluster abbilden könnten, deren Punktemenge ihrerseits in einem relativen Koordinatenbereich mit einem kleineren Intervall (zB [-2^15..2^15[ oder [-2^7..2^7[) liegen. Dann könntest Du zu Punkten jeweils diese relative Differenz ablegen und je nach Verteilung Deiner Punkte den Speicherbedarf dramatisch reduzieren...

Ich hoffe, Dir mit diesen unvollständigen Gedanken ein paar Möglichkeiten aufzeigen zu können

[Nikolas]

Vielen Dank, ich glaub, damit komm ich erstmal hin.