hash_fn.h

/*  _________________________________________________________________________
 *
 *  UTILIB: A utility library for developing portable C++ codes.
 *  Copyright (c) 2001, Sandia National Laboratories.
 *  This software is distributed under the GNU Lesser General Public License.
 *  For more information, see the README file in the top UTILIB directory.
 *  _________________________________________________________________________
 */

//
// hash_fn.h
//
// Defines commonly used hash functions
//

#ifndef __hash_fn_h
#define __hash_fn_h

#include "BasicArray.h"
#include "CharString.h"

//
// Declarations for the Bob Jenkins hash function (which is quite good!)
//
typedef unsigned long int  ub4; /* unsigned 4-byte quantities */
typedef unsigned      char ub1; /* unsigned 1-byte quantities */
ub4 bjlookup( register ub1* k, register ub4 length, register ub4 level);
//
// Declarations for hash functions based on the bjlookup function
//
inline unsigned long int hash_bj(const double& val, unsigned long int level=0)
        {return bjlookup((ub1*)&val,sizeof(double),level);}
inline unsigned long int hash_bj(const int& val, unsigned long int level=0)
        {return bjlookup((ub1*)&val,sizeof(int),level);}
inline unsigned long int hash_bj(const BasicArray<int>& array, 
                                                unsigned long int level=0)
        {return bjlookup((ub1*)(array.data()),array.size()*sizeof(int),level);}
inline unsigned long int hash_bj(const int* array, const int arraylen, 
                                                unsigned long int level=0)
        {return bjlookup((ub1*)(array),arraylen*sizeof(int),level);}
inline unsigned long int hash_bj(const BasicArray<double>& array, 
                                                unsigned long int level=0)
        {return bjlookup((ub1*)(array.data()),array.size()*sizeof(double),level);}
inline unsigned long int hash_bj(const double* array, const int arraylen, 
                                                unsigned long int level=0)
        {return bjlookup((ub1*)(array),arraylen*sizeof(double),level);}



template <class T>
size_type hash_fn(const T& key, size_type table_size)
{return key.hash(table_size);}
template<class T>
inline size_type hash_fn(const SimpleArray<T>& key, size_type table_size)
        {return hash_fn1(*((const BasicArray<T>*)&key),table_size);}



//
// CharString
//
size_type hash_fn1(const CharString& key, size_type table_size);
size_type hash_fn2(const CharString& key, size_type table_size);
size_type hash_fn3(const CharString& key, size_type table_size);
template<>
inline size_type hash_fn(const CharString& key, size_type table_size)
        {return hash_fn3(key,table_size);}


//
// int
//
size_type hash_fn1(const int& key, size_type table_size);
inline size_type hash_fn2(const int& key, size_type table_size)
        {return hash_bj(key) % table_size;}
template<>
inline size_type hash_fn(const int& key, size_type table_size)
        {return hash_fn2(key,table_size);}


//
// double
//
size_type hash_fn1(const double& key, size_type table_size);
inline size_type hash_fn2(const double& key, size_type table_size)
        {return hash_bj(key) % table_size;}
template<>
inline size_type hash_fn(const double& key, size_type table_size)
        {return hash_fn2(key,table_size);}


//
// BasicArray<int>
//
size_type hash_fn1(const BasicArray<int>& key, size_type table_size);
inline size_type hash_fn2(const BasicArray<int>& key, size_type table_size)
        {return hash_bj(key) % table_size;}
template<>
inline size_type hash_fn(const BasicArray<int>& key, size_type table_size)
        {return hash_fn2(key,table_size);}


//
// BasicArray<double>
//
size_type hash_fn1(const BasicArray<double>& key, size_type table_size);
size_type hash_fn2(const BasicArray<double>& key, size_type table_size);
inline size_type hash_fn3(const BasicArray<double>& key, size_type table_size)
        {return hash_bj(key) % table_size;}
template<>
inline size_type hash_fn(const BasicArray<double>& key, size_type table_size)
        {return hash_fn3(key,table_size);}

//
// SimpleArray<double>
//
inline size_type hash_fn1(const SimpleArray<double>& key, size_type table_size)
                {return hash_fn1(*((const BasicArray<double>*)&key),table_size);}
inline size_type hash_fn2(const SimpleArray<double>& key, size_type table_size)
                {return hash_fn2(*((const BasicArray<double>*)&key),table_size);}
inline size_type hash_fn3(const SimpleArray<double>& key, size_type table_size)
                {return hash_fn3(*((const BasicArray<double>*)&key),table_size);}
template<>
inline size_type hash_fn(const SimpleArray<double>& key, size_type table_size)
        {return hash_fn3(*((const BasicArray<double>*)&key),table_size);}

//
// SimpleArray<int>
//
inline size_type hash_fn1(const SimpleArray<int>& key, size_type table_size)
                {return hash_fn1(*((const BasicArray<int>*)&key),table_size);}
inline size_type hash_fn2(const SimpleArray<int>& key, size_type table_size)
                {return hash_fn2(*((const BasicArray<int>*)&key),table_size);}
template<>
inline size_type hash_fn(const SimpleArray<int>& key, size_type table_size)
        {return hash_fn2(*((const BasicArray<int>*)&key),table_size);}

#endif