simd_matrix_scoring_scheme.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <seqan3/alignment/configuration/align_config_mode.hpp>
#include <seqan3/alignment/scoring/scoring_scheme_concept.hpp>
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/core/concept/cereal.hpp>
#include <seqan3/core/simd/concept.hpp>
#include <seqan3/core/simd/simd_algorithm.hpp>
#include <seqan3/std/concepts>
 
namespace seqan3::detail
{
 
template <simd_concept simd_score_t, semialphabet alphabet_t, typename alignment_t, typename scoring_scheme_t>
    requires scoring_scheme<scoring_scheme_t, alphabet_t> &&
             (std::same_as<alignment_t, detail::local_alignment_type> ||
              std::same_as<alignment_t, detail::global_alignment_type>)
class simd_matrix_scoring_scheme
{
public:
    constexpr simd_matrix_scoring_scheme() = default; 
    constexpr simd_matrix_scoring_scheme(simd_matrix_scoring_scheme const &) = default; 
    constexpr simd_matrix_scoring_scheme(simd_matrix_scoring_scheme &&) = default; 
    constexpr simd_matrix_scoring_scheme & operator=(simd_matrix_scoring_scheme const &) = default; 
    constexpr simd_matrix_scoring_scheme & operator=(simd_matrix_scoring_scheme &&) = default; 
    ~simd_matrix_scoring_scheme() = default; 
 
    constexpr explicit simd_matrix_scoring_scheme(scoring_scheme_t const & scoring_scheme)
    {
        initialise_from_scalar_scoring_scheme(scoring_scheme);
    }
 
    constexpr simd_matrix_scoring_scheme & operator=(scoring_scheme_t const & scoring_scheme)
    {
        initialise_from_scalar_scoring_scheme(scoring_scheme);
        return *this;
    }
 
    constexpr simd_score_t score(simd_score_t const & lhs, simd_score_t const & rhs) const noexcept
    {
        simd_score_t result{};
 
        for (size_t i = 0; i < simd_traits<simd_score_t>::length; ++i)
        {
            if (is_padded(lhs[i]) || is_padded(rhs[i]))
            {
                if constexpr (std::same_as<alignment_t, detail::global_alignment_type>)
                    result[i] = 1;
                else
                    result[i] = -1;
            }
            else
            {
                result[i] = internal_scoring_scheme.score(assign_rank_to(lhs[i], alphabet_t{}),
                                                          assign_rank_to(rhs[i], alphabet_t{}));
            }
        }
 
        return result;
    }
 
    constexpr typename scoring_scheme_t::score_type padding_match_score() noexcept
    {
        return 1;
    }
 
private:
    scoring_scheme_t internal_scoring_scheme;
 
    constexpr void initialise_from_scalar_scoring_scheme(scoring_scheme_t const & scoring_scheme)
    {
        using score_t = decltype(std::declval<scoring_scheme_t const &>().score(alphabet_t{}, alphabet_t{}));
        using simd_scalar_t = typename simd_traits<simd_score_t>::scalar_type;
 
        // Check if the scoring scheme match and mismatch scores do not overflow with the respective scalar type.
        if constexpr (sizeof(simd_scalar_t) < sizeof(score_t))
        {
            if (min_or_max_exceeded<score_t, simd_scalar_t>(scoring_scheme))
                throw std::invalid_argument{"The selected scoring scheme score overflows "
                                            "for the selected scalar type of the simd type."};
        }
 
        internal_scoring_scheme = scoring_scheme;
    }
 
    template <typename score_t, typename simd_scalar_t>
    constexpr bool min_or_max_exceeded(scoring_scheme_t const & scoring_scheme)
    {
        score_t max_val = static_cast<score_t>(std::numeric_limits<simd_scalar_t>::max());
        score_t min_val = static_cast<score_t>(std::numeric_limits<simd_scalar_t>::lowest());
 
        for (uint8_t i = 0; i < alphabet_size<alphabet_t>; ++i)
        {
            for (uint8_t j = 0; j < alphabet_size<alphabet_t>; ++j)
            {
                score_t tmp_score = scoring_scheme.score(assign_rank_to(i, alphabet_t{}),
                                                         assign_rank_to(j, alphabet_t{}));
 
                if (tmp_score > max_val || tmp_score < min_val)
                    return true;
            }
        }
 
        return false;
    }
 
    constexpr bool is_padded(typename simd_traits<simd_score_t>::scalar_type const & value) const
    {
        using unsigned_scalar_t = typename std::make_unsigned<typename simd_traits<simd_score_t>::scalar_type>::type;
 
        return static_cast<unsigned_scalar_t>(value) >= alphabet_size<alphabet_t>;
    }
};
 
} // namespace seqan3::detail