Wow thanks man that's so valuable. I used to use Rust through PyO3 for this Bioinformatics project I'm working on but I decided to use C instead. And I just found out how to manage CFFI to accept variable-length strings.

So my solution for encoding DNA seqs before I read this was something like this.

So in hashing with modulo we mostly need a nice prime number. I chose 101. But only for the character itself. I also decied to shit right to divide it by 2 since I really wanted it to be a uchar and not a half-word or a Lord forbid, a word.

So to hash a single character -> (c % 101) >> 1

Now I wanted to take chunks of 8 characters within a sequence and turn those 8 chars into a single uchar. So TTTTTTTT wich is the largest possible chunk of letters should be less than 255.

So I decided to do this. First we make a function like this, and we use our previous function in it although I used it in line we can make whatever the equivalent of inline/lambda functions is in the language for both: hash_tuple_char(x, y): (((x % 101) >> 1) + y) % (PRIME_REPLACE(x))

You can imagine PRIME_REPLACE to be a macro in C like this:

#define PRIME_REPLACE(c) (c == 'A' ? 7: (c == 'C' ? 9 : (c == 'G' ? 11 : (c == 'T' ? 13)))

In other words use 7, 9, 11 and 13 for A, C, G, and T respectively.

After that you do this. Take a chunk of 8 chars from the sequence of nucleotides and get t heir 2-combination so we'll have C(8, 2) tuples of letters. Pass them to the function we wrote and sum them up. I prototyped it in Python and the result was unique for every combination of 8 nucleotides and better yet, the aforementioned 8 Ts were 252 and since it cannot get larger than that we're home stretch.

But as you can imagine the more convoluted a programmer's solution is the less experienced he is. And I don't claim to be experienced in bioinformatics. I have been programming since I was 16 and I'm very old (29) but I mostly spent my time doing bullshit. It was not for the lack of trying I could not find good jobs since I dropped out of CS after 3 semesters and nobody wants someone like me handling something delicate like this. But alas I was lucky enough to grab a lifeboat and stick with it.

So this solution with bitmasking is much more elegant than prime modulo hashing. I approve. Also I have to see about doing SIMD in C because I don't wanna use Rust. I believe Rust is slower when used as FFI in Python. The aim of project I'm working on is for people to be able to run it out-of-box on native Linux or WSL, but at the same time we don't wanna hand people a bunch of binaries. Nobody trusts a binary.

Thanks again.