26template <
typename alignment_configuration_t,
typename... policies_t>
27 requires is_type_specialisation_of_v<alignment_configuration_t, configuration>
40 static_assert(!std::same_as<alignment_result_type, empty_type>,
"Alignment result type was not configured.");
72 template <indexed_sequence_pair_range indexed_sequence_pairs_t,
typename callback_t>
73 requires std::invocable<callback_t, alignment_result_type>
74 void operator()(indexed_sequence_pairs_t && indexed_sequence_pairs, callback_t && callback)
80 size_t sequence1_size = std::ranges::distance(get<0>(
sequence_pair));
81 size_t const sequence2_size = std::ranges::distance(get<1>(
sequence_pair));
83 auto && [alignment_matrix, index_matrix] =
84 this->acquire_matrices(sequence1_size, sequence2_size, this->lowest_viable_score());
87 this->compare_and_set_optimum.set_target_indices(
row_index_type{sequence2_size},
91 sequence1_size =
std::min(sequence1_size, this->upper_diagonal + sequence2_size);
93 using sequence1_difference_t = std::ranges::range_difference_t<decltype(get<0>(
sequence_pair))>;
102 this->optimal_coordinate,
109 template <indexed_sequence_pair_range indexed_sequence_pairs_t,
typename callback_t>
111 auto operator()(indexed_sequence_pairs_t && indexed_sequence_pairs, callback_t && callback)
117 auto seq1_collection = indexed_sequence_pairs | views::elements<0> | views::elements<0>;
118 auto seq2_collection = indexed_sequence_pairs | views::elements<0> | views::elements<1>;
120 this->initialise_tracker(seq1_collection, seq2_collection);
123 thread_local simd_collection_t simd_seq1_collection{};
124 thread_local simd_collection_t simd_seq2_collection{};
128 this->scoring_scheme.padding_symbol);
131 this->scoring_scheme.padding_symbol);
133 size_t const sequence1_size = std::ranges::distance(simd_seq1_collection);
134 size_t const sequence2_size = std::ranges::distance(simd_seq2_collection);
136 auto && [alignment_matrix, index_matrix] =
137 this->acquire_matrices(sequence1_size, sequence2_size, this->lowest_viable_score());
139 compute_matrix(simd_seq1_collection, simd_seq2_collection, alignment_matrix, index_matrix);
144 original_score_t score = this->optimal_score[index]
145 - (this->padding_offsets[index] * this->scoring_scheme.padding_match_score());
146 matrix_coordinate coordinate{
row_index_type{
size_t{this->optimal_coordinate.row[index]}},
151 std::move(coordinate),
212 template <std::ranges::forward_range sequence1_t,
213 std::ranges::forward_range sequence2_t,
214 std::ranges::input_range alignment_matrix_t,
215 std::ranges::input_range index_matrix_t>
216 requires std::ranges::forward_range<std::ranges::range_reference_t<alignment_matrix_t>>
217 && std::ranges::forward_range<std::ranges::range_reference_t<index_matrix_t>>
219 sequence2_t && sequence2,
220 alignment_matrix_t && alignment_matrix,
221 index_matrix_t && index_matrix)
227 this->reset_optimum();
229 auto alignment_matrix_it = alignment_matrix.begin();
230 auto indexed_matrix_it = index_matrix.begin();
232 using row_index_t = std::ranges::range_difference_t<sequence2_t>;
233 using column_index_t = std::ranges::range_difference_t<sequence1_t>;
235 row_index_t row_size = std::max<int32_t>(0, -this->lower_diagonal);
236 column_index_t
const column_size = std::max<int32_t>(0, this->upper_diagonal);
237 this->
initialise_column(*alignment_matrix_it, *indexed_matrix_it, std::views::take(sequence2, row_size));
243 for (
auto alphabet1 : std::views::take(sequence1, column_size))
246 *++indexed_matrix_it,
248 std::views::take(sequence2, ++row_size));
255 row_index_t first_row_index = 0u;
256 for (
auto alphabet1 : std::views::drop(sequence1, column_size))
259 std::views::drop(*++indexed_matrix_it, first_row_index + 1),
269 auto alignment_column = *alignment_matrix_it;
270 auto cell_index_column = std::views::drop(*indexed_matrix_it, first_row_index);
272 auto alignment_column_it = alignment_column.begin();
273 auto cell_index_column_it = cell_index_column.begin();
275 this->track_last_column_cell(*alignment_column_it, *cell_index_column_it);
277 for (row_index_t last_row = std::min<row_index_t>(std::ranges::distance(sequence2), row_size);
278 first_row_index < last_row;
280 this->track_last_column_cell(*++alignment_column_it, *++cell_index_column_it);
282 this->track_final_cell(*alignment_column_it, *cell_index_column_it);
336 template <std::ranges::forward_range alignment_column_t,
337 std::ranges::input_range cell_index_column_t,
338 typename alphabet1_t,
339 std::ranges::input_range sequence2_t>
341 cell_index_column_t && cell_index_column,
342 alphabet1_t
const & alphabet1,
343 sequence2_t && sequence2)
349 auto current_alignment_column_it = alignment_column.begin();
350 auto cell_index_column_it = cell_index_column.begin();
353 decltype(current_alignment_column_it) next_alignment_column_it{current_alignment_column_it};
354 auto cell = *current_alignment_column_it;
355 cell = this->track_cell(
356 this->initialise_band_first_cell(cell.best_score(),
357 *++next_alignment_column_it,
359 *cell_index_column_it);
365 for (
auto && alphabet2 : std::views::drop(sequence2, 1))
367 current_alignment_column_it = next_alignment_column_it;
368 auto cell = *current_alignment_column_it;
369 cell = this->track_cell(this->compute_inner_cell(cell.best_score(),
370 *++next_alignment_column_it,
371 this->scoring_scheme.score(alphabet1, alphabet2)),
372 *++cell_index_column_it);
379 this->track_last_row_cell(*current_alignment_column_it, *cell_index_column_it);
Allocates uninitialized storage whose memory-alignment is specified by alignment.
Definition aligned_allocator.hpp:74
The alignment algorithm type to compute the banded standard pairwise alignment using dynamic programm...
Definition pairwise_alignment_algorithm_banded.hpp:30
pairwise_alignment_algorithm_banded()=default
Defaulted.
pairwise_alignment_algorithm_banded & operator=(pairwise_alignment_algorithm_banded const &)=default
Defaulted.
void compute_matrix(sequence1_t &&sequence1, sequence2_t &&sequence2, alignment_matrix_t &&alignment_matrix, index_matrix_t &&index_matrix)
Compute the actual banded alignment.
Definition pairwise_alignment_algorithm_banded.hpp:218
pairwise_alignment_algorithm_banded(pairwise_alignment_algorithm_banded &&)=default
Defaulted.
pairwise_alignment_algorithm_banded(pairwise_alignment_algorithm_banded const &)=default
Defaulted.
::is_vectorised &&std::invocable< callback_t, alignment_result_type > auto operator()(indexed_sequence_pairs_t &&indexed_sequence_pairs, callback_t &&callback)
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition pairwise_alignment_algorithm_banded.hpp:111
pairwise_alignment_algorithm_banded(alignment_configuration_t const &config)
Constructs and initialises the algorithm using the alignment configuration.
Definition pairwise_alignment_algorithm_banded.hpp:64
pairwise_alignment_algorithm_banded & operator=(pairwise_alignment_algorithm_banded &&)=default
Defaulted.
void operator()(indexed_sequence_pairs_t &&indexed_sequence_pairs, callback_t &&callback)
Computes the pairwise sequence alignment for the given range over indexed sequence pairs.
Definition pairwise_alignment_algorithm_banded.hpp:74
void compute_band_column(alignment_column_t &&alignment_column, cell_index_column_t &&cell_index_column, alphabet1_t const &alphabet1, sequence2_t &&sequence2)
Computes a column of the band that does not start in the first row of the alignment matrix.
Definition pairwise_alignment_algorithm_banded.hpp:340
~pairwise_alignment_algorithm_banded()=default
Defaulted.
The alignment algorithm type to compute standard pairwise alignment using dynamic programming.
Definition pairwise_alignment_algorithm.hpp:44
typename traits_type::score_type score_type
The configured score type.
Definition pairwise_alignment_algorithm.hpp:49
void compute_column(alignment_column_t &&alignment_column, cell_index_column_t &&cell_index_column, alphabet1_t const &alphabet1, sequence2_t &&sequence2)
Initialise any column of the alignment matrix except the first one.
Definition pairwise_alignment_algorithm.hpp:365
alignment_configuration_traits< alignment_configuration_t > traits_type
The alignment configuration traits type with auxiliary information extracted from the configuration t...
Definition pairwise_alignment_algorithm.hpp:47
void initialise_column(alignment_column_t &&alignment_column, cell_index_column_t &&cell_index_column, sequence2_t &&sequence2)
Initialise the first column of the alignment matrix.
Definition pairwise_alignment_algorithm.hpp:312
void convert_batch_of_sequences_to_simd_vector(simd_sequence_t &simd_sequence, sequence_collection_t &sequences, padding_symbol_t const &padding_symbol)
Converts a batch of sequences to a sequence of simd vectors.
Definition pairwise_alignment_algorithm.hpp:217
typename traits_type::alignment_result_type alignment_result_type
The configured alignment result type.
Definition pairwise_alignment_algorithm.hpp:51
constexpr auto slice
A view adaptor that returns a half-open interval on the underlying range.
Definition slice.hpp:175
A helper concept to check if a type is a sequence pair.
The internal SeqAn3 namespace.
Definition aligned_sequence_concept.hpp:26
Provides seqan3::detail::pairwise_alignment_algorithm.
Provides seqan3::views::slice.
static constexpr bool is_banded
Flag indicating whether banded alignment mode is enabled.
Definition alignment/pairwise/detail/type_traits.hpp:120
static constexpr bool is_vectorised
Flag to indicate vectorised mode.
Definition alignment/pairwise/detail/type_traits.hpp:112
typename std::remove_reference_t< decltype(std::declval< configuration_t >().get_or(align_cfg::score_type< int32_t >{}))>::type original_score_type
The original score type selected by the user.
Definition alignment/pairwise/detail/type_traits.hpp:131
A strong type for designated initialisation of the column index of a matrix.
Definition matrix_coordinate.hpp:29
A strong type for designated initialisation of the row index of a matrix.
Definition matrix_coordinate.hpp:58