SeqAn3  3.0.3
The Modern C++ library for sequence analysis.
seqan3::views Namespace Reference

The SeqAn namespace for views. More...

Classes

class  deep
 A wrapper type around an existing view adaptor that enables "deep view" behaviour for that view. More...
 

Variables

constexpr auto chunk = ::ranges::views::chunk
 A chunk view. More...
 
template<auto index>
constexpr auto get = views::elements<index>
 A view calling get on each element in a range. More...
 
template<simd_concept index_simd_t>
constexpr detail::iota_simd_view_fn< index_simd_t > iota_simd
 An iota view over a simd vector. More...
 
constexpr auto istreambuf
 A view factory that returns a view over the stream buffer of an input stream. More...
 
constexpr auto join = ::ranges::views::join
 A join view. More...
 
constexpr auto join_with = ::ranges::views::join
 A join view, please use std::views::join if you don't need a separator. More...
 
constexpr auto persist = detail::persist_fn{}
 A view adaptor that wraps rvalue references of non-views. More...
 
constexpr auto to
 A to view. More...
 
template<simd::simd_concept simd_t>
constexpr auto to_simd
 A view that transforms a range of ranges into chunks of seqan3::simd vectors. More...
 
constexpr auto zip = ::ranges::views::zip
 A zip view. More...
 
Alphabet related views
template<alphabet alphabet_type>
auto const char_to
 A view over an alphabet, given a range of characters. More...
 
auto const complement
 A view that converts a range of nucleotides to their complement. More...
 
template<typename alphabet_type >
auto const rank_to
 A view over an alphabet, given a range of ranks. More...
 
auto const to_char
 A view that calls seqan3::to_char() on each element in the input range. More...
 
auto const to_rank
 A view that calls seqan3::to_rank() on each element in the input range. More...
 
constexpr auto translate_single
 A view that translates nucleotide into aminoacid alphabet for one of the six frames. More...
 
constexpr auto translate
 A view that translates nucleotide into aminoacid alphabet with 1, 2, 3 or 6 frames. More...
 
constexpr auto translate_join
 A view that translates nucleotide into aminoacid alphabet with 1, 2, 3 or 6 frames. Input and output range are always two-dimensional. More...
 
constexpr auto trim_quality
 A view that does quality-threshold trimming on a range of seqan3::quality_alphabet. More...
 
constexpr auto kmer_hash
 Computes hash values for each position of a range via a given shape. More...
 
constexpr auto minimiser_hash
 Computes minimisers for a range with a given shape, window size and seed. More...
 
General purpose views
constexpr auto take
 A view adaptor that returns the first size elements from the underlying range (or less if the underlying range is shorter). More...
 
constexpr auto async_input_buffer
 A view adapter that returns a concurrent-queue-like view over the underlying range. More...
 
constexpr auto as_const
 A view that provides only const & to elements of the underlying range. More...
 
constexpr auto drop
 A view adaptor that returns all elements after n from the underlying range (or an empty range if the underlying range is shorter). More...
 
auto const move
 A view that turns lvalue-references into rvalue-references. More...
 
constexpr auto take_exactly
 A view adaptor that returns the first size elements from the underlying range (or less if the underlying range is shorter); also provides size information. More...
 
constexpr auto take_exactly_or_throw
 A view adaptor that returns the first size elements from the underlying range and also exposes size information; throws if the underlying range is smaller than size. More...
 
constexpr auto take_until
 A view adaptor that returns elements from the underlying range until the functor evaluates to true (or the end of the underlying range is reached). More...
 
constexpr auto take_until_or_throw
 A view adaptor that returns elements from the underlying range until the functor evaluates to true (throws if the end of the underlying range is reached). More...
 
constexpr auto take_until_and_consume
 A view adaptor that returns elements from the underlying range until the functor evaluates to true (or the end of the underlying range is reached; consumes end in single-pass ranges). More...
 
constexpr auto take_until_or_throw_and_consume
 A view adaptor that returns elements from the underlying range until the functor evaluates to true (throws if the end of the underlying range is reached; consumes end in single-pass ranges). More...
 
auto const to_lower
 A view that calls seqan3::to_lower() on each element in the input range. More...
 
auto const to_upper
 A view that calls seqan3::to_upper() on each element in the input range. More...
 
constexpr auto minimiser
 Computes minimisers for a range of comparable values. A minimiser is the smallest value in a window. More...
 
template<typename out_t >
constexpr auto convert
 A view that converts each element in the input range (implicitly or via static_cast). More...
 
template<size_t index>
constexpr auto elements
 A view calling get on each element in a range. More...
 
constexpr auto enforce_random_access
 A view adaptor that converts a pseudo random access range to a std::ranges::random_access_range. More...
 
constexpr auto interleave
 A view that interleaves a given range into another range at regular intervals. More...
 
constexpr auto pairwise_combine
 A view adaptor that generates all pairwise combinations of the elements of the underlying range. More...
 
constexpr detail::repeat_fn repeat
 A view factory that repeats a given value infinitely. More...
 
constexpr auto repeat_n
 A view factory that repeats a given value n times. More...
 
constexpr auto single_pass_input
 A view adapter that decays most of the range properties and adds single pass behavior. More...
 
constexpr auto slice
 A view adaptor that returns a half-open interval on the underlying range. More...
 
constexpr auto type_reduce
 A view adaptor that behaves like std::views::all, but type erases certain ranges. More...
 

Detailed Description

The SeqAn namespace for views.

[adaptor_def]

Since views often have name clashes with regular functions and ranges they are implemented in the sub namespace view.

See the views submodule of the range module for more details.

Variable Documentation

◆ iota_simd

template<simd_concept index_simd_t>
constexpr detail::iota_simd_view_fn<index_simd_t> seqan3::views::iota_simd
inlineconstexpr

An iota view over a simd vector.

Template Parameters
index_simd_tThe represented index type; must model seqan3::simd::simd_concept.

This view is an equivalent implementation to:

// The simd type with 8 unsigned shorts.
using uint16x8_t = seqan3::simd_type_t<uint16_t, 8>;
int main()
{
// Generate ascending simd index using a iota view in combination with a transfor view.
auto simd_iota_view = std::views::iota(0, 10)
| std::views::transform([] (uint16_t const idx)
{
return seqan3::simd::fill<uint16x8_t>(idx);
});
for (auto && simd_id : simd_iota_view)
seqan3::debug_stream << simd_id << '\n'; // [0, 0, ..., 0], [1, 1, ..., 1], ... [9, 9, ..., 9]
return 0;
}
Provides seqan3::debug_stream and related types.
debug_stream_type debug_stream
A global instance of seqan3::debug_stream_type.
Definition: debug_stream.hpp:42
decltype(detail::transform< trait_t >(list_t{})) transform
Apply a transformation trait to every type in the list and return a seqan3::type_list of the results.
Definition: traits.hpp:444
Adaptations of concepts from the Ranges TS.
Meta-header for the simd module.

However, benchmarks showed that increasing a simd vector is faster than constructing it every time (up-to 2x speed-up). This speed-up justifies an own class that does this task more efficiently.

This view is a lightweight wrapper around a seqan3::detail::counted_simd_iterator pair. Note the regular std::views::iota view cannot be used with two simd types:

std::views::iota(simd_begin, simd_end);

because the return type of the comparison of two simd vector types is not convertible to bool.

View properties

Concepts and traits rrng_t (returned range type)
std::ranges::input_range guaranteed
std::ranges::forward_range guaranteed
std::ranges::bidirectional_range lost
std::ranges::random_access_range lost
std::ranges::contiguous_range lost
std::ranges::viewable_range guaranteed
std::ranges::view guaranteed
std::ranges::sized_range guaranteed
std::ranges::common_range guaranteed
std::ranges::output_range lost
std::ranges::borrowed_range guaranteed
seqan3::const_iterable_range guaranteed
std::ranges::range_reference_t index_simd_t

This is a source view. For more details, see Views.

Example

// The simd type with 8 unsigned shorts.
using uint16x8_t = seqan3::simd_type_t<uint16_t, 8>;
int main()
{
// Generate ascending simd index.
for (auto && simd_id : seqan3::views::iota_simd<uint16x8_t>(0, 10))
seqan3::debug_stream << simd_id << '\n'; // [0, 0, ..., 0], [1, 1, ..., 1], ... [9, 9, ..., 9]
return 0;
}

◆ to_simd

template<simd::simd_concept simd_t>
constexpr auto seqan3::views::to_simd
inlineconstexpr

A view that transforms a range of ranges into chunks of seqan3::simd vectors.

Template Parameters
urng_tThe type of the range being processed.
simd_tThe target simd vector type.
Parameters
[in]urangeThe range being processed.
[in]paddingAn optional padding value.
Returns
A range of ranges with the original sequences transformed into simd vectors.

Header File

#include <seqan3/utility/simd/views/to_simd.hpp>

This view can be used to transform a collection of sequences into chunks of simd vectors. This transformation is also known as Array-of-Structure to Structure-of-Array transformation. It is used to transform the memory layout of the sequences to a more efficient form when used in vectorised algorithms. The number of sequences contained in the range to be transformed cannot be larger than the number of elements stored in the target simd vector, i.e. the size of urange <= simd_traits<simd_t>::length. After applying the transformation one column of the outer range is transposed into a simd vector. This means that the characters of all sequences at a given position x are stored in a simd vector retaining the original order. The returned range itself is a range-of-ranges. When dereferencing the iterator a std::span over a std::array with at most simd length many vectors is returned. If a sequence is empty or ends before the largest sequence in the collection, it can be padded with an optional value.

View properties

Concepts and traits urng_t (underlying range type) rrng_t (returned range type)
std::ranges::input_range required preserved
std::ranges::forward_range required lost
std::ranges::bidirectional_range lost
std::ranges::random_access_range lost
std::ranges::contiguous_range lost
std::ranges::viewable_range required guaranteed
std::ranges::view guaranteed
std::ranges::sized_range preserved (iff std::ranges::sized_range<std::ranges::range_value_t<urng_t>> is true)
std::ranges::common_range lost
std::ranges::output_range lost
seqan3::const_iterable_range lost
std::ranges::range_reference_t std::span<simd_t>
  • urng_t is the type of the range modified by this view (input).
  • the expression std::ranges::input_range<std::ranges::range_value_t<urng_t> must evaluate to true
  • the expression std::default_initializable<std::ranges::range_value_t<urng_t>> must evaluate to true
  • the expression semialphabet<std::ranges::range_value_t<std::ranges::range_value_t<urng_t>>> must evaluate to true
  • rrng_type is the type of the range returned by this view.
  • for more details, see Views.

Example

#include <vector>
using uint16x8_t = seqan3::simd_type_t<uint16_t, 8>;
int main()
{
using namespace seqan3::literals;
// Adds 7 sequences. The eighth will be set to a default value.
batch.push_back("ACGTACGTACGTACGATCG"_dna4);
batch.push_back("AGTGAGCTACGGACTAGCTACGACT"_dna4);
batch.push_back("GACTAGCACGAGCGAGATCG"_dna4);
batch.push_back("GGATCGACGGACTAGC"_dna4);
batch.push_back("ACGTACGACGGACGTACGAGCGAGCTACGAGC"_dna4);
batch.push_back("ACGATCGACGACTAGCGAC"_dna4);
batch.push_back("GTACGGATGGTAAACCGCACAT"_dna4);
// Applies lazy transformation using `8` as a padding symbol if a sequence ends early.
auto to_soa = batch | seqan3::views::to_simd<uint16x8_t>(8);
size_t chunk_count = 0;
for (auto && chunk : to_soa)
{
seqan3::debug_stream << "Chunk " << chunk_count++ << ":\n";
for (auto & vec : chunk)
seqan3::debug_stream << vec << '\n';
}
return 0;
}
Provides seqan3::dna4, container aliases and string literals.
constexpr auto chunk
A chunk view.
Definition: chunk.hpp:29
The SeqAn namespace for literals.
T push_back(T... args)

The output is as follows:

Chunk 0:
[0,0,2,2,0,0,2,8]
[1,2,0,2,1,1,3,8]
[2,3,1,0,2,2,0,8]
[3,2,3,3,3,0,1,8]
[0,0,0,1,0,3,2,8]
[1,2,2,2,1,1,2,8]
[2,1,1,0,2,2,0,8]
[3,3,0,1,0,0,3,8]
Chunk 1:
[0,0,1,2,1,1,2,8]
[1,1,2,2,2,2,2,8]
[2,2,0,0,2,0,3,8]
[3,2,2,1,0,1,0,8]
[0,0,1,3,1,3,0,8]
[1,1,2,0,2,0,0,8]
[2,3,0,2,3,2,1,8]
[0,0,2,1,0,1,1,8]
Chunk 2:
[3,2,0,8,1,2,2,8]
[1,1,3,8,2,0,1,8]
[2,3,1,8,0,1,0,8]
[8,0,2,8,2,8,1,8]
[8,1,8,8,1,8,0,8]
[8,2,8,8,2,8,3,8]
[8,0,8,8,0,8,8,8]
[8,1,8,8,2,8,8,8]
Chunk 3:
[8,3,8,8,1,8,8,8]
[8,8,8,8,3,8,8,8]
[8,8,8,8,0,8,8,8]
[8,8,8,8,1,8,8,8]
[8,8,8,8,2,8,8,8]
[8,8,8,8,0,8,8,8]
[8,8,8,8,2,8,8,8]
[8,8,8,8,1,8,8,8]