edit_distance_trace_matrix_full.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 <bitset>
 
#include <seqan3/alignment/matrix/trace_directions.hpp>
#include <seqan3/alignment/pairwise/edit_distance_fwd.hpp>
#include <seqan3/core/bit_manipulation.hpp>
 
namespace seqan3::detail
{
 
template <typename word_t, bool is_semi_global, bool use_max_errors>
class edit_distance_trace_matrix_full
{
public:
    template <std::ranges::viewable_range database_t,
              std::ranges::viewable_range query_t,
              typename align_config_t,
              typename edit_traits>
    friend class edit_distance_unbanded;
 
     edit_distance_trace_matrix_full() = default;                                                    
     edit_distance_trace_matrix_full(edit_distance_trace_matrix_full const &) = default;             
     edit_distance_trace_matrix_full(edit_distance_trace_matrix_full &&) = default;                  
     edit_distance_trace_matrix_full & operator=(edit_distance_trace_matrix_full const &) = default; 
     edit_distance_trace_matrix_full & operator=(edit_distance_trace_matrix_full &&) = default;      
     ~edit_distance_trace_matrix_full() = default;                                                   
 
 protected:
     template <typename derived_t, typename edit_traits>
     friend class edit_distance_unbanded_trace_matrix_policy;
 
     edit_distance_trace_matrix_full(size_t const rows_size)
         : rows_size{rows_size}, columns{}
     {}
 
public:
    using word_type = word_t;
 
    static constexpr auto word_size = sizeof_bits<word_type>;
 
    using value_type = detail::trace_directions;
 
    using reference = value_type;
 
    using size_type = size_t;
 
    void reserve(size_t const new_capacity)
    {
        columns.reserve(new_capacity);
    }
 
public:
    reference at(matrix_coordinate const & coordinate) const noexcept
    {
        size_t row = coordinate.row;
        size_t col = coordinate.col;
 
        assert(row < rows());
        assert(col < cols());
 
        column_type const & column = columns[col];
 
        if constexpr(use_max_errors)
            if (!(row < column.max_rows))
                return detail::trace_directions::none;
 
        if (row == 0u)
        {
            if constexpr(is_semi_global)
                return detail::trace_directions::none;
 
            if (col == 0u)
                return detail::trace_directions::none;
 
            return detail::trace_directions::left;
        }
 
        size_t const idx = (row - 1u) / word_size;
        size_t const offset = (row - 1u) % word_size;
 
        bool const left = std::bitset<word_size>(column.left[idx])[offset];
        bool const diagonal = std::bitset<word_size>(column.diagonal[idx])[offset];
        bool const up = std::bitset<word_size>(column.up[idx])[offset];
 
        auto const dir = (left ? detail::trace_directions::left : detail::trace_directions::none) |
                         (diagonal ? detail::trace_directions::diagonal : detail::trace_directions::none) |
                         (up ? detail::trace_directions::up : detail::trace_directions::none);
 
        return dir;
    }
 
    size_t rows() const noexcept
    {
        return rows_size;
    }
 
    size_t cols() const noexcept
    {
        return columns.size();
    }
 
protected:
    struct max_errors_state
    {
        size_t max_rows{};
    };
 
    struct trace_matrix_state
    {
        std::vector<word_type> left{};
        std::vector<word_type> diagonal{};
        std::vector<word_type> up{};
    };
 
    struct column_type :
        enable_state_t<true, trace_matrix_state>,
        enable_state_t<use_max_errors, max_errors_state>
    {};
 
    void add_column(std::vector<word_type> left, std::vector<word_type> diagonal, std::vector<word_type> up)
        requires (!use_max_errors)
    {
        column_type column{};
        column.left = std::move(left);
        column.diagonal = std::move(diagonal);
        column.up = std::move(up);
 
        columns.push_back(std::move(column));
    }
 
    void add_column(std::vector<word_type> left, std::vector<word_type> diagonal, std::vector<word_type> up,
                    size_t const max_rows)
        requires use_max_errors
    {
        column_type column{};
        column.left = std::move(left);
        column.diagonal = std::move(diagonal);
        column.up = std::move(up);
        column.max_rows = max_rows;
 
        columns.push_back(std::move(column));
    }
 
private:
    size_t rows_size{};
    std::vector<column_type> columns{};
};
 
} // namespace seqan3::detail