mirror of
https://github.com/lcn2/calc.git
synced 2025-08-16 01:03:29 +03:00
Release calc version 2.10.2t30
This commit is contained in:
Landon Curt Noll
474
quickhash.c
Normal file
474
quickhash.c
Normal file
@@ -0,0 +1,474 @@
|
||||
/*
|
||||
* Copyright (c) 1996 by Landon Curt Noll. All Rights Reserved.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software and
|
||||
* its documentation for any purpose and without fee is hereby granted,
|
||||
* provided that the above copyright, this permission notice and text
|
||||
* this comment, and the disclaimer below appear in all of the following:
|
||||
*
|
||||
* supporting documentation
|
||||
* source copies
|
||||
* source works derived from this source
|
||||
* binaries derived from this source or from derived source
|
||||
*
|
||||
* LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
|
||||
* EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
||||
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
|
||||
* USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
* OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
* PERFORMANCE OF THIS SOFTWARE.
|
||||
*
|
||||
* chongo was here /\../\
|
||||
*/
|
||||
|
||||
/*
|
||||
* quickhash - qickly hash a calc value using a partial Fowler/Noll/Vo hash
|
||||
*
|
||||
* NOTE: This file does not contain a hash interface. It is used by
|
||||
* associative arrays and other internal processes.
|
||||
*
|
||||
* We will compute a hash value for any type of calc value
|
||||
* for use in associative arrays and the hash() builtin.
|
||||
* Hash speed is of primary importance to make associative
|
||||
* arrays work at a reasonable speed. For this reason, we
|
||||
* cut corners by hashing only a small part of a calc value.
|
||||
*
|
||||
* The Fowler/Noll/Vo hash does a very good job in producing
|
||||
* a 32 bit hash from ASCII strings in a short amount of time.
|
||||
* It is not bad for hashing calc data as well. So doing a
|
||||
* quick and dirty job of hashing on a part of a calc value,
|
||||
* combined with using a reasonable hash function will result
|
||||
* acceptable associative array performance.
|
||||
*/
|
||||
|
||||
#include "value.h"
|
||||
#include "zrand.h"
|
||||
|
||||
#define ZMOST 2 /* most significant HALFs to hash */
|
||||
#define ZLEAST 2 /* least significant HALFs to hash */
|
||||
#define ZMIDDLE 4 /* HALFs in the middle to hash */
|
||||
|
||||
|
||||
/*
|
||||
* forward declarations
|
||||
*/
|
||||
static QCKHASH assochash(ASSOC *ap, QCKHASH val);
|
||||
static QCKHASH listhash(LIST *lp, QCKHASH val);
|
||||
static QCKHASH mathash(MATRIX *m, QCKHASH val);
|
||||
static QCKHASH objhash(OBJECT *op, QCKHASH val);
|
||||
static QCKHASH randhash(RAND *r, QCKHASH val);
|
||||
static QCKHASH randomhash(RANDOM *state, QCKHASH val);
|
||||
static QCKHASH config_hash(CONFIG *cfg, QCKHASH val);
|
||||
static QCKHASH fnv_strhash(char *str, QCKHASH val);
|
||||
static QCKHASH fnv_fullhash(FULL *v, LEN len, QCKHASH val);
|
||||
static QCKHASH fnv_zhash(ZVALUE z, QCKHASH val);
|
||||
|
||||
|
||||
/*
|
||||
* fnv - compute the next Fowler/Noll/Vo hash given a variable
|
||||
*
|
||||
* The basis of the hash algorithm was taken from an idea
|
||||
* sent by Email to the IEEE Posix P1003.2 mailing list from
|
||||
* Phong Vo (kpv@research.att.com) and Glenn Fowler (gsf@research.att.com).
|
||||
* Landon Curt Noll (chongo@toad.com) later improved on there
|
||||
* algorithm to come up with Fowler/Noll/Vo hash.
|
||||
*
|
||||
* The magic lies in the constant 16777619, which for 32 bit hashing
|
||||
* is able to process 234936 words from the web2 dictionary without
|
||||
* any collisions.
|
||||
*
|
||||
* given:
|
||||
* x the value to hash (must not be longer than 32 bits)
|
||||
* val previous QCKHASH value
|
||||
*
|
||||
* returns:
|
||||
* the next 32 bit QCKHASH
|
||||
*/
|
||||
#define fnv(x,val) (((QCKHASH)(val)*(QCKHASH)16777619) ^ ((QCKHASH)(x)))
|
||||
|
||||
|
||||
/*
|
||||
* fnv_qhash - compute the next Fowler/Noll/Vo hash given a NUMBER
|
||||
*
|
||||
* given:
|
||||
* q pointer to a NUMBER
|
||||
* val previous QCKHASH value
|
||||
*
|
||||
* returns:
|
||||
* the next 32 bit QCKHASH
|
||||
*/
|
||||
#define fnv_qhash(q,val) \
|
||||
(qisint(q) ? fnv_zhash((q)->num, (val)) : \
|
||||
fnv_zhash((q)->num, fnv_zhash((q)->den, (val))))
|
||||
|
||||
|
||||
/*
|
||||
* fnv_chash - compute the next Fowler/Noll/Vo hash given a COMPLEX
|
||||
*
|
||||
* given:
|
||||
* c pointer to a COMPLEX
|
||||
* val previous QCKHASH value
|
||||
*
|
||||
* returns:
|
||||
* the next 32 bit QCKHASH
|
||||
*/
|
||||
#define fnv_chash(c,val) \
|
||||
(cisreal(c) ? fnv_qhash((c)->real, (val)) : \
|
||||
fnv_qhash((c)->real, fnv_qhash((c)->imag, (val))))
|
||||
|
||||
|
||||
/*
|
||||
* hashvalue - calculate a hash value for a value.
|
||||
*
|
||||
* The hash does not have to be a perfect one, it is only used for
|
||||
* making associations faster.
|
||||
*
|
||||
* given:
|
||||
* vp pointer to a VALUE
|
||||
* val previous QCKHASH value
|
||||
*
|
||||
* returns:
|
||||
* next QCKHASH value
|
||||
*/
|
||||
QCKHASH
|
||||
hashvalue(VALUE *vp, QCKHASH val)
|
||||
{
|
||||
switch (vp->v_type) {
|
||||
case V_INT:
|
||||
return fnv(vp->v_int, V_NUM+val);
|
||||
case V_NUM:
|
||||
return fnv_qhash(vp->v_num, val);
|
||||
case V_COM:
|
||||
return fnv_chash(vp->v_com, val);
|
||||
case V_STR:
|
||||
return fnv_strhash(vp->v_str, val);
|
||||
case V_NULL:
|
||||
return val;
|
||||
case V_OBJ:
|
||||
return objhash(vp->v_obj, val);
|
||||
case V_LIST:
|
||||
return listhash(vp->v_list, val);
|
||||
case V_ASSOC:
|
||||
return assochash(vp->v_assoc, val);
|
||||
case V_MAT:
|
||||
return mathash(vp->v_mat, val);
|
||||
case V_FILE:
|
||||
return fnv(vp->v_file, V_FILE+val);
|
||||
case V_RAND:
|
||||
return randhash(vp->v_rand, val);
|
||||
case V_RANDOM:
|
||||
return randomhash(vp->v_random, val);
|
||||
case V_CONFIG:
|
||||
return config_hash(vp->v_config, val);
|
||||
default:
|
||||
math_error("Hashing unknown value");
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
return (QCKHASH)0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Return a trivial hash value for an association.
|
||||
*/
|
||||
static QCKHASH
|
||||
assochash(ASSOC *ap, QCKHASH val)
|
||||
{
|
||||
/* XXX - hash the first and last values??? */
|
||||
return fnv(ap->a_count, V_ASSOC+val);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Return a trivial hash value for a list.
|
||||
*/
|
||||
static QCKHASH
|
||||
listhash(LIST *lp, QCKHASH val)
|
||||
{
|
||||
/*
|
||||
* hash small lists
|
||||
*/
|
||||
switch (lp->l_count) {
|
||||
case 0:
|
||||
/* empty list hashes to just V_LIST */
|
||||
return V_LIST+val;
|
||||
case 1:
|
||||
/* single element list hashes just that element */
|
||||
return hashvalue(&lp->l_first->e_value, V_LIST+val);
|
||||
}
|
||||
|
||||
/*
|
||||
* multi element list hashes the first and last elements
|
||||
*/
|
||||
return hashvalue(&lp->l_first->e_value,
|
||||
hashvalue(&lp->l_last->e_value, V_LIST+val));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Return a trivial hash value for a matrix.
|
||||
*/
|
||||
static QCKHASH
|
||||
mathash(MATRIX *m, QCKHASH val)
|
||||
{
|
||||
long skip;
|
||||
long i;
|
||||
VALUE *vp;
|
||||
|
||||
/*
|
||||
* hash size parts of the matrix
|
||||
*/
|
||||
val = fnv(m->m_dim, V_MAT+val);
|
||||
val = fnv(m->m_size, val);
|
||||
|
||||
/*
|
||||
* hash the matrix index bounds
|
||||
*/
|
||||
for (i = m->m_dim - 1; i >= 0; i--) {
|
||||
val = fnv(m->m_min[i], val);
|
||||
val = fnv(m->m_max[i], val);
|
||||
}
|
||||
|
||||
/*
|
||||
* hash the first 16 elements
|
||||
*/
|
||||
vp = m->m_table;
|
||||
for (i = 0; ((i < m->m_size) && (i < 16)); i++) {
|
||||
val = hashvalue(vp++, val);
|
||||
}
|
||||
|
||||
/*
|
||||
* hash 10 more elements if they exist
|
||||
*/
|
||||
i = 16;
|
||||
vp = &m->m_table[16];
|
||||
skip = (m->m_size / 11) + 1;
|
||||
while (i < m->m_size) {
|
||||
val = hashvalue(vp, val);
|
||||
i += skip;
|
||||
vp += skip;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Return a trivial hash value for an object.
|
||||
*/
|
||||
static QCKHASH
|
||||
objhash(OBJECT *op, QCKHASH val)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = op->o_actions->count;
|
||||
while (--i >= 0)
|
||||
val = hashvalue(&op->o_table[i], val);
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* randhash - return a trivial hash for an a55 state
|
||||
*
|
||||
* given:
|
||||
* state - state to hash
|
||||
*
|
||||
* returns:
|
||||
* trivial hash integer
|
||||
*/
|
||||
static QCKHASH
|
||||
randhash(RAND *r, QCKHASH val)
|
||||
{
|
||||
/*
|
||||
* hash the RAND state
|
||||
*/
|
||||
if (!r->seeded) {
|
||||
/* unseeded state hashes to V_RAND */
|
||||
return V_RAND+val;
|
||||
} else {
|
||||
/* hash control values */
|
||||
val = fnv(r->j, V_RAND+val);
|
||||
val = fnv(r->k, val);
|
||||
val = fnv(r->bits, val);
|
||||
|
||||
/* hash the state arrays */
|
||||
return fnv_fullhash(&r->buffer[0], SLEN+SCNT+SHUFLEN, val);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* randomhash - return a trivial hash for a Blum state
|
||||
*
|
||||
* given:
|
||||
* state - state to hash
|
||||
*
|
||||
* returns:
|
||||
* trivial hash integer
|
||||
*/
|
||||
static QCKHASH
|
||||
randomhash(RANDOM *state, QCKHASH val)
|
||||
{
|
||||
/*
|
||||
* unseeded RANDOM state hashes to V_RANDOM
|
||||
*/
|
||||
if (!state->seeded) {
|
||||
return V_RANDOM+val;
|
||||
}
|
||||
|
||||
/*
|
||||
* hash a seeded RANDOM state
|
||||
*/
|
||||
val = fnv(state->buffer+state->bits, V_RANDOM+val);
|
||||
if (state->r != NULL && state->r->v != NULL) {
|
||||
val = fnv_zhash(*(state->r), val);
|
||||
}
|
||||
if (state->n != NULL && state->n->v != NULL) {
|
||||
val = fnv_zhash(*(state->n), val);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* config_hash - return a trivial hash for a configuration state
|
||||
*/
|
||||
static QCKHASH
|
||||
config_hash(CONFIG *cfg, QCKHASH val)
|
||||
{
|
||||
/*
|
||||
* hash scalar values
|
||||
*/
|
||||
val = fnv(cfg->traceflags + cfg->outdigits + cfg->outmode +
|
||||
cfg->epsilonprec + cfg->maxprint + cfg->mul2 +
|
||||
cfg->sq2 + cfg->pow2 + cfg->redc2 + cfg->tilde_ok +
|
||||
cfg->tab_ok + cfg->quomod + cfg->quo + cfg->mod +
|
||||
cfg->sqrt + cfg->appr + cfg->cfappr + cfg->cfsim +
|
||||
cfg->outround + cfg->round + cfg->leadzero +
|
||||
cfg->fullzero + cfg->maxerrorcount, V_CONFIG+val);
|
||||
|
||||
/*
|
||||
* hash the strings if possible
|
||||
*/
|
||||
if (cfg->prompt1) {
|
||||
val = fnv_strhash(cfg->prompt1, val);
|
||||
}
|
||||
if (cfg->prompt2) {
|
||||
val = fnv_strhash(cfg->prompt2, val);
|
||||
}
|
||||
|
||||
/*
|
||||
* hash the epsilon if possible
|
||||
*/
|
||||
if (cfg->epsilon) {
|
||||
val = fnv_qhash(cfg->epsilon, val);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* fnv_strhash - Fowler/Noll/Vo 32 bit hash of a string
|
||||
*
|
||||
* given:
|
||||
* str the string to hash
|
||||
* val initial hash value
|
||||
*
|
||||
* returns:
|
||||
* a 32 bit QCKHASH value
|
||||
*/
|
||||
static QCKHASH
|
||||
fnv_strhash(char *str, QCKHASH val)
|
||||
{
|
||||
/*
|
||||
* hash each character in the string
|
||||
*/
|
||||
while (*str) {
|
||||
val = fnv(*str++, val);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* fnv_fullhash - Fowler/Noll/Vo 32 bit hash of an array of HALFs
|
||||
*
|
||||
* given:
|
||||
* v an array of FULLs
|
||||
* len length of buffer FULLs
|
||||
* val initial hash value
|
||||
*
|
||||
* returns:
|
||||
* a 32 bit QCKHASH value
|
||||
*/
|
||||
static QCKHASH
|
||||
fnv_fullhash(FULL *v, LEN len, QCKHASH val)
|
||||
{
|
||||
/*
|
||||
* hash each character in the string
|
||||
*/
|
||||
while (len-- > 0) {
|
||||
val = fnv(*v++, val);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* fnv_zhash - Fowler/Noll/Vo 32 bit hash of ZVALUE
|
||||
*
|
||||
* given:
|
||||
* z a ZVALUE
|
||||
* val initial hash value
|
||||
*
|
||||
* returns:
|
||||
* a 32 bit QCKHASH value
|
||||
*/
|
||||
static QCKHASH
|
||||
fnv_zhash(ZVALUE z, QCKHASH val)
|
||||
{
|
||||
int skip; /* HALFs to skip in the middle */
|
||||
int i;
|
||||
|
||||
/*
|
||||
* hash the sign and length
|
||||
*/
|
||||
if (zisneg(z)) {
|
||||
val = fnv(-(z.len), val+V_NUM);
|
||||
} else {
|
||||
val = fnv(z.len, val+V_NUM);
|
||||
}
|
||||
|
||||
/*
|
||||
* if a ZVALUE is short enough, hash it all
|
||||
*/
|
||||
if (z.len <= ZMOST+ZLEAST+ZMIDDLE) {
|
||||
/* hash all HALFs of a short ZVALUE */
|
||||
for (i=0; i < z.len; ++i) {
|
||||
val = fnv(z.v[i], val);
|
||||
}
|
||||
|
||||
/*
|
||||
* otherwise hash the ZLEAST significant HALFs followed by
|
||||
* ZMIDDLE HALFs followed by the ZMOST significant HALFs.
|
||||
*/
|
||||
} else {
|
||||
/* hash the ZLEAST significant HALFs */
|
||||
for (i=0; i < ZLEAST; ++i) {
|
||||
val = fnv(z.v[i], val);
|
||||
}
|
||||
|
||||
/* hash ZMIDDLE HALFs in the middle */
|
||||
skip = (z.len-ZLEAST-ZMOST)/(ZMIDDLE + 1);
|
||||
for (i=ZLEAST-1+skip; i < ZLEAST-1+skip*(ZMIDDLE+1); i+=skip) {
|
||||
val = fnv(z.v[i], val);
|
||||
}
|
||||
|
||||
/* hash the ZMOST significant HALFs */
|
||||
for (i=z.len-1-ZMOST; i < z.len; ++i) {
|
||||
val = fnv(z.v[i], val);
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
Reference in New Issue
Block a user