How to hash a 96-bit struct/number?

Question

So I can't figure out how to do this in C++. I need to do a modulus operation and integer conversion on data that is 96 bits in length.

Example:

struct Hash96bit
{
   char x[12];
};

int main()
{
   Hash96bit n;
   // set n to something
   int size = 23;
   int result = n % size
}

Edit: I'm trying to have a 96 bit hash because i have 3 floats which when combined create a unique combination. Thought that would be best to use as the hash because you don't really have to process it at all.

Edit: Okay... so at this point I might as well explain the bigger issue. I have a 3D world that I want to subdivide into sectors, that way groups of objects can be placed in sectors that would make frustum culling and physics iterations take less time. So at the begging lets say you are at sector 0,0,0. Sure we store them all in array, cool, but what happens when we get far away from 0,0,0? We don't care about those sectors there anymore. So we use a hashmap since memory isn't an issue and because we will be accessing data with sector values rather than handles. Now a sector is 3 floats, hashing that could easily be done with any number of algorithms. I thought it might be better if I could just say the 3 floats together is the key and go from there, I just needed a way to mod a 96 bit number to fit it in the data segment. Anyway I think i'm just gonna take the bottom bits of each of these floats and use a 64 bit hash unless anyone comes up with something brilliant. Thank you for the advice so far.

Answer 1

You can use jenkins hash.

uint32_t jenkins_one_at_a_time_hash(char *key, size_t len)
{
    uint32_t hash, i;
    for(hash = i = 0; i < len; ++i)
    {
        hash += key[i];
        hash += (hash << 10);
        hash ^= (hash >> 6);
   }
   hash += (hash << 3);
   hash ^= (hash >> 11);
   hash += (hash << 15);
   return hash;
}

Answer 2

UPDATE: Having just read your second edit to the question, I'd recommend you use David's jenkin's approach (which I upvoted a while back)... just point it at the lowest byte in your struct of three floats.

Regarding "Anyway I think i'm just gonna take the bottom bits of each of these floats" - again, the idea with a hash function used by a hash table is not just to map each bit in the input (less till some subset of them) to a bit in the hash output. You could easily end up with a lot of collisions that way, especially if the number of buckets is not a prime number. For example, if you take 21 bits from each float, and the number of buckets happens to be 1024 currently, then after % 1024 only 10 bits from one of the floats will be used with no regard to the values of the other floats... hash(a,b,c) == hash(d,e,c) for all c (it's actually a little worse than that - values like 5.5, 2.75 etc. will only use a couple bits of the mantissa....).

---

Since you're insisting on this (though it's very likely not what you need, and a misnomer to boot):

struct Hash96bit
{
   union {
       float f[3];
       char x[12];
       uint32_t u[3];
   };

   Hash96bit(float a, float b, float c)
   {
       f[0] = a;
       f[1] = b;
       f[2] = c;
   }

   // the operator will support your "int result = n % size;" usage...
   operator uint128_t() const
   {
       return u[0] * ((uint128_t)1 << 64) +  // arbitrary ordering
              u[1] + ((uint128_t)1 << 32) +
              u[2];
   }
};