Function ReverseComplementImpl

src/simd.cpp:121–160

}

void ReverseComplementImpl(const char* src, char* dst, int len) {
    const hn::ScalableTag<uint8_t> d;
    const int N = hn::Lanes(d);

    // Complement via single table lookup on low nibble of ASCII code.
    // DNA base low nibbles: A/a=1, C/c=3, T/t=4, G/g=7, N=14.
    // Uppercase and lowercase share the same low nibble, so one table
    // handles both.  Unmapped nibbles default to 'N'.
    HWY_ALIGN static const uint8_t kComplement[16] = {
        'N', 'T', 'N', 'G', 'A', 'N', 'N', 'C',
        'N', 'N', 'N', 'N', 'N', 'N', 'N', 'N'
    };
    const auto table = hn::LoadDup128(d, kComplement);
    const auto vMask = hn::Set(d, static_cast<uint8_t>(0x0F));

    int i = 0;
    for (; i + N <= len; i += N) {
        const auto v = hn::LoadU(d, reinterpret_cast<const uint8_t*>(src + i));
        const auto indices = hn::And(v, vMask);
        const auto comp = hn::TableLookupBytes(table, indices);

        // Reverse and store at mirrored position
        const auto revComp = hn::Reverse(d, comp);
        hn::StoreU(revComp, d, reinterpret_cast<uint8_t*>(dst + len - i - N));
    }

    // Scalar tail
    for (; i < len; i++) {
        char base = src[i];
        char comp;
        switch (base) {
            case 'A': case 'a': comp = 'T'; break;
            case 'T': case 't': comp = 'A'; break;
            case 'C': case 'c': comp = 'G'; break;
            case 'G': case 'g': comp = 'C'; break;
            default: comp = 'N'; break;
        }
        dst[len - 1 - i] = comp;
    }
}

int CountAdjacentDiffsImpl(const char* data, int len) {
    if (len <= 1) return 0;