29 namespace seqan3::detail
34 template <
typename derived_t,
typename edit_traits>
35 class edit_distance_unbanded_max_errors_policy :
41 static_assert(edit_traits::use_max_errors,
"This policy assumes that edit_traits::use_max_errors is true.");
49 edit_distance_unbanded_max_errors_policy() noexcept = default;
50 edit_distance_unbanded_max_errors_policy(edit_distance_unbanded_max_errors_policy const &) noexcept
52 edit_distance_unbanded_max_errors_policy(edit_distance_unbanded_max_errors_policy &&) noexcept
54 edit_distance_unbanded_max_errors_policy & operator=(edit_distance_unbanded_max_errors_policy const &) noexcept
56 edit_distance_unbanded_max_errors_policy & operator=(edit_distance_unbanded_max_errors_policy &&) noexcept
58 ~edit_distance_unbanded_max_errors_policy() noexcept = default;
62 using typename edit_traits::word_type;
63 using typename edit_traits::score_type;
70 score_type max_errors{255};
72 size_t last_block{0u};
74 word_type last_score_mask{};
82 void max_errors_init(
size_t block_count) noexcept
84 derived_t *
self =
static_cast<derived_t *
>(
this);
86 max_errors = -get<align_cfg::min_score>(self->config).score;
88 assert(max_errors >= score_type{0});
90 if (std::ranges::empty(self->query))
93 self->score_mask = 0u;
94 last_score_mask =
self->score_mask;
98 last_block = block_count - 1u;
99 last_score_mask =
self->score_mask;
104 size_t const local_max_errors = std::min<size_t>(max_errors,
std::ranges::size(self->query) - 1u);
105 self->score_mask = word_type{1u} << (local_max_errors %
self->word_size);
106 last_block =
std::min(local_max_errors / self->word_size, last_block);
107 self->_score = local_max_errors + 1u;
111 bool is_last_active_cell_within_last_row() const noexcept
113 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
114 return (self->score_mask == this->last_score_mask) && (this->last_block ==
self->vp.size() - 1u);
118 bool prev_last_active_cell() noexcept
120 derived_t *
self =
static_cast<derived_t *
>(
this);
121 self->score_mask >>= 1u;
122 if (self->score_mask != 0u)
125 if constexpr (edit_traits::is_global)
127 if (last_block == 0u)
133 self->score_mask = word_type{1u} << (edit_traits::word_size - 1u);
138 void next_last_active_cell() noexcept
140 derived_t *
self =
static_cast<derived_t *
>(
this);
141 self->score_mask <<= 1u;
142 if (self->score_mask)
145 self->score_mask = 1u;
152 bool update_last_active_cell() noexcept
154 derived_t *
self =
static_cast<derived_t *
>(
this);
156 while (!(self->_score <= max_errors))
158 self->advance_score(self->vn[last_block], self->vp[last_block], self->score_mask);
159 if (!prev_last_active_cell())
162 assert(edit_traits::is_global);
165 return !edit_traits::compute_matrix;
169 if (is_last_active_cell_within_last_row())
171 assert(self->_score <= max_errors);
173 if constexpr(edit_traits::is_semi_global)
174 self->update_best_score();
176 return self->on_hit();
180 next_last_active_cell();
181 self->advance_score(self->vp[last_block], self->vn[last_block], self->score_mask);
189 static size_t max_rows(word_type
const score_mask,
unsigned const last_block,
190 score_type
const score, score_type
const max_errors) noexcept
192 using score_matrix_type =
typename edit_traits::score_matrix_type;
193 return score_matrix_type::max_rows(score_mask,
203 template <
typename derived_t,
typename edit_traits>
204 class edit_distance_unbanded_global_policy :
210 static_assert(edit_traits::is_global || edit_traits::is_semi_global,
211 "This policy assumes that edit_traits::is_global or edit_traits::is_semi_global is true.");
219 edit_distance_unbanded_global_policy() noexcept = default;
220 edit_distance_unbanded_global_policy(edit_distance_unbanded_global_policy const &) noexcept
222 edit_distance_unbanded_global_policy(edit_distance_unbanded_global_policy &&) noexcept
224 edit_distance_unbanded_global_policy & operator=(edit_distance_unbanded_global_policy const &) noexcept
226 edit_distance_unbanded_global_policy & operator=(edit_distance_unbanded_global_policy &&) noexcept
228 ~edit_distance_unbanded_global_policy() noexcept = default;
233 using typename edit_traits::score_type;
243 score_type _best_score{};
251 void score_init() noexcept
253 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
254 _best_score =
self->_score;
258 bool is_valid() const noexcept
260 [[maybe_unused]] derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
265 if constexpr(edit_traits::use_max_errors)
266 return _best_score <=
self->max_errors;
274 alignment_coordinate invalid_coordinate() const noexcept
276 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
281 void update_best_score() noexcept
283 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
284 _best_score =
self->_score;
288 size_t end_positions_first() const noexcept
290 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
304 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
305 static_assert(edit_traits::compute_score,
"score() can only be computed if you specify the result type within "
306 "your alignment config.");
307 if (!self->is_valid())
315 alignment_coordinate end_positions() const noexcept
317 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
318 static_assert(edit_traits::compute_end_positions,
"end_positions() can only be computed if you specify the "
319 "result type within your alignment config.");
320 if (!self->is_valid())
321 return self->invalid_coordinate();
323 column_index_type
const first{
self->end_positions_first()};
325 return {first, second};
331 template <
typename derived_t,
typename edit_traits>
332 class edit_distance_unbanded_semi_global_policy :
333 public edit_distance_unbanded_global_policy<derived_t, edit_traits>
336 static_assert(edit_traits::is_semi_global,
"This policy assumes that edit_traits::is_semi_global is true.");
344 edit_distance_unbanded_semi_global_policy() noexcept = default;
345 edit_distance_unbanded_semi_global_policy(edit_distance_unbanded_semi_global_policy const &) noexcept
347 edit_distance_unbanded_semi_global_policy(edit_distance_unbanded_semi_global_policy &&) noexcept
349 edit_distance_unbanded_semi_global_policy & operator=(edit_distance_unbanded_semi_global_policy const &) noexcept
351 edit_distance_unbanded_semi_global_policy & operator=(edit_distance_unbanded_semi_global_policy &&) noexcept
353 ~edit_distance_unbanded_semi_global_policy() noexcept = default;
358 using base_t = edit_distance_unbanded_global_policy<derived_t, edit_traits>;
360 using database_iterator = typename edit_traits::database_iterator;
361 using base_t::_best_score;
375 database_iterator _best_score_col{};
383 void score_init() noexcept
385 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
386 base_t::score_init();
387 _best_score_col =
self->database_it_end;
391 void update_best_score() noexcept
393 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
395 if constexpr(edit_traits::use_max_errors)
397 assert(std::ranges::empty(self->query) || self->is_last_active_cell_within_last_row());
400 _best_score_col = (
self->_score <= _best_score) ? self->database_it : _best_score_col;
401 _best_score = (self->_score <= _best_score) ?
self->_score : _best_score;
405 size_t end_positions_first() const noexcept
407 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
409 size_t offset = std::ranges::empty(self->database) ? 0u : 1u;
410 return std::ranges::distance(std::ranges::begin(self->database), _best_score_col) +
offset;
418 template <
typename derived_t,
typename edit_traits>
419 class edit_distance_unbanded_score_matrix_policy :
425 static_assert(edit_traits::compute_score_matrix,
426 "This policy assumes that edit_traits::compute_score_matrix is true.");
434 edit_distance_unbanded_score_matrix_policy() noexcept = default;
435 edit_distance_unbanded_score_matrix_policy(edit_distance_unbanded_score_matrix_policy const &) noexcept
437 edit_distance_unbanded_score_matrix_policy(edit_distance_unbanded_score_matrix_policy &&) noexcept
439 edit_distance_unbanded_score_matrix_policy & operator=(edit_distance_unbanded_score_matrix_policy const &) noexcept
441 edit_distance_unbanded_score_matrix_policy & operator=(edit_distance_unbanded_score_matrix_policy &&) noexcept
443 ~edit_distance_unbanded_score_matrix_policy() noexcept = default;
447 using typename edit_traits::score_matrix_type;
454 score_matrix_type _score_matrix{};
469 void score_matrix_init()
471 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
486 score_matrix_type
const & score_matrix() const noexcept
488 static_assert(edit_traits::compute_score_matrix,
"score_matrix() can only be computed if you specify the "
489 "result type within your alignment config.");
490 return _score_matrix;
498 template <
typename derived_t,
typename edit_traits>
499 class edit_distance_unbanded_trace_matrix_policy :
505 static_assert(edit_traits::compute_trace_matrix,
506 "This policy assumes that edit_traits::compute_trace_matrix is true.");
514 edit_distance_unbanded_trace_matrix_policy() noexcept = default;
515 edit_distance_unbanded_trace_matrix_policy(edit_distance_unbanded_trace_matrix_policy const &) noexcept
517 edit_distance_unbanded_trace_matrix_policy(edit_distance_unbanded_trace_matrix_policy &&) noexcept
519 edit_distance_unbanded_trace_matrix_policy & operator=(edit_distance_unbanded_trace_matrix_policy const &) noexcept
521 edit_distance_unbanded_trace_matrix_policy & operator=(edit_distance_unbanded_trace_matrix_policy &&) noexcept
523 ~edit_distance_unbanded_trace_matrix_policy() noexcept = default;
527 using typename edit_traits::word_type;
528 using typename edit_traits::trace_matrix_type;
529 using typename edit_traits::alignment_result_type;
536 std::vector<word_type> hp{};
541 trace_matrix_type _trace_matrix{};
556 void trace_matrix_init(
size_t block_count)
558 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
563 hp.resize(block_count, 0u);
564 db.resize(block_count, 0u);
574 trace_matrix_type
const & trace_matrix() const noexcept
576 static_assert(edit_traits::compute_trace_matrix,
"trace_matrix() can only be computed if you specify the "
577 "result type within your alignment config.");
578 return _trace_matrix;
583 alignment_coordinate begin_positions() const noexcept
585 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
586 static_assert(edit_traits::compute_begin_positions,
"begin_positions() can only be computed if you specify the "
587 "result type within your alignment config.");
588 if (!self->is_valid())
589 return self->invalid_coordinate();
591 alignment_coordinate
const back =
self->end_positions();
592 auto trace_path =
self->trace_matrix().trace_path(
back);
594 std::ranges::advance(trace_path_it, std::ranges::end(trace_path));
595 matrix_coordinate coordinate = trace_path_it.coordinate();
596 return {column_index_type{coordinate.col}, row_index_type{coordinate.row}};
605 derived_t
const *
self =
static_cast<derived_t
const *
>(
this);
606 static_assert(edit_traits::compute_sequence_alignment,
"alignment() can only be computed if you specify the "
607 "result type within your alignment config.");
609 if (!self->is_valid())
610 return alignment_t{};
612 alignment_coordinate
const back =
self->end_positions();
613 aligned_sequence_builder builder{
self->database,
self->query};
614 auto trace_path =
self->trace_matrix().trace_path(
back);
615 return builder(trace_path).alignment;
623 template <
typename value_t>
624 class proxy_reference
630 proxy_reference() noexcept = default;
631 proxy_reference(proxy_reference const &) noexcept = default;
632 proxy_reference(proxy_reference &&) noexcept = default;
633 proxy_reference & operator=(proxy_reference const &) noexcept = default;
634 proxy_reference & operator=(proxy_reference &&) noexcept = default;
635 ~proxy_reference() = default;
638 proxy_reference(value_t & t) noexcept
639 : ptr(
std::addressof(t))
642 proxy_reference(value_t &&) =
delete;
645 template <
typename other_value_t>
647 requires std::convertible_to<other_value_t, value_t>
649 proxy_reference & operator=(other_value_t && u) noexcept
651 get() = std::forward<other_value_t>(u);
657 value_t &
get() const noexcept
659 assert(ptr !=
nullptr);
664 operator value_t & ()
const noexcept
671 value_t * ptr{
nullptr};
685 template <std::ranges::viewable_range database_t,
686 std::ranges::viewable_range query_t,
687 typename align_config_t,
688 typename edit_traits>
689 class edit_distance_unbanded :
692 public edit_distance_base<
693 edit_traits::use_max_errors,
694 edit_distance_unbanded_max_errors_policy,
696 edit_distance_unbanded<database_t, query_t, align_config_t, edit_traits>>,
697 public edit_distance_base<
698 edit_traits::is_global,
699 edit_distance_unbanded_global_policy,
701 edit_distance_unbanded<database_t, query_t, align_config_t, edit_traits>>,
702 public edit_distance_base<
703 edit_traits::is_semi_global,
704 edit_distance_unbanded_semi_global_policy,
706 edit_distance_unbanded<database_t, query_t, align_config_t, edit_traits>>,
707 public edit_distance_base<
708 edit_traits::compute_score_matrix,
709 edit_distance_unbanded_score_matrix_policy,
711 edit_distance_unbanded<database_t, query_t, align_config_t, edit_traits>>,
712 public edit_distance_base<
713 edit_traits::compute_trace_matrix,
714 edit_distance_unbanded_trace_matrix_policy,
716 edit_distance_unbanded<database_t, query_t, align_config_t, edit_traits>>
720 using typename edit_traits::word_type;
721 using typename edit_traits::score_type;
722 using typename edit_traits::database_type;
723 using typename edit_traits::query_type;
724 using typename edit_traits::align_config_type;
725 using edit_traits::word_size;
729 template <
typename other_derived_t,
typename other_edit_traits>
730 friend class edit_distance_unbanded_max_errors_policy;
732 template <
typename other_derived_t,
typename other_edit_traits>
733 friend class edit_distance_unbanded_global_policy;
735 template <
typename other_derived_t,
typename other_edit_traits>
736 friend class edit_distance_unbanded_semi_global_policy;
738 template <
typename other_derived_t,
typename other_edit_traits>
739 friend class edit_distance_unbanded_score_matrix_policy;
741 template <
typename other_derived_t,
typename other_edit_traits>
742 friend class edit_distance_unbanded_trace_matrix_policy;
744 using typename edit_traits::database_iterator;
745 using typename edit_traits::query_alphabet_type;
746 using typename edit_traits::alignment_result_type;
747 using edit_traits::use_max_errors;
748 using edit_traits::is_semi_global;
749 using edit_traits::is_global;
750 using edit_traits::compute_score;
751 using edit_traits::compute_end_positions;
752 using edit_traits::compute_begin_positions;
753 using edit_traits::compute_sequence_alignment;
754 using edit_traits::compute_score_matrix;
755 using edit_traits::compute_trace_matrix;
756 using edit_traits::compute_matrix;
757 using typename edit_traits::score_matrix_type;
758 using typename edit_traits::trace_matrix_type;
765 align_config_t config;
768 static constexpr word_type hp0 = is_global ? 1u : 0u;
770 static constexpr word_type hn0 = 0u;
772 static constexpr word_type vp0 = ~word_type{0u};
774 static constexpr word_type vn0 = 0u;
784 word_type score_mask{0u};
798 database_iterator database_it{};
800 database_iterator database_it_end{};
803 struct compute_state_trace_matrix
806 proxy_reference<word_type> db{};
810 struct compute_state : enable_state_t<edit_traits::compute_trace_matrix, compute_state_trace_matrix>
824 proxy_reference<word_type> vp{};
826 proxy_reference<word_type> vn{};
828 word_type carry_d0{};
830 word_type carry_hp{hp0};
832 word_type carry_hn{};
838 if constexpr(!use_max_errors && compute_score_matrix)
839 this->_score_matrix.add_column(vp, vn);
841 if constexpr(!use_max_errors && compute_trace_matrix)
842 this->_trace_matrix.add_column(this->hp, this->db, vp);
844 if constexpr(use_max_errors && compute_matrix)
846 size_t max_rows = this->max_rows(score_mask, this->last_block, _score, this->max_errors);
847 if constexpr(compute_score_matrix)
848 this->_score_matrix.add_column(vp, vn, max_rows);
850 if constexpr(compute_trace_matrix)
851 this->_trace_matrix.add_column(this->hp, this->db, vp, max_rows);
860 edit_distance_unbanded() =
delete;
861 edit_distance_unbanded(edit_distance_unbanded
const &) =
default;
862 edit_distance_unbanded(edit_distance_unbanded &&) =
default;
863 edit_distance_unbanded & operator=(edit_distance_unbanded
const &) =
default;
864 edit_distance_unbanded & operator=(edit_distance_unbanded &&) =
default;
865 ~edit_distance_unbanded() =
default;
873 edit_distance_unbanded(database_t _database,
875 align_config_t _config,
876 edit_traits
const & SEQAN3_DOXYGEN_ONLY(_traits)) :
877 database{
std::
forward<database_t>(_database)},
879 config{
std::
forward<align_config_t>(_config)},
880 _score{static_cast<score_type>(
std::ranges::
size(query))},
881 database_it{ranges::
begin(database)},
882 database_it_end{ranges::
end(database)}
884 static constexpr
size_t alphabet_size_ = alphabet_size<query_alphabet_type>;
886 size_t const block_count = (
std::ranges::size(query) - 1u + word_size) / word_size;
887 score_mask = word_type{1u} << ((
std::ranges::size(query) - 1u + word_size) % word_size);
890 if constexpr(use_max_errors)
891 this->max_errors_init(block_count);
893 if constexpr(compute_score_matrix)
894 this->score_matrix_init();
896 if constexpr(compute_trace_matrix)
897 this->trace_matrix_init(block_count);
899 vp.resize(block_count, vp0);
900 vn.resize(block_count, vn0);
901 bit_masks.resize((alphabet_size_ + 1u) * block_count, 0u);
906 size_t const i = block_count *
seqan3::to_rank(query[j]) + j / word_size;
907 bit_masks[i] |= word_type{1u} << (j % word_size);
916 template <
bool with_carry>
917 static void compute_step(compute_state & state) noexcept
920 assert(state.carry_d0 <= 1u);
921 assert(state.carry_hp <= 1u);
922 assert(state.carry_hn <= 1u);
924 x = state.b | state.vn;
925 t = state.vp + (x & state.vp) + state.carry_d0;
927 state.d0 = (t ^ state.vp) | x;
928 state.hn = state.vp & state.d0;
929 state.hp = state.vn | ~(state.vp | state.d0);
931 if constexpr(with_carry)
932 state.carry_d0 = (state.carry_d0 != 0u) ? t <= state.vp : t < state.vp;
934 x = (state.hp << 1u) | state.carry_hp;
935 state.vn = x & state.d0;
936 state.vp = (state.hn << 1u) | ~(x | state.d0) | state.carry_hn;
938 if constexpr(with_carry)
940 state.carry_hp = state.hp >> (word_size - 1u);
941 state.carry_hn = state.hn >> (word_size - 1u);
946 template <
bool with_carry>
947 void compute_kernel(compute_state & state,
size_t const block_offset,
size_t const current_block) noexcept
949 state.vp = proxy_reference<word_type>{this->vp[current_block]};
950 state.vn = proxy_reference<word_type>{this->vn[current_block]};
951 if constexpr(compute_trace_matrix)
953 state.hp = proxy_reference<word_type>{this->hp[current_block]};
954 state.db = proxy_reference<word_type>{this->db[current_block]};
956 state.b = bit_masks[block_offset + current_block];
958 compute_step<with_carry>(state);
959 if constexpr(compute_trace_matrix)
960 state.db = ~(state.b ^ state.d0);
964 void advance_score(word_type P, word_type N, word_type mask) noexcept
966 if ((P & mask) != word_type{0u})
968 else if ((N & mask) != word_type{0u})
973 bool on_hit() noexcept
980 inline bool small_patterns();
983 inline bool large_patterns();
986 inline void compute_empty_query_sequence()
988 assert(std::ranges::empty(query));
990 bool abort_computation =
false;
992 for (; database_it != database_it_end; ++database_it)
994 if constexpr(is_global)
997 this->update_best_score();
1000 if constexpr(use_max_errors)
1001 abort_computation = on_hit();
1004 if (abort_computation)
1013 if constexpr(use_max_errors && is_global && !compute_matrix)
1033 if (vp.size() == 0u)
1034 compute_empty_query_sequence();
1035 else if (vp.size() == 1u)
1040 if constexpr(is_global)
1041 this->update_best_score();
1049 template <
typename callback_t>
1050 void operator()([[maybe_unused]]
size_t const idx, callback_t && callback)
1052 using traits_type = alignment_configuration_traits<align_config_t>;
1053 using result_value_type =
typename alignment_result_value_type_accessor<alignment_result_type>::type;
1060 auto cached_end_positions = this->invalid_coordinate();
1061 auto cached_begin_positions = this->invalid_coordinate();
1063 if constexpr (compute_end_positions)
1064 cached_end_positions = this->end_positions();
1066 if constexpr (compute_begin_positions && !compute_sequence_alignment)
1068 static_assert(compute_end_positions,
"End positions required to compute the begin positions.");
1069 cached_begin_positions = this->begin_positions();
1075 result_value_type res_vt{};
1077 if constexpr (traits_type::output_sequence1_id)
1078 res_vt.sequence1_id = idx;
1080 if constexpr (traits_type::output_sequence2_id)
1081 res_vt.sequence2_id = idx;
1083 if constexpr (traits_type::compute_score)
1084 res_vt.score = this->score().value_or(matrix_inf<score_type>);
1086 if constexpr (traits_type::compute_sequence_alignment)
1088 if (this->is_valid())
1090 aligned_sequence_builder builder{this->database, this->query};
1091 auto trace_res = builder(this->trace_matrix().trace_path(cached_end_positions));
1092 res_vt.alignment =
std::move(trace_res.alignment);
1093 cached_begin_positions.first = trace_res.first_sequence_slice_positions.first;
1094 cached_begin_positions.second = trace_res.second_sequence_slice_positions.first;
1098 if constexpr (traits_type::compute_end_positions)
1099 res_vt.end_positions =
std::move(cached_end_positions);
1101 if constexpr (traits_type::compute_begin_positions)
1102 res_vt.begin_positions =
std::move(cached_begin_positions);
1104 callback(alignment_result_type{
std::move(res_vt)});
1108 template <
typename database_t,
typename query_t,
typename align_config_t,
typename traits_t>
1109 bool edit_distance_unbanded<database_t, query_t, align_config_t, traits_t>::small_patterns()
1111 bool abort_computation =
false;
1114 while (database_it != database_it_end)
1116 compute_state state{};
1117 size_t const block_offset =
seqan3::to_rank((query_alphabet_type) *database_it);
1119 compute_kernel<false>(state, block_offset, 0u);
1120 advance_score(state.hp, state.hn, score_mask);
1123 if constexpr(is_semi_global && !use_max_errors)
1124 this->update_best_score();
1127 if constexpr(use_max_errors)
1128 abort_computation = this->update_last_active_cell();
1132 if (abort_computation)
1139 template <
typename database_t,
typename query_t,
typename align_config_t,
typename traits_t>
1140 bool edit_distance_unbanded<database_t, query_t, align_config_t, traits_t>::large_patterns()
1142 bool abort_computation =
false;
1144 while (database_it != database_it_end)
1146 compute_state state{};
1147 size_t const block_offset = vp.size() *
seqan3::to_rank((query_alphabet_type) *database_it);
1149 size_t block_count = vp.size();
1150 if constexpr(use_max_errors)
1151 block_count = this->last_block + 1;
1154 for (
size_t current_block = 0u; current_block < block_count; current_block++)
1155 compute_kernel<true>(state, block_offset, current_block);
1157 advance_score(state.hp, state.hn, score_mask);
1160 if constexpr(is_semi_global && !use_max_errors)
1161 this->update_best_score();
1163 if constexpr(use_max_errors)
1166 bool additional_block = score_mask >> (word_size - 1u);
1167 bool reached_last_block = this->last_block + 1u == vp.size();
1169 if (reached_last_block)
1170 additional_block =
false;
1172 if (additional_block)
1174 size_t const current_block = this->last_block + 1u;
1176 vp[current_block] = vp0;
1177 vn[current_block] = vn0;
1178 compute_kernel<false>(state, block_offset, current_block);
1182 abort_computation = this->update_last_active_cell();
1188 if (abort_computation)
1201 template <
typename database_t,
typename query_t,
typename config_t,
typename traits_t>
1202 edit_distance_unbanded(database_t && database, query_t && query, config_t config, traits_t)
1203 -> edit_distance_unbanded<database_t, query_t, config_t, traits_t>;
Provides seqan3::detail::alignment_coordinate.
Provides seqan3::alignment_result.
Provides seqan3::configuration and utility functions.
Forwards for seqan3::edit_distance_unbanded related types.
Provides seqan3::detail::edit_distance_score_matrix_full.
Provides seqan3::detail::edit_distance_trace_matrix_full.
constexpr auto to_rank
Return the rank representation of a (semi-)alphabet object.
Definition: concept.hpp:155
@ alignment
The (pairwise) alignment stored in an object that models seqan3::detail::pairwise_alignment.
@ offset
Sequence (seqan3::field::seq) relative start position (0-based), unsigned value.
typename decltype(detail::back(list_t{}))::type back
Return the last type from the type list.
Definition: traits.hpp:264
constexpr size_t size
The size of a type pack.
Definition: traits.hpp:150
auto const move
A view that turns lvalue-references into rvalue-references.
Definition: move.hpp:70
Provides seqan3::detail::matrix.
constexpr auto const & get(configuration< configs_t... > const &config) noexcept
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition: configuration.hpp:434
SeqAn specific customisations in the standard namespace.
Adaptations of concepts from the Ranges TS.