Alphabet.cuh

Go to the documentation of this file.

#pragma once
 
#include <cuda/std/__bit/integral.h>
#include <cuda_runtime.h>
 
#include <concepts>
#include <cstdint>
 
namespace cusbf {
 
namespace detail {
 
template <typename T>
consteval uint64_t validByteCount() {
    uint64_t count = 0;
    while (T::validBytes[count] != '\0') {
        ++count;
    }
    return count;
}
 
template <typename T>
consteval bool
separatorPositionAlwaysEncodesInvalid(char* input, uint64_t separatorPosition, uint64_t index) {
    if (index == T::symbolWidth) {
        return T::encode(input) == static_cast<uint8_t>(T::invalidSymbol);
    }
 
    if (index == separatorPosition) {
        input[index] = static_cast<char>(T::separator);
        return separatorPositionAlwaysEncodesInvalid<T>(input, separatorPosition, index + 1);
    }
 
    for (uint64_t byteIndex = 0; byteIndex < validByteCount<T>(); ++byteIndex) {
        input[index] = T::validBytes[byteIndex];
        if (!separatorPositionAlwaysEncodesInvalid<T>(input, separatorPosition, index + 1)) {
            return false;
        }
    }
    return true;
}
 
template <typename T>
consteval bool separatorByteAlwaysEncodesInvalid() {
    for (uint64_t separatorPosition = 0; separatorPosition < T::symbolWidth; ++separatorPosition) {
        char input[T::symbolWidth]{};
        if (!separatorPositionAlwaysEncodesInvalid<T>(input, separatorPosition, 0)) {
            return false;
        }
    }
    return true;
}
 
}  // namespace detail
 
template <typename T>
concept Alphabet = requires(const char* input) {
    { T::symbolCount } -> std::convertible_to<uint64_t>;
    { T::symbolWidth } -> std::convertible_to<uint64_t>;
    { T::invalidSymbol } -> std::convertible_to<uint8_t>;
    { T::separator } -> std::convertible_to<uint8_t>;
    { T::validBytes } -> std::convertible_to<const char*>;
    { T::encode(input) } -> std::same_as<uint8_t>;
} && requires {
    requires T::symbolCount > 0 && T::symbolCount <= 255;
    requires T::symbolWidth > 0;
    requires detail::validByteCount<T>() > 0;
    requires detail::separatorByteAlwaysEncodesInvalid<T>();
};
 
struct DnaAlphabet {
    static constexpr uint64_t symbolWidth = 1;
    static constexpr uint64_t symbolCount = 4;
    static constexpr uint8_t invalidSymbol = 0xFFu;
    static constexpr uint8_t separator = 'N';
    static constexpr char validBytes[] = "ACGT";
 
    [[nodiscard]] constexpr __host__ __device__ __forceinline__ static uint8_t encode(
        const char* input
    ) {
        const auto byte = static_cast<uint8_t>(input[0]);
        const uint8_t upper = byte & 0xDFu;   // force upper for validation only
        const uint8_t x = (byte >> 1u) & 3u;  // A=0, C=1, T=2, G=3
        const uint8_t valid = (upper == 'A') | (upper == 'C') | (upper == 'G') | (upper == 'T');
        const uint8_t mask = -valid;
        return (x & mask) | (invalidSymbol & ~mask);
    }
};
 
struct DnaTripletAlphabet {
    static constexpr uint64_t symbolWidth = 3;
    static constexpr uint64_t symbolCount = 64;
    static constexpr uint8_t invalidSymbol = 0xFFu;
    static constexpr uint8_t separator = 'N';
    static constexpr char validBytes[] = "ACGT";
 
    [[nodiscard]] constexpr __host__ __device__ __forceinline__ static uint8_t encode(
        const char* input
    ) {
        const uint8_t a = DnaAlphabet::encode(input + 0);
        const uint8_t b = DnaAlphabet::encode(input + 1);
        const uint8_t c = DnaAlphabet::encode(input + 2);
        const uint8_t valid = (a != invalidSymbol) & (b != invalidSymbol) & (c != invalidSymbol);
        const uint8_t packed = (a << 4u) | (b << 2u) | c;
        const uint8_t mask = -valid;
        return (packed & mask) | (invalidSymbol & ~mask);
    }
};
 
struct ProteinAlphabet {
    static constexpr uint64_t symbolWidth = 1;
    static constexpr uint64_t symbolCount = 26;
    static constexpr uint8_t invalidSymbol = 0xFFu;
    static constexpr uint8_t separator = '*';
    static constexpr char validBytes[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
    [[nodiscard]] constexpr __host__ __device__ __forceinline__ static uint8_t encode(
        const char* input
    ) {
        const auto byte = static_cast<uint8_t>(input[0]);
        const uint8_t upper = byte & 0xDFu;
        const uint8_t letterIndex = upper - 'A';
        const uint8_t valid = letterIndex < 26;
        const uint8_t mask = -valid;
        return (letterIndex & mask) | (invalidSymbol & ~mask);
    }
};
 
}  // namespace cusbf