vor längerer Zeit hat jemand aus dem Forum hier eine Hash-Funktion für double werte geschrieben. Sie funktioniert prima. Was sie tut: aus einem double einen eindeutigen hash-wert zurückzugeben.

Nur verstehe ich absolut nicht wie intern diese 2 Zeilen arbeiten.
Ich bräuchte wirklich jemanden der GENAU erklärt was mit welchen BIts passiert und vor allem warum. Ich versuche es unten von selbst damit ihr seht wie dumm ich bis jetzt bin

typedef unsigned int U_Int32;                  
typedef unsigned long long U_Int64; 

inline U_Int32 
Hash::hash_double(double x)
{ 
    U_Int64* p = reinterpret_cast< U_Int64* > (&x); 
    return *p ^ (*p >> 32); 
}

Mein Versuch:
x hat 64 Bit und wird übergeben,
wir erzeugen einen pointer p der auch 64 Bit hat und der auf die Adresse von x zeigt. also dorthin zeigt er wo x was trägt sozusgaen.
Jetzt nehmen wir den Inhalt von x (weil ja p draufzeigt) der 64 BIt hat, shiften ihn einmal um 32 Bit nach rechts so das in den ersten 32 Bits NUllen erzeugt werden. Jetzt machen wir ein XOR zwischen dem kompletten wert aus x und diesen geshifteten und geben nur die unteren 32 Bits zurück????????

Hilfe bitte

Mati schrieb:

wir erzeugen einen pointer p der auch 64 Bit hat ...

noe stimmt so nicht ganz. ein pointer wird hochstwahrscheinlich 32 bit breit sein, aber er zeigt auf einen 64-bit breiten integer. zu mindest nach dem reinterpret_cast.
der schreiberling kann nun mit (double)x rechnen wie mit einem 64 bit breiten integer.
ausserdem werden nicht in den ersten 32 bits auf 0 gesetzt sondern die letzten 32.
warum er jedoch genau diesen algortihmus verwendet vermag ich dir leider auch nicht zu sagen.
[edit] die funktion gibt den wert zurueck den die ersten 32 bit xor den 2ten 32 bit ergibt [/edit]

Meep Meep

es handelt sich bei der Funktion um eine Routine, die zu einer Gleitkommazahl einen Hashwert bildet.

Zuerst wollen wir uns anschauen, wie viel Speicher die vorkommenden Datentypen benötigen...

#include <iostream>
using namespace std;
int main() {
    cout << "u int " << sizeof(unsigned int) << endl;
    cout << "u long long " << sizeof(unsigned long long) << endl;
    cout << "double " << sizeof(double) << endl;
}

u int 4
u long long 8
double 8

Wir halten also fest: Ein positiver, ganzzahliger Wert benötigt 4 (der Einfachheit halber) "Einheiten". Ein Wert vom Typ unsigned long long benötigt das Doppelte, nämlich 8 Einheiten - Das ist genausoviel Speicher wie eine Gleitkommazahl (double) in Anspruch nimmt.

Der Funktion hash_double wird eine Gleitkommazahl x übergeben. Diese wird als Ganzzahl vom Typ unsigned long long aufgefasst (*p). Dies wird als Zeiger p auf die lokale Variable x umgesetzt.

Nun wird der Shift-Operator auf den Wert des dereferenzierten Zeiger p angewandt und anschließend mit *p verknüpft. Relevant ist an dieser Stelle nur der "zweite" Teil (die letzte Hälfte der Bits) des Wertes, da die Routine hash_double eine 32Bit-Ganzzahl zurückgibt (es findet also implizit eine Typumwandlung statt).

Zusammenfassend kann man sagen: Die Funktion hash_double fasst eine 64 Bit Gleitkommazahl als Ganzzahl auf und Verknüpft die erste Hälfte der Bits via XOR mit der zweiten Hälfte der Bits. Das Ergebnis der Bitoperation wird als 32 Bit Ganzzahl zurückgegeben.

Zahlen aus einer Quellmenge werden Hashwerte zugeordnet, welche deutlich weniger Speicher in Anspruch nehmen und möglichst eindeutig sind.

http://de.wikipedia.org/wiki/Hash sollte weitere Informationen liefern.

Grüße Martin

"Einheiten"

=Bytes.

vor längerer Zeit hat jemand aus dem Forum hier eine Hash-Funktion für double werte geschrieben. Sie funktioniert prima. Was sie tut: aus einem double einen eindeutigen hash-wert zurückzugeben.

Einen Hash-Wert. Das "eindeutig" ist hier überflüssig bzw. falsch, je nachdem, wie man es versteht.

Mir ist schon vieles klarer.

Aufgerufen wird die Funktion ja so:

U_Int32 
Hash::compute_key(const double* vec, 
                  size_t size) const
{                    
    //The mix value is necessary because of the zero elements. 
    //without v1 = 0.0 0.0 1.0 and v2 = 0.0 0.0 0.0 1.0 would
    //produce the same key
    U_Int32 ret = 0;
    U_Int32 mix = hash_double(0.13);
    while(size--)
    {
        ret = (ret * 31) + mix + hash_double(*vec);
        vec++;
    } 
    return ret;
}

Wäre es nicht sinnvoller gewesen eher gleich nen 64 Bit Rückgabewert zu generieren anstatt nur die gemixten 32 Bit zurückzugeben aus der Funktion? Oder ist das in diesem Fall egal?
Man könnte doch trotzdem die Bits mixen und dann nen 64 Bit Wert als Hashwert zurückgeben oder? Wäre das nicht besser?

Wäre es nicht sinnvoller gewesen eher gleich nen 64 Bit Rückgabewert zu generieren anstatt nur die gemixten 32 Bit zurückzugeben aus der Funktion? Oder ist das in diesem Fall egal?
Man könnte doch trotzdem die Bits mixen und dann nen 64 Bit Wert als Hashwert zurückgeben oder? Wäre das nicht besser?

Wir müssen uns vor Augen halten, wozu wir eigentlich Container in Kombination mit Hashwerten verwenden...

Hashwerte werden generiert um Datenbestände schnell zu verwalten. Zum beispiel können in einem Container der Gebrauch von Hash-Funktionen macht schnell Datenelemente miteinander verglichen werden oder nach der Größe geordnet werden o.Ä..

Um nun zur Frage zurückzukommen ein Beispiel: Angenommen wir haben 10 große Texte à 20MB. Nun wollen wir alle gleichen Texte rausfinden. Anstatt nun die Texte von jeweils 20MB miteinander zu vergleichen, erstellen wir zu jedem Text einen Hashwert von 2MB und vergleichen diese generierten Werte untereinander - somit sparen wir Zeit und das Programm ist deutlich performanter.
Wenn den Hashwert nun ebenfalls 20MB betragen würde, so könnten wir auch direkt die Texte vergleichen und hätten die Zeit gespart, die für das Erzeugen der Hashwerte anfällt.

Hashwerte finden gerade bei vielen und großen Datenbeständen wie z.B. in Datenbanken häufig Einsatz. Wenn Hashwerte gebildet werden, so ist dies zumeist immer mit einem Informationsverlust verbunden, weswegen die Wahl der Hash-Funktion entscheiden ist.

Grüße Martin

danke für Deine genauen Antworten - alles sehr interessant.

Leider verstehe ich nicht ganz Deine Antwort auf meine Frage. Meinst Du vielleicht dass die Schlüssel deshalb so gewählt wurden (32 Bit) weil wir da mit einer komprimierten Datenmenge arbeiten? ALso sprich da wir ja so schneller suchen können als gleich die gesamten Elemente miteinander zu vergleichen die z.B 64 Bit groß sind?

Danke für Deine Antwort

Man kann hier also ziemlich sicher annehmen, das 32 Bit für eine vollständige Adressierung aller Objekte ausreichen.
Ein 64 Bit Wert und der damit einhergehende reservierte Speicherplatz wäre dann also überdimensioniert.
MfG

Hashcodes können aber genauso für einen Hashtable verwendet werden, und da kommts nicht darauf an dass der Hashcode schneller zu vergleichen geht, sondern dass man aus "was auch immer" (müssen ja keine doubles sein) einen Integerwert bekommt.
Diesen Integerwert bildet man dann (üblicherweise einfach mit Modulo) auf ein Fenster [0-N) ab, wobei N die grösse des Hashtables ist.
An diesem Index im Table legt man dann das zum Hashcode gehörende Objekt ab.

Natürlich kann es dabei zu Kollisionen kommen, da gibt es dann verschiedene Verfahren das "aufzulösen" (die einfachste ist dass die Elemente des Tables einfach Listen von Werten sind, man kann also zu jedem Index mehrere Werte ablegen).

Wenn man dann einen bestimmten Wert in so einem Hashtable suchen möchte muss man nur den Hashcode bilden, den auf das Fenster abbilden, an der Stelle im Table nachgucken und fertig. (Das "Nachgucken" geht dabei üblicherweise sehr schnell, denn wenn der Hashtable gross genug gewählt ist kommt es sehr selten vor dass zu einem Index mehr als 2 oder 3 Werte abgelegt sind.)

Man gewinnt also nicht dadurch Geschwindigkeit dass der Hashcode kleiner und schneller zu vergleichen ist als der Originalwert, sondern dadurch dass man im Idealfall bloss einen einzigen Vergleich durchführen muss - egal wieviele Elemente der Hashtable enthält.