alignment_matrix_policy.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2026 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2026 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <limits>
#include <tuple>
 
#include <seqan3/alignment/configuration/align_config_band.hpp>
#include <seqan3/alignment/pairwise/detail/alignment_algorithm_state.hpp>
#include <seqan3/utility/type_traits/basic.hpp>
#include <seqan3/utility/views/slice.hpp>
#include <seqan3/utility/views/zip.hpp>
 
namespace seqan3::detail
{
 
template <typename alignment_algorithm_t, typename score_matrix_t, typename trace_matrix_t>
class alignment_matrix_policy
{
private:
    friend alignment_algorithm_t;
 
    constexpr alignment_matrix_policy() = default;                                            
    constexpr alignment_matrix_policy(alignment_matrix_policy const &) = default;             
    constexpr alignment_matrix_policy(alignment_matrix_policy &&) = default;                  
    constexpr alignment_matrix_policy & operator=(alignment_matrix_policy const &) = default; 
    constexpr alignment_matrix_policy & operator=(alignment_matrix_policy &&) = default;      
    ~alignment_matrix_policy() = default;                                                     
 
    template <typename configuration_t>
    alignment_matrix_policy(configuration_t const & /*config*/)
    {}
 
    template <typename sequence1_t, typename sequence2_t>
    constexpr void allocate_matrix(sequence1_t && sequence1, sequence2_t && sequence2)
    {
        score_matrix = score_matrix_t{sequence1, sequence2};
        trace_matrix = trace_matrix_t{sequence1, sequence2};
 
        initialise_matrix_iterator();
    }
 
    template <typename sequence1_t, typename sequence2_t, typename score_t>
    constexpr void allocate_matrix(sequence1_t && sequence1,
                                   sequence2_t && sequence2,
                                   align_cfg::band_fixed_size const & band,
                                   alignment_algorithm_state<score_t> const & state)
    {
        assert(state.gap_extension_score <= 0); // We expect it to never be positive.
 
        score_t inf = std::numeric_limits<score_t>::lowest() - state.gap_extension_score;
        score_matrix = score_matrix_t{sequence1, sequence2, band, inf};
        trace_matrix = trace_matrix_t{sequence1, sequence2, band};
 
        initialise_matrix_iterator();
    }
 
    constexpr void initialise_matrix_iterator() noexcept
    {
        score_matrix_iter = score_matrix.begin();
        trace_matrix_iter = trace_matrix.begin();
    }
 
    template <typename sequence1_t, typename sequence2_t>
    constexpr auto
    slice_sequences(sequence1_t & sequence1, sequence2_t & sequence2, align_cfg::band_fixed_size const & band) noexcept
    {
        size_t seq1_size = std::ranges::distance(sequence1);
        size_t seq2_size = std::ranges::distance(sequence2);
 
        auto trim_sequence1 = [&]() constexpr
        {
            seq1_slice_offset = std::max<std::ptrdiff_t>(band.lower_diagonal - 1, 0);
            size_t end_pos = std::min<std::ptrdiff_t>(band.upper_diagonal + seq2_size, seq1_size);
            return sequence1 | views::slice(seq1_slice_offset, end_pos);
        };
 
        auto trim_sequence2 = [&]() constexpr
        {
            seq2_slice_offset = std::abs(std::min<std::ptrdiff_t>(band.upper_diagonal + 1, 0));
            size_t end_pos = std::min<std::ptrdiff_t>(seq1_size - band.lower_diagonal, seq2_size);
            return sequence2 | views::slice(seq2_slice_offset, end_pos);
        };
 
        return std::tuple{trim_sequence1(), trim_sequence2()};
    }
 
    constexpr auto current_alignment_column() noexcept
    {
        assert(!std::ranges::empty(*score_matrix_iter));
        assert(!std::ranges::empty(*trace_matrix_iter));
 
        return views::zip(*score_matrix_iter, *trace_matrix_iter);
    }
 
    constexpr void next_alignment_column() noexcept
    {
        ++score_matrix_iter;
        ++trace_matrix_iter;
    }
 
    constexpr size_t to_original_sequence1_position(size_t position) const noexcept
    {
        return position + seq1_slice_offset;
    }
 
    constexpr size_t to_original_sequence2_position(size_t position) const noexcept
    {
        return position + seq2_slice_offset;
    }
 
    score_matrix_t score_matrix{}; 
    trace_matrix_t trace_matrix{}; 
 
    typename score_matrix_t::iterator score_matrix_iter{}; 
    typename trace_matrix_t::iterator trace_matrix_iter{}; 
 
    size_t seq1_slice_offset{}; 
    size_t seq2_slice_offset{}; 
};
} // namespace seqan3::detail