scoring_scheme_base.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, 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.md
// -----------------------------------------------------------------------------------------------------

#pragma once

#include <range/v3/algorithm/copy.hpp>

#include <seqan3/alphabet/concept.hpp>
#include <seqan3/core/concept/cereal.hpp>
#include <seqan3/core/detail/strong_type.hpp>
#include <seqan3/range/shortcuts.hpp>
#include <seqan3/std/algorithm>

#if SEQAN3_WITH_CEREAL
#include <cereal/types/array.hpp>
#endif // SEQAN3_WITH_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;
};

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;
};

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 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();
    }

    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(matrix_type const & _matrix) noexcept
    {
        set_custom_matrix(_matrix);
    }

public:
    constexpr void set_hamming_distance() noexcept
    {
        set_simple_scheme(match_score<score_t>{0}, mismatch_score<score_t>{-1});
    }

    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_custom_matrix(matrix_type const & _matrix) noexcept
    {
        std::ranges::copy(_matrix, begin(matrix));
    }

    template <ExplicitlyConvertibleTo<alphabet_t> alph1_t,
              ExplicitlyConvertibleTo<alphabet_t> alph2_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))];
    }

    template <ExplicitlyConvertibleTo<alphabet_t> alph1_t, ExplicitlyConvertibleTo<alphabet_t> alph2_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 bool operator==(derived_t const & rhs) const noexcept
    {
        return matrix == rhs.matrix;
    }

    constexpr bool operator!=(derived_t const & rhs) const noexcept
    {
        return matrix != rhs.matrix;
    }

    template <CerealArchive archive_t>
    void CEREAL_SERIALIZE_FUNCTION_NAME(archive_t & archive)
    {
        archive(matrix);
    }

private:
    matrix_type matrix{};
};

} // namespace seqan3