26namespace seqan3::detail
31struct number_cols : strong_type<size_t, number_cols>
34 using strong_type<size_t, number_cols>::strong_type;
39struct number_rows : strong_type<size_t, number_rows>
42 using strong_type<size_t, number_rows>::strong_type;
61template <
typename value_t,
63 matrix_major_order order = matrix_major_order::row>
64class two_dimensional_matrix
74 template <
bool const_range>
83 using value_type =
typename storage_type::value_type;
84 using reference =
typename storage_type::reference;
85 using const_reference =
typename storage_type::const_reference;
86 using pointer =
typename storage_type::pointer;
87 using const_pointer =
typename storage_type::const_pointer;
88 using difference_type =
typename storage_type::difference_type;
89 using size_type =
typename storage_type::size_type;
90 using iterator = basic_iterator<false>;
91 using const_iterator = basic_iterator<true>;
97 two_dimensional_matrix() =
default;
98 two_dimensional_matrix(two_dimensional_matrix
const &) =
default;
99 two_dimensional_matrix(two_dimensional_matrix &&) =
default;
100 two_dimensional_matrix & operator=(two_dimensional_matrix
const &) =
default;
101 two_dimensional_matrix & operator=(two_dimensional_matrix &&) =
default;
102 ~two_dimensional_matrix() =
default;
108 two_dimensional_matrix(number_rows
const row_dim, number_cols
const col_dim) :
109 row_dim{row_dim.
get()},
110 col_dim{col_dim.
get()}
112 storage.resize(row_dim.get() * col_dim.get());
121 template <std::ranges::forward_range entries_t>
122 requires (std::convertible_to<std::ranges::range_value_t<entries_t>, value_type>)
123 two_dimensional_matrix(number_rows
const row_dim, number_cols
const col_dim, entries_t entries) :
124 row_dim{row_dim.get()},
125 col_dim{col_dim.get()}
127 static_assert(std::move_constructible<std::ranges::range_value_t<entries_t>>,
128 "The value type must be moveable.");
130 assert(
static_cast<size_t>(std::ranges::distance(entries)) == (row_dim.get() * col_dim.get()));
131 storage.resize(row_dim.get() * col_dim.get());
132 std::ranges::move(entries, storage.begin());
136 two_dimensional_matrix(number_rows
const row_dim, number_cols
const col_dim, storage_type entries) :
137 row_dim{row_dim.
get()},
138 col_dim{col_dim.
get()}
140 assert(
static_cast<size_t>(std::ranges::distance(entries)) == (row_dim.get() * col_dim.get()));
141 storage = std::move(entries);
169 template <
typename other_value_t,
typename other_allocator_t, matrix_major_order other_order>
170 requires std::assignable_from<other_value_t &, value_t &>
171 explicit constexpr two_dimensional_matrix(
172 two_dimensional_matrix<other_value_t, other_allocator_t, other_order>
const & matrix) :
173 two_dimensional_matrix{number_rows{matrix.rows()}, number_cols{matrix.cols()}}
175 for (
size_t i = 0; i < cols(); ++i)
177 for (
size_t j = 0; j < rows(); ++j)
179 matrix_coordinate coord{row_index_type{j}, column_index_type{i}};
180 (*this)[coord] = matrix[coord];
189 constexpr reference operator[](matrix_coordinate
const & coordinate)
noexcept
191 assert(coordinate.col < cols());
192 assert(coordinate.row < rows());
195 + matrix_offset{row_index_type{
static_cast<std::ptrdiff_t>(coordinate.row)},
200 constexpr const_reference operator[](matrix_coordinate
const & coordinate)
const noexcept
202 assert(coordinate.col < cols());
203 assert(coordinate.row < rows());
206 + matrix_offset{row_index_type{
static_cast<std::ptrdiff_t>(coordinate.row)},
211 constexpr reference
at(matrix_coordinate
const & coordinate)
213 if (coordinate.col >= cols())
214 throw std::invalid_argument{
"Column index is out of range. Please check the dimensions of the matrix."};
215 if (coordinate.row >= rows())
216 throw std::invalid_argument{
"Row index is out of range. Please check the dimensions of the matrix."};
218 return (*
this)[coordinate];
222 constexpr const_reference
at(matrix_coordinate
const & coordinate)
const
224 if (coordinate.col >= cols())
225 throw std::invalid_argument{
"Column index is out of range. Please check the dimensions of the matrix."};
226 if (coordinate.row >= rows())
227 throw std::invalid_argument{
"Row index is out of range. Please check the dimensions of the matrix."};
229 return (*
this)[coordinate];
237 void resize(number_rows
const row_dim, number_cols
const col_dim)
239 this->row_dim = row_dim.get();
240 this->col_dim = col_dim.get();
241 storage.resize(this->row_dim * this->col_dim);
245 size_t rows() const noexcept
251 size_t cols() const noexcept
257 constexpr pointer
data() noexcept
259 return storage.data();
263 constexpr const_pointer
data() const noexcept
265 return storage.data();
273 constexpr iterator
begin() noexcept
275 return {*
this, storage.begin()};
278 constexpr const_iterator
begin() const noexcept
280 return {*
this, storage.begin()};
284 constexpr const_iterator
cbegin() const noexcept
290 constexpr iterator
end() noexcept
292 return {*
this, storage.end()};
296 constexpr const_iterator
end() const noexcept
298 return {*
this, storage.end()};
302 constexpr const_iterator
cend() const noexcept
309 storage_type storage;
322template <
typename value_t,
typename allocator_t, matrix_major_order order>
323template <
bool const_range>
324class two_dimensional_matrix<value_t, allocator_t, order>::basic_iterator :
325 public two_dimensional_matrix_iterator_base<basic_iterator<const_range>, order>
329 using parent_t = detail::maybe_const_range_t<const_range, two_dimensional_matrix>;
332 using base_t = two_dimensional_matrix_iterator_base<basic_iterator, order>;
335 template <
typename derived_t, matrix_major_order other_order>
336 friend class two_dimensional_matrix_iterator_base;
339 template <
bool other_const_range>
340 friend class basic_iterator;
343 using storage_iterator = detail::maybe_const_iterator_t<const_range, storage_type>;
350 using value_type = std::iter_value_t<storage_iterator>;
352 using reference = std::iter_reference_t<storage_iterator>;
354 using pointer =
typename storage_iterator::pointer;
356 using difference_type = std::iter_difference_t<storage_iterator>;
364 constexpr basic_iterator() =
default;
365 constexpr basic_iterator(basic_iterator
const &) =
default;
366 constexpr basic_iterator(basic_iterator &&) =
default;
367 constexpr basic_iterator & operator=(basic_iterator
const &) =
default;
368 constexpr basic_iterator & operator=(basic_iterator &&) =
default;
369 ~basic_iterator() =
default;
375 constexpr basic_iterator(parent_t & matrix, storage_iterator iter) : matrix_ptr{&matrix}, host_iter{iter}
379 constexpr basic_iterator(basic_iterator<!const_range>
const & other)
noexcept
381 : matrix_ptr{other.matrix_ptr}, host_iter{other.host_iter}
386 using base_t::operator+=;
389 constexpr basic_iterator & operator+=(matrix_offset
const &
offset)
noexcept
391 assert(matrix_ptr !=
nullptr);
393 if constexpr (order == matrix_major_order::column)
395 host_iter += (
offset.col * matrix_ptr->rows());
401 host_iter += (
offset.row * matrix_ptr->cols());
407 matrix_coordinate coordinate() const noexcept
409 assert(matrix_ptr !=
nullptr);
411 auto diff = *
this - matrix_ptr->begin();
412 if constexpr (order == matrix_major_order::column)
413 return {row_index_type{diff % matrix_ptr->rows()}, column_index_type{diff / matrix_ptr->rows()}};
415 return {row_index_type{diff / matrix_ptr->cols()}, column_index_type{diff % matrix_ptr->cols()}};
419 parent_t * matrix_ptr{
nullptr};
420 storage_iterator host_iter{};
Provides various transformation traits used by the range module.
Provides seqan3::detail::deferred_crtp_base.
@ offset
Sequence (seqan3::field::seq) relative start position (0-based), unsigned value.
typename decltype(detail::at< idx >(list_t{}))::type at
Return the type at given index from the type list.
Definition type_list/traits.hpp:279
Provides seqan3::detail::matrix_index, seqan3::detail::matrix_coordinate and associated strong types.
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:415
Provides type traits for working with templates.
Provides seqan3::detail::two_dimensional_matrix_iterator_base.