ich habe eine Hashfunktion die mir für eine Reihenfolge von double-werten einen schlüssel berechnet. Dabei spielt die Reihenfolge der double-werte ebenfalls eine rolle.
Meine Schlüssel sind 32 Bit lang.

Beispiel:

[0.0, 1.2, 0.0, 0.0]
[0.0, 0.0, 1.2, 0.0]
[0.0, 1.2]

ergeben alle unterschiedliche schlüssel. Also sowohl der Wert des doubles als auch seine Position werden miteinbezogen. Dies mache ich durch einfaches durchmischen mit einem zwischenwert.

Also für jeden double wird ein schlüssel berechnet, dann durchgemischt und dann ein neuer schlüssel des nächsten doubles hinzugerechnet und wieder durchgemischt...das funktioniert auch wunderbar - die schlüssel sind weitgehend kollisionsfrei (glaube ich zumindest).

Frage:
Der wertebereich ist im rechner natürlich beschränkt. Laufe ich denn trotzdem nicht gefahr Kollisionen zu bekommen?

Wäre folgender Ansatz eine weitere Verbesserung:?
Wenn ich folgende Vektoren habe

[0.0, 0.0, 3.9999999999999999999999999999999999999999998, 0.0]
[0.0, 0.0, 4.0, 0.0]

also die 3.99...89 gerade noch darstellbar ist.
KÖnnte ich eine Prüfung so machen dass ich die beiden ergebnisschlüssel der vektoren bitweise miteinander vergleiche?

Hilft das überhaupt was?

Könnte ich so prüfen dass falls ich 2 identische Schlüssel habe ich dann die Vektoren bitweise teste ob sie identisch sind? Reicht mir das dann als "eindeutiges" Kriterium?

Danke

Doch es kann doch vorkommen dass 2 Schlüssel identisch sind - also eine kollision aufgetreten ist.

Würde es hier jetzt sinn machen zuerst die einzelnen double-werte miteinander zu vergleichen? Das geht ja auch nur bis auf eine gewisse epsilon-toleranz also sowas:

if (abs(0.9999 - 1.0) < 1e-15) dann gleich.

Das ist doch aber blödsinn weil damit liefere ich mir doch selbst wieder nur eine approximation und damit im grunde eine kollision wo vielleicht keine ist...

Doch es kann doch vorkommen dass 2 Schlüssel identisch sind - also eine kollision aufgetreten ist.

Würde es hier jetzt sinn machen zuerst die einzelnen double-werte miteinander zu vergleichen?

Wie willst du denn dadurch verhindern, dass trotzdem gleiche Schlüssel entstehen können?

Ist dein Schlüssel-Generierungs-Algorithmus gefährdet, Kollisionen zu erzeugen? Ich würde das mal ausführlich testen. Und sonst kommst du wahrscheinlich nicht darum herum, den Algorithmus zu ändern.

Wie willst du denn dadurch verhindern, dass trotzdem gleiche Schlüssel entstehen können?

vollständig verhindern kann ich es natürlich nicht - sonst hätte ich ja eine möglichkeit gefunden kollisionen beim hash zu umgehen. Aber die wahrscheinlichkeit für eine Kollision kann ich dann reduzieren.

Ist dein Schlüssel-Generierungs-Algorithmus gefährdet, Kollisionen zu erzeugen?

Gefährdet ist jeder Schlüssel-Generierungs-Algorithmus (vielleicht fast jeder).Es kamen bisher keine Kollisionen vor - das zu testen ist aber auch fast unmöglich. Es kann immer einen input geben wo Kollisionen auftreten. Ich will die Wahrscheinlichkeit einfach minimieren. Deswgen die frage.

Wie gesagt ist die Idee folgende:
Ich baue mir aus einem double-vektor einen ganzzahligen Schlüssel auf. Wenn jetzt 2 Schlüssel identisch sind prüfe ich in einem 2ten schritt die einzelnen double-werte des vektors bis auf eine epsilon-toleranz.
Bringt das überhaupt was? Bzw. kann ich dadurch die Wahrscheinlichkeit weiter verringern in eine Kollision zu kommen?

Danke