util_hash.h

Go to the documentation of this file.

#ifndef UTIL_HASH_H
#define UTIL_HASH_H
#ifdef __cplusplus
extern "C"{
#endif
#include "util_io.h"
#include "util_m4ri.h"
 
  

  typedef struct TWO_VEC_T {
    UT_hash_handle hh;
    int *err; 
    //    int cnt;  /** how many times this vector was encountered */
    int w_e; 
    int w_s; 
    //  int w_tot; /** `= w_e+w_s` */
    //  size_t len; /** `weight*sizeof(int)` (is this really needed?) */
    int syn[0]; 
  } two_vec_t;
 
  struct CW_VEC_T {
    UT_hash_handle hh;
    int weight;
    int cnt;   
    int cnt_u; 
    int cnt_w; 
    int arr[0];
  };
 
  typedef struct ONE_VEC_T{
    int wei; 
    //    int max; /** allocated */
    int vec[0];
  } one_vec_t;
 

  void one_vec_print(const one_vec_t * const pvec);
  
  static inline two_vec_t * two_vec_init(const one_vec_t * const syn, const one_vec_t * const err){
    two_vec_t * ans = malloc(sizeof(two_vec_t)+sizeof(int)*(syn->wei + err->wei));
    if(!ans)
      ERROR("memory allocation fail");
    for(int i=0; i < syn->wei; i++)
      ans->syn[i] = syn->vec[i];
    ans->w_e = err->wei;
    ans->w_s = syn->wei;
    ans->err = &( ans->syn[syn->wei] );
    for(int j=0 ; j < err->wei; j++)
      ans->err[j] = err->vec[j];
    
    return ans;
  } 
  
  static inline void two_vec_print(const two_vec_t * const it){
    if(!it){
      printf("two_vec_print(): null structure!\n");
      return;
    }
    printf("# two_vec: w_e=%d e=[",it->w_e);
    for(int i=0; i < it->w_e; i++)
      printf(" %d",it->err[i]);
    printf(" ]%s w_s=%d s=[",it->w_s>20?"\n#":" ",it->w_s);
    for(int i=0; i < it->w_s; i++)
      printf(" %d",it->syn[i]);
    printf(" ]\n");
  }

  static inline int by_syndrome(void *a, void *b){
  const two_vec_t * const pa = (two_vec_t *) a;
  const two_vec_t * const pb = (two_vec_t *) b;
  if (pa->w_s < pb->w_s)
    return -1;
  else if (pa->w_s > pb->w_s)
    return +1;
  else{ 
    for(int i=0; i < pa->w_s; i++){
      if (pa->syn[i] < pb->syn[i])
    return -1;
      else if (pa->syn[i] > pb->syn[i])
    return +1;
    }
  }
  return 0;
}

  static inline int by_error(void *a, void *b){
    const two_vec_t * const pa = (two_vec_t *) a;
    const two_vec_t * const pb = (two_vec_t *) b;
    if (pa->w_e < pb->w_e)
      return -1;
    else if (pa->w_e > pb->w_e)
      return +1;
    else{ 
      for(int i=0; i < pa->w_e; i++){
    if (pa->err[i] < pb->err[i])
      return -1;
    else if (pa->err[i] > pb->err[i])
      return +1;
      }
    }
    return 0;
  }

  static inline two_vec_t * hash_add_maybe(one_vec_t * syn, const one_vec_t * const err,
                 two_vec_t * errors, int p_swei[],
                 __attribute__ ((unused)) const int debug){
    two_vec_t *pvec, *entry;
    const size_t keylen = syn->wei * sizeof(int);
    if(p_swei[err->wei] > syn->wei){
      //#ifndef NDEBUG
      if(debug & 4096){ /* DBG_LEGACY in util_io.h */
    printf("# swei[%d]=%d -> %d change\n# err: ",
           err->wei,p_swei[err->wei],syn->wei);
    one_vec_print(err);
    printf("# syn: ");
    one_vec_print(syn);
      }
      //#endif
      p_swei[err->wei]=syn->wei;      
    }
#ifndef NDEBUG      
    else{   
      if(debug & 4096){ /* DBG_LEGACY in util_io.h */
    printf("p_swei[%d]=%d swei=%d not small enough\n",err->wei,p_swei[err->wei],syn->wei);
    one_vec_print(err);
    one_vec_print(syn);
      }
    }
#endif      
 
    HASH_FIND(hh, errors, syn->vec, keylen, pvec);
    if(!pvec){ 
      entry = two_vec_init(syn, err);       
      HASH_ADD(hh, errors, syn, keylen, entry); 
    }
    else{  
#ifndef NDEBUG  
      if(debug & 4096){ /* DBG_LEGACY in util_io.h */
    printf("err: ");
    one_vec_print(err);
    printf("syn: ");
    one_vec_print(syn);
    printf("already in the hash:\n");
    two_vec_print(pvec);
      }
#endif   
    }
    return errors;
  }
  
 
#ifdef __cplusplus
}
#endif
 
#endif /* UTIL_HASH_H */