iota_simd.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, 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 <seqan3/std/ranges>
 
#include <seqan3/utility/detail/exposition_only_concept.hpp>
#include <seqan3/utility/simd/algorithm.hpp>
#include <seqan3/utility/simd/concept.hpp>
#include <seqan3/utility/simd/simd_traits.hpp>
 
namespace seqan3::detail
{
 
template <simd_concept index_simd_t>
class counted_simd_iterator
{
private:
    index_simd_t count_simd{};
 
public:
    using value_type = index_simd_t;
    using reference = value_type;
    using pointer = void;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
 
    counted_simd_iterator() = default; 
    counted_simd_iterator(counted_simd_iterator const &) = default; 
    counted_simd_iterator(counted_simd_iterator &&) = default; 
    counted_simd_iterator & operator=(counted_simd_iterator const &) = default; 
    counted_simd_iterator & operator=(counted_simd_iterator &&) = default; 
    ~counted_simd_iterator() = default; 
 
    template <arithmetic index_scalar_t>
    explicit counted_simd_iterator(index_scalar_t const scalar_index) noexcept :
        count_simd{simd::fill<index_simd_t>(scalar_index)}
    {}
 
    reference operator*() const
    {
        return count_simd;
    }
 
    counted_simd_iterator & operator++()
    {
        count_simd += seqan3::simd::fill<index_simd_t>(1);
        return *this;
    }
 
    counted_simd_iterator operator++(int)
    {
        counted_simd_iterator tmp{*this};
        ++(*this);
        return tmp;
    }
 
    difference_type operator-(counted_simd_iterator const & rhs) const
    {
        return count_simd[0] - rhs.count_simd[0];
    }
 
    friend bool operator==(counted_simd_iterator const & lhs, counted_simd_iterator const & rhs) noexcept
    {
        return lhs.count_simd[0] == rhs.count_simd[0];
    }
 
    friend bool operator!=(counted_simd_iterator const & lhs, counted_simd_iterator const & rhs) noexcept
    {
        return !(lhs == rhs);
    }
};
 
template <simd_concept index_simd_t>
class iota_simd_view : public std::ranges::view_interface<iota_simd_view<index_simd_t>>
{
private:
    using index_scalar_type = typename simd_traits<index_simd_t>::scalar_type;
    using iterator_type = seqan3::detail::counted_simd_iterator<index_simd_t>;
 
    index_scalar_type begin_index{};
    index_scalar_type end_index{};
 
public:
    iota_simd_view() = default; 
    iota_simd_view(iota_simd_view const &) noexcept = default; 
    iota_simd_view(iota_simd_view &&) = default; 
    iota_simd_view & operator=(iota_simd_view const &) = default; 
    iota_simd_view & operator=(iota_simd_view &&) = default; 
    ~iota_simd_view() = default; 
 
    iota_simd_view(index_scalar_type const begin_index, index_scalar_type const end_index) :
        begin_index{begin_index},
        end_index{end_index}
    {}
 
    iterator_type begin() const noexcept
    {
        return iterator_type{begin_index};
    }
 
    iterator_type end() const noexcept
    {
        return iterator_type{end_index};
    }
};
 
template <simd_concept index_simd_t>
struct iota_simd_view_fn
{
    using index_scalar_type = typename simd_traits<index_simd_t>::scalar_type;
 
    constexpr auto operator()(index_scalar_type const begin_index, index_scalar_type const end_index) const
    {
        return iota_simd_view<index_simd_t>{begin_index, end_index};
    }
};
} // namespace seqan3::detail
 
namespace seqan3::views
{
 
template <simd_concept index_simd_t>
inline constexpr detail::iota_simd_view_fn<index_simd_t> iota_simd{};
 
} // namespace seqan3::views
 
namespace ranges
{
template <seqan3::simd_concept index_simd_t>
inline constexpr bool enable_borrowed_range<seqan3::detail::iota_simd_view<index_simd_t>> = true;
} // namespace ranges
 
#ifdef __cpp_lib_ranges
namespace std::ranges
{
template <seqan3::simd_concept index_simd_t>
inline constexpr bool enable_borrowed_range<seqan3::detail::iota_simd_view<index_simd_t>> = true;
} // namespace std::ranges
#endif // __cpp_lib_ranges