custom hasher in initializer constructor with arguments for parallel_hash_map

[gf777]

Hi @greg7mdp
I was looking here #125
And I thought I could use the same syntax for parallel_hash_map but it doesn't work:

struct KeyHasher {

      uint64_t* pows = new uint64_t[kPrefixLen];
      
      KeyHasher() {
          for(uint8_t p = 0; p<kPrefixLen; ++p) // precomputes the powers of k
              pows[p] = (uint64_t) pow(4,p);
      }
      
      std::size_t operator()(const Key& key) const {
          
          uint8_t *kmerPtr = seqBuf->seq+key.getKmer();
          uint64_t fw = 0, rv = 0; // hashes for both forward and reverse complement sequence
          
          for(uint8_t c = 0; c<kPrefixLen; ++c) { // for each position up to kPrefixLen
              fw += *(kmerPtr+c) * pows[c]; // base * 2^N
              rv += (3-(*(kmerPtr+kLen-1-c))) * pows[c]; // we walk the kmer backward to compute the rvcp
          }
          
          // return fw < rv ? 0 : 0; // even if they end up in the same bucket it's fine!
          return fw < rv ? fw : rv;
      }
  };
  
  struct KeyEqualTo {
      
      Buf<uint8_t> *seqBuf, *seqBuf2;
      
      KeyEqualTo(Buf<uint8_t> *seqBuf = NULL, Buf<uint8_t> *seqBuf2 = NULL) : seqBuf(seqBuf), seqBuf2(seqBuf2) {}
      
      constexpr bool operator()(const Key& key1, const Key& key2) const {
          
          uint8_t *lhs = seqBuf->seq+key1.getKmer(), *rhs = seqBuf2->seq+key2.getKmer();
          
          for(uint32_t i = 0; i<kLen; ++i) { // check fw
              if(lhs[i] != rhs[i])
                  break;
              if (i == kLen-1)
                  return true;
          }
          for(uint32_t i = 0; i<kLen; ++i) { // if fw fails, check rv
              if(lhs[i] != 3-rhs[kLen-i-1])
                  return false;
          }
          return true;
      }
  };

`Kmap(UserInput& userInput) : userInput(userInput), k{kPrefixLen}, maps(0, KeyHasher(), KeyEqualTo(seqBuf, seqBuf2)), maps32(0, KeyHasher(), KeyEqualTo(seqBuf, seqBuf2))`

What is the right syntax?
Thanks!!

[gf777]

Actually, I realize that the syntax is the same:

maps[m] = new ParallelMap(0, KeyHasher(seqBuf[m].seq, prefix, k), KeyEqualTo(seqBuf[m].seq, prefix, k));

And:

struct KeyHasher {

    uint8_t prefix;
    uint32_t k;
    uint64_t* pows;
    Buf2bit<> *seqBuf;
    
    KeyHasher() {}
    
    KeyHasher(Buf2bit<> *seqBuf, uint8_t prefix, uint32_t k) : prefix(prefix), k(k), seqBuf(seqBuf) {
        pows = new uint64_t[prefix];
        for(uint8_t p = 0; p<prefix; ++p) // precomputes the powers of k
            pows[p] = (uint64_t) pow(4,p);
    }
    std::size_t operator()(const Key& key) const {

        uint64_t fw = 0, rv = 0, offset = key.getKmer(); // hashes for both forward and reverse complement sequence
        
        for(uint8_t c = 0; c<prefix; ++c) { // for each position up to prefix len
            
            fw += seqBuf->at(offset+c) * pows[c]; // base * 2^N
            rv += (3-seqBuf->at(offset+k-1-c)) * pows[c]; // we walk the kmer backward to compute the rvcp
        }
        // return fw < rv ? 0 : 0; // even if they end up in the same bucket it's fine!
        return fw < rv ? fw : rv;
    }
};

[greg7mdp]

@gf777 Glad you found your answer, sorry I wasn't more helpful, I'm very busy these days.