gap_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.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <seqan3/core/concept/cereal.hpp>
#include <seqan3/core/concept/core_language.hpp>
#include <seqan3/core/detail/strong_type.hpp>
#include <seqan3/std/concepts>
 
namespace seqan3
{
 
// ------------------------------------------------------------------
// seqan3::gap_score
// ------------------------------------------------------------------
 
template <arithmetic score_type>
struct gap_score : detail::strong_type<score_type, gap_score<score_type>, detail::strong_type_skill::convert>
{
     using detail::strong_type<score_type, gap_score<score_type>, detail::strong_type_skill::convert>::strong_type;
};
 
template <arithmetic score_type>
gap_score(score_type) -> gap_score<score_type>;
 
// ------------------------------------------------------------------
// seqan3::gap_open_score
// ------------------------------------------------------------------
 
template <arithmetic score_type>
struct gap_open_score : detail::strong_type<score_type, gap_open_score<score_type>, detail::strong_type_skill::convert>
{
     using detail::strong_type<score_type, gap_open_score<score_type>, detail::strong_type_skill::convert>::strong_type;
};
 
template <arithmetic score_type>
gap_open_score(score_type) -> gap_open_score<score_type>;
 
// ------------------------------------------------------------------
// seqan3::gap_scheme
// ------------------------------------------------------------------
 
template <arithmetic score_t = int8_t>
class gap_scheme
{
public:
 
    using score_type = score_t;
 
    constexpr gap_scheme() noexcept = default;                               
    constexpr gap_scheme(gap_scheme const &) noexcept = default;             
    constexpr gap_scheme(gap_scheme &&) noexcept = default;                  
    constexpr gap_scheme & operator=(gap_scheme const &) noexcept = default; 
    constexpr gap_scheme & operator=(gap_scheme &&) noexcept = default;      
    ~gap_scheme() noexcept = default;                                        
 
    template <arithmetic score_arg_t>
    constexpr gap_scheme(gap_score<score_arg_t> const g, gap_open_score<score_arg_t> const go)
    {
        set_affine(g, go);
    }
 
    template <arithmetic score_arg_t>
    constexpr gap_scheme(gap_score<score_arg_t> const g)
    {
        set_linear(g);
    }
 
    template <arithmetic score_arg_t>
    constexpr void set_affine(gap_score<score_arg_t> const g, gap_open_score<score_arg_t> const go)
    {
        std::conditional_t<std::integral<score_t>, int64_t, double> i_g = static_cast<score_arg_t>(g);
        std::conditional_t<std::integral<score_t>, int64_t, double> i_go = static_cast<score_arg_t>(go);
        if ((i_g  < std::numeric_limits<score_t>::lowest() || i_g  > std::numeric_limits<score_t>::max()) ||
            (i_go < std::numeric_limits<score_t>::lowest() || i_go > std::numeric_limits<score_t>::max()))
        {
            throw std::invalid_argument{"You passed a score value to set_affine/set_linear that is out of range of the "
                                        "scoring scheme's underlying type. Define your scoring scheme with a larger "
                                        "template parameter or down-cast your score value beforehand to prevent "
                                        "this exception."};
        }
 
        gap = static_cast<score_arg_t>(g);
        gap_open = static_cast<score_arg_t>(go);
    }
 
    template <arithmetic score_arg_t>
    constexpr void set_linear(gap_score<score_arg_t> const g)
    {
        set_affine(g, gap_open_score<score_arg_t>{0});
    }
 
    constexpr score_t & get_gap_score() noexcept
    {
        return gap;
    }
 
    constexpr score_t get_gap_score() const noexcept
    {
        return gap;
    }
 
    constexpr score_t & get_gap_open_score() noexcept
    {
        return gap_open;
    }
 
    constexpr score_t get_gap_open_score() const noexcept
    {
        return gap_open;
    }
 
    constexpr ptrdiff_t score(size_t const number_of_consecutive_gaps) const noexcept
    {
        return (gap_open * (number_of_consecutive_gaps ? 1 : 0)) + number_of_consecutive_gaps * gap;
    }
 
    constexpr bool operator==(gap_scheme const & rhs) const noexcept
    {
        return std::tie(gap, gap_open) == std::tie(rhs.gap, rhs.gap_open);
    }
 
    constexpr bool operator!=(gap_scheme const & rhs) const noexcept
    {
        return !(*this == rhs);
    }
 
    template <cereal_archive archive_t>
    void CEREAL_SERIALIZE_FUNCTION_NAME(archive_t & archive)
    {
        archive(gap);
        archive(gap_open);
    }
 
private:
    score_t gap = -1;
    score_t gap_open = 0;
};
 
gap_scheme() -> gap_scheme<int8_t>;
 
template <floating_point score_arg_type>
gap_scheme(gap_score<score_arg_type>, gap_open_score<score_arg_type>) -> gap_scheme<float>;
 
template <floating_point score_arg_type>
gap_scheme(gap_score<score_arg_type>) -> gap_scheme<float>;
 
template <arithmetic score_arg_type>
gap_scheme(gap_score<score_arg_type>, gap_open_score<score_arg_type>) -> gap_scheme<int8_t>;
 
template <arithmetic score_arg_type>
gap_scheme(gap_score<score_arg_type>) -> gap_scheme<int8_t>;
 
} // namespace seqan3