scoring_scheme_base.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2025 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <algorithm>
 
#include <seqan3/alphabet/concept.hpp>
#include <seqan3/core/concept/cereal.hpp>
#include <seqan3/core/detail/strong_type.hpp>
#include <seqan3/utility/concept.hpp>
 
#if SEQAN3_HAS_CEREAL
#    include <cereal/types/array.hpp>
#endif // SEQAN3_HAS_CEREAL
 
namespace seqan3
{
 
// ------------------------------------------------------------------
// seqan3::match_score
// ------------------------------------------------------------------
 
template <arithmetic score_type>
struct match_score : detail::strong_type<score_type, match_score<score_type>, detail::strong_type_skill::convert>
{
    using detail::strong_type<score_type, match_score<score_type>, detail::strong_type_skill::convert>::strong_type;
};
struct match_score : detail::strong_type<score_type, match_score<score_type>, detail::strong_type_skill::convert> {…};
 
template <arithmetic score_type>
match_score(score_type) -> match_score<score_type>;
 
// ------------------------------------------------------------------
// seqan3::mismatch_score
// ------------------------------------------------------------------
 
template <arithmetic score_type>
struct mismatch_score : detail::strong_type<score_type, mismatch_score<score_type>, detail::strong_type_skill::convert>
{
    using detail::strong_type<score_type, mismatch_score<score_type>, detail::strong_type_skill::convert>::strong_type;
};
struct mismatch_score : detail::strong_type<score_type, mismatch_score<score_type>, detail::strong_type_skill::convert> {…};
 
template <arithmetic score_type>
mismatch_score(score_type) -> mismatch_score<score_type>;
 
// ------------------------------------------------------------------
// seqan3::scoring_scheme_base
// ------------------------------------------------------------------
 
template <typename derived_t, alphabet alphabet_t, arithmetic score_t>
class scoring_scheme_base
{
public:
    using score_type = score_t;
    using alphabet_type = alphabet_t;
    using matrix_size_type = std::remove_const_t<decltype(alphabet_size<alphabet_t>)>;
 
    static constexpr matrix_size_type matrix_size = alphabet_size<alphabet_t>;
 
    using matrix_type = std::array<std::array<score_type, matrix_size>, matrix_size>;
 
private:
    friend derived_t;
 
 
    constexpr scoring_scheme_base(scoring_scheme_base const &) noexcept = default;             
    constexpr scoring_scheme_base(scoring_scheme_base &&) noexcept = default;                  
    constexpr scoring_scheme_base & operator=(scoring_scheme_base const &) noexcept = default; 
    constexpr scoring_scheme_base & operator=(scoring_scheme_base &&) noexcept = default;      
    ~scoring_scheme_base() noexcept = default;                                                 
 
    constexpr scoring_scheme_base() noexcept
    {
        set_hamming_distance();
    }
    constexpr scoring_scheme_base() noexcept {…}
 
    template <arithmetic score_arg_t>
    constexpr scoring_scheme_base(match_score<score_arg_t> const ms, mismatch_score<score_arg_t> const mms)
    {
        set_simple_scheme(ms, mms);
    }
    constexpr scoring_scheme_base(match_score<score_arg_t> const ms, mismatch_score<score_arg_t> const mms) {…}
 
    constexpr scoring_scheme_base(matrix_type const & matrix) noexcept
    {
        set_custom_matrix(matrix);
    }
    constexpr scoring_scheme_base(matrix_type const & matrix) noexcept {…}
 
public:
    constexpr void set_hamming_distance() noexcept
    {
        set_simple_scheme(match_score<score_t>{0}, mismatch_score<score_t>{-1});
    }
    constexpr void set_hamming_distance() noexcept {…}
 
    template <arithmetic score_arg_t>
    constexpr void set_simple_scheme(match_score<score_arg_t> const ms, mismatch_score<score_arg_t> const mms)
    {
        std::conditional_t<std::integral<score_t>, int64_t, double> i_ms = static_cast<score_arg_t>(ms);
        std::conditional_t<std::integral<score_t>, int64_t, double> i_mms = static_cast<score_arg_t>(mms);
        if ((i_ms < std::numeric_limits<score_t>::lowest() || i_ms > std::numeric_limits<score_t>::max())
            || (i_mms < std::numeric_limits<score_t>::lowest() || i_mms > std::numeric_limits<score_t>::max()))
        {
            throw std::invalid_argument{"You passed a score value to set_simple_scheme that is out of range of the "
                                        "scoring scheme's underlying type. Define your scoring scheme with a larger "
                                        "template parameter or down-cast you score value beforehand to prevent "
                                        "this exception."};
        }
 
        for (matrix_size_type i = 0; i < matrix_size; ++i)
            for (matrix_size_type j = 0; j < matrix_size; ++j)
                matrix[i][j] = (i == j) ? static_cast<score_t>(i_ms) : static_cast<score_t>(i_mms);
    }
    constexpr void set_simple_scheme(match_score<score_arg_t> const ms, mismatch_score<score_arg_t> const mms) {…}
 
    constexpr void set_custom_matrix(matrix_type const & matrix) noexcept
    {
        std::ranges::copy(matrix, this->matrix.begin());
    }
    constexpr void set_custom_matrix(matrix_type const & matrix) noexcept {…}
 
    template <typename alph1_t, typename alph2_t>
        requires explicitly_convertible_to<alph1_t, alphabet_t> && explicitly_convertible_to<alph2_t, alphabet_t>
    constexpr score_t & score(alph1_t const alph1, alph2_t const alph2) noexcept
    {
        return matrix[to_rank(static_cast<alphabet_t>(alph1))][to_rank(static_cast<alphabet_t>(alph2))];
    }
    constexpr score_t & score(alph1_t const alph1, alph2_t const alph2) noexcept {…}
 
    template <typename alph1_t, typename alph2_t>
        requires explicitly_convertible_to<alph1_t, alphabet_t> && explicitly_convertible_to<alph2_t, alphabet_t>
    constexpr score_t score(alph1_t const alph1, alph2_t const alph2) const noexcept
    {
        return matrix[to_rank(static_cast<alphabet_t>(alph1))][to_rank(static_cast<alphabet_t>(alph2))];
    }
    constexpr score_t score(alph1_t const alph1, alph2_t const alph2) const noexcept {…}
 
 
    constexpr bool operator==(derived_t const & rhs) const noexcept
    {
        return matrix == rhs.matrix;
    }
    constexpr bool operator==(derived_t const & rhs) const noexcept {…}
 
    constexpr bool operator!=(derived_t const & rhs) const noexcept
    {
        return matrix != rhs.matrix;
    }
    constexpr bool operator!=(derived_t const & rhs) const noexcept {…}
 
    template <cereal_archive archive_t>
    void CEREAL_SERIALIZE_FUNCTION_NAME(archive_t & archive)
    {
        archive(matrix);
    }
 
private:
    matrix_type matrix{};
};
class scoring_scheme_base {…};
 
} // namespace seqan3