The main SeqAn3 namespace. More...

Namespaces
namespace	align_cfg
	A special sub namespace for the alignment configurations.

namespace	custom
	A namespace for third party and standard library specialisations of SeqAn customisation points.

namespace	exposition_only
	A namespace for SeqAn entities that are intended for documentation purposes only.

namespace	list_traits
	Namespace containing traits for working on seqan3::type_list.

namespace	literals
	The SeqAn namespace for literals.

namespace	pack_traits
	Namespace containing traits for working on type packs.

namespace	search_cfg
	A special sub namespace for the search configurations.

namespace	views
	The SeqAn namespace for views.

Classes
class	aa10li
	The reduced Li amino acid alphabet. More...

class	aa10murphy
	The reduced Murphy amino acid alphabet. More...

class	aa20
	The canonical amino acid alphabet. More...

class	aa27
	The twenty-seven letter amino acid alphabet. More...

struct	advanceable_alignment_coordinate_printer

struct	advanceable_alignment_coordinate_printer< detail::advanceable_alignment_coordinate< state_t > >
	The printer for seqan3::detail::advanceable_alignment_coordinate. More...

class	algorithm_result_generator_range
	An input range over the algorithm results generated by the underlying algorithm executor. More...

class	aligned_allocator
	Allocates uninitialized storage whose memory-alignment is specified by alignment. More...

struct	alignment_matrix_printer

struct	alignment_matrix_printer< alignment_matrix_t >
	The printer for alignment scoring and trace matrices. More...

struct	alignment_printer

struct	alignment_printer< alignment_t >
	The printer for alignment. More...

class	alignment_result
	Stores the alignment results and gives access to score, alignment and the front and end positions. More...

struct	alignment_result_printer

struct	alignment_result_printer< alignment_result< result_value_t > >
	The printer used for formatted output of the alignment result. More...

class	alphabet_base
	A CRTP-base that makes defining a custom alphabet easier. More...

struct	alphabet_printer

struct	alphabet_printer< alphabet_t >
	The printer used for formatted output of seqan3::alphabet types. More...

class	alphabet_proxy
	A CRTP-base that eases the definition of proxy types returned in place of regular alphabets. More...

class	alphabet_tuple_base
	The CRTP base for a combined alphabet that contains multiple values of different alphabets at the same time.. More...

class	alphabet_variant
	A combined alphabet that can hold values of either of its alternatives.. More...

class	aminoacid_base
	A CRTP-base that refines seqan3::alphabet_base and is used by the amino acids. More...

struct	aminoacid_empty_base
	This is an empty base class that can be inherited by types that shall model seqan3::aminoacid_alphabet. More...

class	aminoacid_scoring_scheme
	A data structure for managing and computing the score of two amino acids. More...

class	argument_parser
	The SeqAn command line parser. More...

class	argument_parser_error
	Argument parser exception that is thrown whenever there is an error while parsing the command line arguments. More...

struct	argument_parser_meta_data
	Stores all parser related meta information of the seqan3::argument_parser. More...

class	arithmetic_range_validator
	A validator that checks whether a number is inside a given range. More...

class	bi_fm_index
	The SeqAn Bidirectional FM Index. More...

class	bi_fm_index_cursor
	The SeqAn Bidirectional FM Index Cursor. More...

struct	bin_count
	A strong type that represents the number of bins for the seqan3::interleaved_bloom_filter. More...

struct	bin_index
	A strong type that represents the bin index for the seqan3::interleaved_bloom_filter. More...

struct	bin_literal
	A strong type of underlying type `uint64_t` that represents the shape in binary representation. More...

struct	bin_size
	A strong type that represents the number of bits for each bin in the seqan3::interleaved_bloom_filter. More...

class	bitpacked_sequence
	A space-optimised version of std::vector that compresses multiple letters into a single byte. More...

class	bloom_filter
	The Bloom Filter. A data structure that efficiently answers set-membership queries. More...

struct	char_sequence_printer

struct	char_sequence_printer< char_sequence_t >
	A printer for character sequences. More...

class	cigar
	The seqan3::cigar semialphabet pairs a counter with a seqan3::cigar::operation letter. More...

struct	cigar_clipped_bases
	Helper struct to specialise soft and hard clipping when using seqan3::cigar_from_alignment. More...

struct	cigar_printer

struct	cigar_printer< cigar >
	The printer used for formatted output of the cigar alphabets. More...

class	concatenated_sequences
	Container that stores sequences concatenated internally. More...

class	configuration
	Collection of elements to configure an algorithm. More...

class	counting_vector
	A data structure that behaves like a std::vector and can be used to consolidate the results of multiple calls to seqan3::interleaved_bloom_filter::membership_agent_type::bulk_contains. More...

struct	debug_stream_printer

struct	debug_stream_printer< value_t >
	A struct that provides a debug stream printer for a specific value type. More...

class	debug_stream_type
	A "pretty printer" for most SeqAn data structures and related types. More...

struct	default_printer
	The default printer that is used by seqan3::debug_stream. More...

class	design_error
	Argument parser exception that is thrown whenever there is an design error directed at the developer of the application (e.g. Reuse of option). More...

class	dna15
	The 15 letter DNA alphabet, containing all IUPAC smybols minus the gap. More...

class	dna16sam
	A 16 letter DNA alphabet, containing all IUPAC symbols minus the gap and plus an equality sign ('='). More...

class	dna3bs
	The three letter reduced DNA alphabet for bisulfite sequencing mode (A,G,T(=C)). More...

class	dna4
	The four letter DNA alphabet of A,C,G,T. More...

class	dna5
	The five letter DNA alphabet of A,C,G,T and the unknown character N. More...

class	dot_bracket3
	The three letter RNA structure alphabet of the characters ".()". More...

class	dssp9
	The protein structure alphabet of the characters "HGIEBTSCX". More...

class	dynamic_bitset
	A constexpr bitset implementation with dynamic size at compile time. More...

struct	dynamic_bitset_printer

struct	dynamic_bitset_printer< dynamic_bitset< bit_capacity > >
	Prints seqan3::dynamic_bitset. This entity is experimental and subject to change in the future. Experimental since version 3.1. . More...

struct	enumeration_printer

struct	enumeration_printer< enum_t >
	A type (e.g. an enum) can be made debug streamable by customizing the seqan3::enumeration_names. More...

struct	fields
	A class template that holds a choice of seqan3::field. More...

struct	file_open_error
	Thrown if there is an unspecified filesystem or stream error while opening, e.g. permission problem. More...

class	file_validator_base
	An abstract base class for the file and directory validators. More...

class	fm_index
	The SeqAn FM Index. More...

class	fm_index_cursor
	The SeqAn FM Index Cursor. More...

class	format_bam
	The BAM format. More...

class	format_embl
	The EMBL format. More...

struct	format_error
	Thrown if information given to output format didn't match expectations. More...

class	format_fasta
	The FASTA format. More...

class	format_fastq
	The FASTQ format. More...

class	format_genbank
	The GenBank format. More...

class	format_sam
	The SAM format (tag). More...

class	format_vienna
	The Vienna format (dot bracket notation) for RNA sequences with secondary structure. More...

struct	function_traits< std::function< return_t(args_t...)> >
	A traits class to provide a uniform interface to the properties of a function type. More...

class	gap
	The alphabet of a gap character '-'. More...

class	gap_decorator
	A gap decorator allows the annotation of sequences with gap symbols while leaving the underlying sequence unmodified. More...

class	gap_erase_failure
	Thrown in function seqan3::erase_gap, if a position does not contain a gap. More...

class	hamming_scoring_scheme
	A scoring scheme that assigns a score of `0` to matching letters and `-1` to mismatching letters. More...

struct	hash_function_count
	A strong type that represents the number of hash functions for the seqan3::interleaved_bloom_filter. More...

class	input_directory_validator
	A validator that checks if a given path is a valid input directory. More...

class	input_file_validator
	A validator that checks if a given path is a valid input file. More...

struct	input_range_printer

struct	input_range_printer< rng_t >
	A printer for arbitrary input ranges. More...

struct	integer_sequence_printer

struct	integer_sequence_printer< integer_sequence_t >
	A printer for integer sequences. More...

struct	integral_printer

struct	integral_printer< integral_t >
	The printer for integral types. More...

class	interleaved_bloom_filter
	The IBF binning directory. A data structure that efficiently answers set-membership queries for multiple bins. More...

class	invalid_alignment_configuration
	Thrown if the configuration of the alignment algorithm is invalid. More...

struct	invalid_char_assignment
	An exception typically thrown by seqan3::alphabet::assign_char_strict. More...

struct	io_error
	Thrown if there is an io error in low level io operations such as in std::basic_streambuf operations. More...

struct	is_constexpr_default_constructible
	Whether a type std::is_default_constructible in `constexpr`-context (unary_type_trait specialisation). More...

class	mask
	Implementation of a masked alphabet to be used for tuple composites. More...

struct	mask_printer

struct	mask_printer< mask_t >
	The printer used for formatted output of seqan3::mask alphabet. More...

class	masked
	Implementation of a masked composite, which extends a given alphabet with a mask. More...

struct	match_score
	A strong type of underlying type `score_type` that represents the score of two matching characters. More...

struct	mismatch_score
	A strong type of underlying type `score_type` that represents the score two different characters. More...

struct	no_printer_found
	A tag that indicates that no printer was found for the given type. More...

class	nucleotide_base
	A CRTP-base that refines seqan3::alphabet_base and is used by the nucleotides. More...

class	nucleotide_scoring_scheme
	A data structure for managing and computing the score of two nucleotides. More...

class	option_declared_multiple_times
	Argument parser exception thrown when a non-list option is declared multiple times. More...

struct	optional_printer

struct	optional_printer< std::nullopt_t >
	Printer for formatted output of std::nullopt_t. More...

struct	optional_printer< std::optional< T > >
	Printer for formatted output of a std::optional. More...

class	output_directory_validator
	A validator that checks if a given path is a valid output directory. More...

class	output_file_validator
	A validator that checks if a given path is a valid output file. More...

struct	parse_error
	Thrown if there is a parse error, such as reading an unexpected character from an input stream. More...

class	phred42
	Quality type for traditional Sanger and modern Illumina Phred scores. More...

class	phred63
	Quality type for traditional Sanger and modern Illumina Phred scores. More...

class	phred68solexa
	Quality type for Solexa and deprecated Illumina formats. More...

class	phred94
	Quality type for PacBio Phred scores of HiFi reads. More...

class	phred_base
	A CRTP-base that refines seqan3::alphabet_base and is used by the quality alphabets. More...

struct	pipeable_config_element
	Adds pipe interface to configuration elements. More...

struct	pod_tuple

struct	pod_tuple< type0 >
	Recursion anchor for seqan3::pod_tuple. More...

struct	pod_tuple< type0, types... >
	Behaves like std::tuple but is an aggregate PODType. More...

struct	printer_order
	The printer_order is a variadic template that defines the order of the printers. More...

class	qualified
	Joins an arbitrary alphabet with a quality alphabet. More...

struct	range_innermost_value
	Recursively determines the `value_type` on containers and/or iterators. More...

struct	record
	The class template that file records are based on; behaves like a std::tuple. More...

struct	ref_info_not_given
	Type tag which indicates that no reference information has been passed to the SAM file on construction. More...

class	regex_validator
	A validator that checks if a matches a regular expression pattern. More...

struct	remove_rvalue_reference
	Return the input type with `&&` removed, but lvalue references preserved. More...

class	required_option_missing
	Argument parser exception thrown when a required option is missing. More...

class	rna15
	The 15 letter RNA alphabet, containing all IUPAC smybols minus the gap. More...

class	rna4
	The four letter RNA alphabet of A,C,G,U. More...

class	rna5
	The five letter RNA alphabet of A,C,G,U and the unknown character N. More...

class	sam_file_header
	Stores the header information of SAM/BAM files. More...

class	sam_file_input
	A class for reading SAM files, both SAM and its binary representation BAM are supported. More...

struct	sam_file_input_default_traits
	The default traits for seqan3::sam_file_input. More...

interface	sam_file_input_format
	The generic concept for alignment file input formats. More...

struct	sam_file_input_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

class	sam_file_output
	A class for writing SAM files, both SAM and its binary representation BAM are supported. More...

interface	sam_file_output_format
	The generic concept for alignment file out formats. More...

struct	sam_file_output_options
	The options type defines various option members that influence the behavior of all or some formats. More...

struct	sam_file_program_info_t
	Stores information of the program/tool that was used to create a SAM/BAM file. More...

struct	sam_flag_printer

struct	sam_flag_printer< sam_flag >
	A sam_flag can be printed as an integer value. More...

class	sam_record
	The record type of seqan3::sam_file_input. More...

class	sam_tag_dictionary
	The SAM tag dictionary class that stores all optional SAM fields. More...

struct	sam_tag_type
	The generic base class. More...

class	scoring_scheme_base
	A CRTP base class for scoring schemes. More...

class	search_result
	The result class generated by the seqan3::seach algorithm. More...

struct	search_result_printer

struct	search_result_printer< search_result< specs_t... > >
	The printer used for formatted output of the search result. More...

struct	seed
	strong_type for seed. More...

class	semialphabet_any
	A semi-alphabet that type erases all other semi-alphabets of the same size. More...

class	sequence_file_input
	A class for reading sequence files, e.g. FASTA, FASTQ ... More...

struct	sequence_file_input_default_traits_aa
	A traits type that specifies input as amino acids. More...

struct	sequence_file_input_default_traits_dna
	The default traits for seqan3::sequence_file_input. More...

interface	sequence_file_input_format
	The generic concept for sequence file in formats. More...

struct	sequence_file_input_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

class	sequence_file_output
	A class for writing sequence files, e.g. FASTA, FASTQ ... More...

interface	sequence_file_output_format
	The generic concept for sequence file out formats. More...

struct	sequence_file_output_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

struct	sequence_printer

struct	sequence_printer< sequence_t >
	A printer for (biological) sequences. More...

class	sequence_record
	The record type of seqan3::sequence_file_input. More...

class	shape
	A class that defines which positions of a pattern to hash. More...

struct	simd_printer

class	small_string
	Implements a small string that can be used for compile time computations. More...

class	small_vector
	A constexpr vector implementation with dynamic size at compile time. More...

struct	std_byte_printer

struct	std_byte_printer< std::byte >
	A std::byte can be printed by printing its value as integer. More...

struct	std_printer

struct	std_printer< type_t >
	The printer for standard output streams. More...

struct	std_variant_printer

struct	std_variant_printer< std::variant< variant_ts... > >
	A std::variant can be printed by visiting the stream operator for the corresponding type. More...

struct	strong_type_printer

class	structure_file_input
	A class for reading structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ... More...

struct	structure_file_input_default_traits_aa
	A traits type that specifies input as amino acids. More...

struct	structure_file_input_default_traits_rna
	The default traits for seqan3::structure_file_input. More...

interface	structure_file_input_format
	The generic concept for structure file in formats. More...

struct	structure_file_input_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

class	structure_file_output
	A class for writing structured sequence files, e.g. Stockholm, Connect, Vienna, ViennaRNA bpp matrix ... More...

interface	structure_file_output_format
	The generic concept for structure file out formats. More...

struct	structure_file_output_options
	The options type defines various option members that influence the behaviour of all or some formats. More...

class	structure_record
	The record type of seqan3::structure_file_input. More...

class	structured_aa
	A seqan3::alphabet_tuple_base that joins an aminoacid alphabet with a protein structure alphabet. More...

class	structured_rna
	A seqan3::alphabet_tuple_base that joins a nucleotide alphabet with an RNA structure alphabet. More...

struct	suffix_array_interval
	The underlying suffix array interval. More...

class	too_few_arguments
	Argument parser exception thrown when too few arguments are provided. More...

class	too_many_arguments
	Argument parser exception thrown when too many arguments are provided. More...

struct	trace_directions_printer

struct	trace_directions_printer< detail::trace_directions >
	Prints `trace_directions` as ascii or as utf8 to output stream. More...

struct	tuple_printer

struct	tuple_printer< tuple_t >
	Printer for formatted output of tuple like objects. More...

struct	type_list
	Type that contains multiple types. More...

struct	unexpected_end_of_input
	Thrown if I/O was expecting more input (e.g. a delimiter or a new line), but the end of input was reached. More...

struct	ungapped
	A strong type of underlying type `uint8_t` that represents the ungapped shape size. More...

struct	unhandled_extension_error
	Thrown if there is no format that accepts a given file extension. More...

class	unknown_option
	Argument parser exception thrown when encountering unknown option. More...

class	user_input_error
	Argument parser exception thrown when an incorrect argument is given as (positional) option value. More...

class	validation_error
	Argument parser exception thrown when an argument could not be casted to the according type. More...

class	value_list_validator
	A validator that checks whether a value is inside a list of valid values. More...

struct	window_size
	strong_type for the window_size. More...

class	wuss
	The WUSS structure alphabet of the characters `.<>:,-_~;()[]{}AaBbCcDd`... More...

Concepts
concept	printable_with

concept	nonrecursive_range

Typedefs
template<typename alphabet_type >
using	alphabet_char_t = decltype(seqan3::to_char(std::declval< alphabet_type const >()))
	The `char_type` of the alphabet; defined as the return type of seqan3::to_char.

template<typename alphabet_type >
using	alphabet_phred_t = decltype(seqan3::to_phred(std::declval< alphabet_type >()))
	The `phred_type` of the alphabet; defined as the return type of seqan3::to_phred.

template<typename semi_alphabet_type >
using	alphabet_rank_t = decltype(seqan3::to_rank(std::declval< semi_alphabet_type >()))
	The `rank_type` of the semi-alphabet; defined as the return type of seqan3::to_rank. !

template<typename t1 , typename t2 >
using	common_pair = seqan::stl::pair< t1, t2 >
	A std::pair implementation that incorporates most changes from C++23's standard library.

template<typename... t>
using	common_tuple = seqan::stl::tuple< t... >
	A std::tuple implementation that incorporates most changes from C++23's standard library.

using	default_sdsl_index_type = sdsl_wt_index_type
	The default FM Index Configuration.

using	dna15q = qualified< dna15, phred42 >
	An alphabet that stores a seqan3::dna15 letter and an seqan3::qualified letter at each position.

using	dna4q = qualified< dna4, phred42 >
	An alphabet that stores a seqan3::dna4 letter and an seqan3::phred42 letter at each position.

using	dna5q = qualified< dna5, phred42 >
	An alphabet that stores a seqan3::dna5 letter and an seqan3::phred42 letter at each position.

template<typename alphabet_t >
using	gapped = alphabet_variant< alphabet_t, gap >
	Extends a given alphabet with a gap character.

template<typename t >
using	range_innermost_value_t = typename range_innermost_value< t >::type
	Shortcut for seqan3::range_innermost_value (transformation_trait shortcut).

using	rna15q = qualified< rna15, phred42 >
	An alphabet that stores a seqan3::rna15 letter and an seqan3::qualified letter at each position.

using	rna4q = qualified< rna4, phred42 >
	An alphabet that stores a seqan3::rna4 letter and an seqan3::phred42 letter at each position.

using	rna5q = qualified< rna5, phred42 >
	An alphabet that stores a seqan3::rna5 letter and an seqan3::phred42 letter at each position.

using	sdsl_wt_index_type = sdsl::csa_wt< sdsl::wt_blcd< sdsl::bit_vector, sdsl::rank_support_v<>, sdsl::select_support_scan<>, sdsl::select_support_scan< 0 > >, 16, 10 '000 '000, sdsl::sa_order_sa_sampling<>, sdsl::isa_sampling<>, sdsl::plain_byte_alphabet >
	The FM Index Configuration using a Wavelet Tree.

Enumerations
enum class	aminoacid_similarity_matrix { aminoacid_similarity_matrix::blosum30 , aminoacid_similarity_matrix::blosum45 , aminoacid_similarity_matrix::blosum62 , aminoacid_similarity_matrix::blosum80 }
	Identifiers for amino acid similarity matrixes. More...

enum	data_layout : bool { uncompressed , compressed }
	Determines if the Interleaved Bloom Filter is compressed. More...

enum class	field { field::seq , field::id , field::qual , field::offset , field::bpp , field::structure , field::structured_seq , field::energy , field::react , field::react_err , field::comment , field::alignment , field::ref_id , field::ref_seq , field::ref_offset , field::header_ptr , field::flag , field::mate , field::mapq , field::cigar , field::tags , field::bit_score , field::evalue , field::user_defined_0 , field::user_defined_1 , field::user_defined_2 , field::user_defined_3 , field::user_defined_4 , field::user_defined_5 , field::user_defined_6 , field::user_defined_7 , field::user_defined_8 , field::user_defined_9 }
	An enumerator for the fields used in file formats. More...

enum class	fmtflags2 : int8_t { fmtflags2::none = 0 , fmtflags2::utf8 = 1 , fmtflags2::small_int_as_number = 1 << 1 , default_ = small_int_as_number }
	Flags that change the behaviour of the seqan3::debug_stream. More...

enum struct	genetic_code : uint8_t { canonical = 1 }
	Genetic codes used for translation of nucleotides into amino acids. More...

enum	option_spec { standard = 0 , required = 1 , advanced = 2 , hidden = 4 }
	Used to further specify argument_parser options/flags. More...

enum class	output_file_open_options { open_or_create , create_new }
	Mode of an output file: Determines whether an existing file can be (silently) overwritten. More...

enum class	sam_flag : uint16_t { sam_flag::none = 0 , sam_flag::paired = 0x1 , sam_flag::proper_pair = 0x2 , sam_flag::unmapped = 0x4 , sam_flag::mate_unmapped = 0x8 , sam_flag::on_reverse_strand = 0x10 , sam_flag::mate_on_reverse_strand = 0x20 , sam_flag::first_in_pair = 0x40 , sam_flag::second_in_pair = 0x80 , sam_flag::secondary_alignment = 0x100 , sam_flag::failed_filter = 0x200 , sam_flag::duplicate = 0x400 , sam_flag::supplementary_alignment = 0x800 }
	An enum flag that describes the properties of an aligned read (given as a SAM record). More...

enum	text_layout : bool { single , collection }
	The possible text layouts (single, collection) the seqan3::fm_index and seqan3::bi_fm_index can support. More...

enum class	translation_frames : uint8_t { forward_frame0 = 1 , forward_frame1 = 1 << 1 , forward_frame2 = 1 << 2 , reverse_frame0 = 1 << 3 , reverse_frame1 = 1 << 4 , reverse_frame2 = 1 << 5 , forward_reverse0 = forward_frame0 \| reverse_frame0 , forward_reverse1 = forward_frame1 \| reverse_frame1 , forward_reverse2 = forward_frame2 \| reverse_frame2 , forward_frames = forward_frame0 \| forward_frame1 \| forward_frame2 , reverse_frames = reverse_frame0 \| reverse_frame1 \| reverse_frame2 , six_frames = forward_frames \| reverse_frames }
	Specialisation values for single and multiple translation frames. More...

enum class	update_notifications { on , off }
	Indicates whether application allows automatic update notifications by the seqan3::argument_parser. More...

Functions
template<typename sequence_t , typename alignment_config_t > requires detail::align_pairwise_single_input<sequence_t> && std::copy_constructible<std::remove_reference_t<sequence_t>> && detail::is_type_specialisation_of_v<alignment_config_t, configuration>
constexpr auto	align_pairwise (sequence_t &&seq, alignment_config_t const &config)
	Computes the pairwise alignment for a pair of sequences or a range over sequence pairs.

template<typename reference_type , typename sequence_type >
auto	alignment_from_cigar (std::string const &cigar_string, reference_type const &reference, uint32_t const zero_based_reference_start_position, sequence_type const &query)

template<typename reference_type , typename sequence_type >
auto	alignment_from_cigar (std::vector< cigar > const &cigar_vector, reference_type const &reference, uint32_t const zero_based_reference_start_position, sequence_type const &query)
	Construct an alignment from a CIGAR string and the corresponding sequences.

template<typename alignment_type >
auto	cigar_from_alignment (alignment_type const &alignment, cigar_clipped_bases const &clipped_bases={}, bool const extended_cigar=false)
	Creates a CIGAR string (SAM format) given a seqan3::detail::pairwise_alignment represented by two `seqan3::aligned_sequence`s.

template<validator validator1_type, validator validator2_type> requires std::common_with<typename std::remove_reference_t<validator1_type>::option_value_type, typename std::remove_reference_t<validator2_type>::option_value_type>
auto	operator\| (validator1_type &&vali1, validator2_type &&vali2)
	Enables the chaining of validators.

template<typename base_t , std::unsigned_integral exp_t> requires (std::same_as<base_t, uint64_t> \|\| std::same_as<base_t, int64_t>)
base_t	pow (base_t base, exp_t exp)
	Computes the value of `base` raised to the power `exp`.

template<typename index_t , std::ranges::forward_range queries_t, typename configuration_t = decltype(search_cfg::default_configuration)> requires std::ranges::forward_range<std::ranges::range_reference_t<queries_t>> && std::same_as<range_innermost_value_t<queries_t>, typename index_t::alphabet_type>
auto	search (queries_t &&queries, index_t const &index, configuration_t const &cfg=search_cfg::default_configuration)
	Search a query or a range of queries in an index.

template<genetic_code gc = genetic_code::canonical, nucleotide_alphabet nucl_type>
constexpr aa27	translate_triplet (nucl_type const &n1, nucl_type const &n2, nucl_type const &n3) noexcept
	Translate one nucleotide triplet into single amino acid (single nucleotide interface).

template<tuple_like tuple_t>
constexpr auto	tuple_pop_front (tuple_t &&t)
	Removes the first element of a tuple.

template<typename pivot_t , tuple_like tuple_t>
constexpr auto	tuple_split (tuple_t &&t)
	Splits a tuple like data structure at the first position of the given type.

template<size_t pivot_c, template< typename... > typename tuple_t, typename... ts> requires tuple_like<tuple_t<ts...>>
constexpr auto	tuple_split (tuple_t< ts... > &&t)
	Splits a tuple like data structure at the given position.

template<size_t pivot_c, template< typename... > typename tuple_t, typename... ts> requires tuple_like<tuple_t<ts...>>
constexpr auto	tuple_split (tuple_t< ts... > const &t)
	Splits a tuple like data structure at the given position.

Type deduction guides
template<std::ranges::viewable_range urng_t> requires (!std::ranges::view<std::remove_reference_t<urng_t>>)
	gap_decorator (urng_t &&range) -> gap_decorator< std::remove_reference_t< urng_t > const & >
	Ranges (not views!) always deduce to `const & range_type` since they are access-only anyway.

template<std::ranges::view urng_t>
	gap_decorator (urng_t range) -> gap_decorator< urng_t >
	Views always deduce to their respective type because they are copied.

template<size_t capacity2, typename value_type >
	small_vector (value_type const (&array)[capacity2]) -> small_vector< value_type, capacity2 >
	Deducts the size and value type from an built-in array on construction.

Tuple interface
template<template< typename... > class query_t, typename... configs_t>
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 only in what argument(s) it accepts.

template<template< typename... > class query_t, typename... configs_t>
constexpr auto &&	get (configuration< configs_t... > &&config) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<template< typename... > class query_t, typename... configs_t>
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 only in what argument(s) it accepts.

Template argument type deduction guides
template<std::ranges::range text_t>
	bi_fm_index (text_t &&) -> bi_fm_index< range_innermost_value_t< text_t >, text_layout
	Deduces the dimensions of the text.

template<std::ranges::range text_t>
	fm_index (text_t &&) -> fm_index< range_innermost_value_t< text_t >, text_layout
	Deduces the alphabet and dimensions of the text.

Operations on characters
template<builtin_character char_type>
constexpr char_type	to_lower (char_type const c) noexcept
	Converts 'A'-'Z' to 'a'-'z' respectively; other characters are returned as is.

template<builtin_character char_type>
constexpr char_type	to_upper (char_type const c) noexcept
	Converts 'a'-'z' to 'A'-'Z' respectively; other characters are returned as is.

Variables

template<typename alph_t >

constexpr auto alphabet_size = detail::adl_only::alphabet_size_cpo<alph_t>{}()

A type trait that holds the size of a (semi-)alphabet.

debug_stream_type debug_stream {std::cerr}

A global instance of seqan3::debug_stream_type.

template<typename t >

constexpr bool enable_aminoacid

A trait that indicates whether a type shall model seqan3::aminoacid_alphabet.

template<typename config1_t , typename config2_t >

constexpr bool is_config_element_combineable_v = detail::config_element_pipeable_with<config1_t, config2_t>

Helper variable template to test if a configuration element is combineable with another configuration element or configuration.

constexpr auto is_pair_close = detail::adl_only::is_pair_close_cpo{}

Check whether the given character represents a leftward interaction in an RNA structure.

constexpr auto is_pair_open = detail::adl_only::is_pair_open_cpo{}

Check whether the given character represents a rightward interaction in an RNA structure.

constexpr auto is_unpaired = detail::adl_only::is_unpaired_cpo{}

Check whether the given character represents an unpaired nucleotide in an RNA structure.

template<typename alph_t >

constexpr auto max_pseudoknot_depth = detail::adl_only::max_pseudoknot_depth_cpo<alph_t>{}()

A type trait that holds the ability of the structure alphabet to represent pseudoknots, i.e. crossing interactions, up to a certain depth.

constexpr auto pseudoknot_id = detail::adl_only::pseudoknot_id_cpo{}

Retrieve an id for the level of a pseudoknotted interaction (also known as 'page number').

template<typename t >

constexpr size_t range_dimension_v = 1

Returns the number of times you can call seqan3::value_type_t recursively on t (type trait).

constexpr std::size_t seqan3_version = SEQAN3_VERSION

The full version as std::size_t.

constexpr char const * seqan3_version_cstring = SEQAN3_VERSION_CSTRING

The full version as null terminated string.

constexpr uint8_t seqan3_version_major = SEQAN3_VERSION_MAJOR

The major version.

constexpr uint8_t seqan3_version_minor = SEQAN3_VERSION_MINOR

The minor version.

constexpr uint8_t seqan3_version_patch = SEQAN3_VERSION_PATCH

The patch version.

Function objects

constexpr auto to_rank = detail::adl_only::to_rank_cpo{}

Return the rank representation of a (semi-)alphabet object.

constexpr auto assign_rank_to = detail::adl_only::assign_rank_to_cpo{}

Assign a rank to an alphabet object.

constexpr auto to_char = detail::adl_only::to_char_cpo{}

Return the char representation of an alphabet object.

constexpr auto assign_char_to = detail::adl_only::assign_char_to_cpo{}

Assign a character to an alphabet object.

template<typename alph_t >

constexpr auto char_is_valid_for = detail::adl_only::char_is_valid_for_cpo<alph_t>{}

Returns whether a character is in the valid set of a seqan3::alphabet (usually implies a bijective mapping to an alphabet value).

constexpr auto assign_char_strictly_to = detail::adl_only::assign_char_strictly_to_fn{}

Assign a character to an alphabet object, throw if the character is not valid.

Function objects (Nucleotide)

constexpr auto complement = detail::adl_only::complement_cpo{}

Return the complement of a nucleotide object.

Function objects (Quality)

constexpr auto to_phred = detail::adl_only::to_phred_cpo{}

The public getter function for the Phred representation of a quality score.

constexpr auto assign_phred_to = detail::adl_only::assign_phred_to_cpo{}

Assign a Phred score to a quality alphabet object.

Customisation Points

template<typename option_type >

auto const enumeration_names = detail::adl_only::enumeration_names_cpo<option_type>{}()

Return a conversion map from std::string_view to option_type.

Char predicates

Char predicates are function like objects that can be used to check if a character c fulfills certain constraints. SeqAn implements all predicates also available in the standard library and some more.

Disjunction and Negation

In contrast to the standard library (where the checks are implemented as functions), the functors in SeqAn can be joined efficiently, maintaining constant-time evaluation independent of the number of checks. Functors can be combined with the ||-operator or negated via the !-operator:

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#include <iostream>
 
#include <seqan3/utility/char_operations/predicate.hpp>
 
int main()
{
    char chr{'1'};
    constexpr auto my_cond = seqan3::is_char<'%'> || seqan3::is_digit;
    bool is_percent = my_cond(chr);
    std::cout << std::boolalpha << is_percent << '\n'; // true
}

Defining complex combinations and using them in e.g. input/output can increase speed significantly over checking multiple functions: we measured speed-ups of 10x for a single check and speed-ups of over 20x for complex combinations.

Custom predicates

seqan3::is_in_interval: Checks if the given character is within specified range of ASCII characters.
seqan3::is_char: Checks if the character is equal to the specified ASCII character.
seqan3::is_eof: Checks if a character is the end-of-file marker.

Standard library predicates

SeqAn offers the 12 predicates exactly as defined in the standard library except that we have introduced an underscore in the name to be consistent with our other naming.

The following table lists the predefined character predicates and which constraints are associated with them.

ASCII values			characters	`is_cntrl`	`is_print`	`is_space`	`is_blank`	`is_graph`	`is_punct`	`is_alnum`	`is_alpha`	`is_upper`	`is_lower`	`is_digit`	`is_xdigit`
decimal	hexadecimal	octal	characters	`is_cntrl`	`is_print`	`is_space`	`is_blank`	`is_graph`	`is_punct`	`is_alnum`	`is_alpha`	`is_upper`	`is_lower`	`is_digit`	`is_xdigit`
0–8	`\x0`–`\x8`	`\0`–`\10`	control codes (`NUL`, etc.)	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`
9	`\x9`	`\11`	tab (`\t`)	`≠0`	`0`	`≠0`	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`
10–13	`\xA`–`\xD`	`\12`–`\15`	whitespaces (`\n`, `\v`, `\f`, `\r`)	`≠0`	`0`	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`
14–31	`\xE`–`\x1F`	`\16`–`\37`	control codes	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`
32	`\x20`	`\40`	space	`0`	`≠0`	`≠0`	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`
33–47	`\x21`–`\x2F`	`\41`–`\57`	`!"#$%&'()*+,-./`	`0`	`≠0`	`0`	`0`	`≠0`	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`
48–57	`\x30`–`\x39`	`\60`–`\71`	`0123456789`	`0`	`≠0`	`0`	`0`	`≠0`	`0`	`≠0`	`0`	`0`	`0`	`≠0`	`≠0`
58–64	`\x3A`–`\x40`	`\72`–`\100`	`:;<=>?@`	`0`	`≠0`	`0`	`0`	`≠0`	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`
65–70	`\x41`–`\x46`	`\101`–`\106`	`ABCDEF`	`0`	`≠0`	`0`	`0`	`≠0`	`0`	`≠0`	`≠0`	`≠0`	`0`	`0`	`≠0`
71–90	`\x47`–`\x5A`	`\107`–`\132`	`GHIJKLMNOP` `QRSTUVWXYZ`	`0`	`≠0`	`0`	`0`	`≠0`	`0`	`≠0`	`≠0`	`≠0`	`0`	`0`	`0`
91–96	`\x5B`–`\x60`	`\133`–`\140`	[]^_`	`0`	`≠0`	`0`	`0`	`≠0`	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`
97–102	`\x61`–`\x66`	`\141`–`\146`	`abcdef`	`0`	`≠0`	`0`	`0`	`≠0`	`0`	`≠0`	`≠0`	`0`	`≠0`	`0`	`≠0`
103–122	`\x67`–`\x7A`	`\147`–`\172`	`ghijklmnop` `qrstuvwxyz`	`0`	`≠0`	`0`	`0`	`≠0`	`0`	`≠0`	`≠0`	`0`	`≠0`	`0`	`0`
123–126	`\x7B`–`\x7E`	`\172`–`\176`	`{\|}~`	`0`	`≠0`	`0`	`0`	`≠0`	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`
127	`\x7F`	`\177`	backspace character (`DEL`)	`≠0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`	`0`

template<uint8_t interval_first, uint8_t interval_last>

constexpr auto is_in_interval

Checks whether a given letter is in the specified interval.

template<int char_v>

constexpr auto is_char

Checks whether a given letter is the same as the template non-type argument.

constexpr auto is_eof = is_char<EOF>

Checks whether a given letter is equal to the EOF constant defined in <cstdio>.

constexpr auto is_cntrl = is_in_interval<'\0', static_cast<char>(31)> || is_char<static_cast<char>(127)>

Checks whether c is a control character.

constexpr auto is_print = is_in_interval<' ', '~'>

Checks whether c is a printable character.

constexpr auto is_space = is_in_interval<'\t', '\r'> || is_char<' '>

Checks whether c is a space character.

constexpr auto is_blank = is_char<'\t'> || is_char<' '>

Checks whether c is a blank character.

constexpr auto is_graph = is_in_interval<'!', '~'>

Checks whether c is a graphic character.

constexpr auto is_punct

Checks whether c is a punctuation character.

constexpr auto is_alnum = is_in_interval<'0', '9'> || is_in_interval<'A', 'Z'> || is_in_interval<'a', 'z'>

Checks whether c is a alphanumeric character.

constexpr auto is_alpha = is_in_interval<'A', 'Z'> || is_in_interval<'a', 'z'>

Checks whether c is a alphabetical character.

constexpr auto is_upper = is_in_interval<'A', 'Z'>

Checks whether c is a upper case character.

constexpr auto is_lower = is_in_interval<'a', 'z'>

Checks whether c is a lower case character.

constexpr auto is_digit = is_in_interval<'0', '9'>

Checks whether c is a digital character.

constexpr auto is_xdigit = is_in_interval<'0', '9'> || is_in_interval<'A', 'F'> || is_in_interval<'a', 'f'>

Checks whether c is a hexadecimal character.

Detailed Description

The main SeqAn3 namespace.

Enumeration Type Documentation

◆ genetic_code

enum struct seqan3::genetic_code : uint8_t

strong

Genetic codes used for translation of nucleotides into amino acids.

The numeric values of the enums correspond to the genbank transl_table values.

See also: https://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi

This entity is experimental and subject to change in the future. Experimental since version 3.1.

Enumerator
canonical	The Standard Code.

◆ output_file_open_options

enum class seqan3::output_file_open_options

strong

Mode of an output file: Determines whether an existing file can be (silently) overwritten.

Enumerator
open_or_create	Allow to overwrite the output file.
create_new	Forbid overwriting the output file.

◆ translation_frames

enum class seqan3::translation_frames : uint8_t

strong

Specialisation values for single and multiple translation frames.

See also: seqan3::enum_bitwise_operators enables combining enum values.

This entity is experimental and subject to change in the future. Experimental since version 3.1.

Enumerator
forward_frame0	The first forward frame starting at position 0.
forward_frame1	The second forward frame starting at position 1.
forward_frame2	The third forward frame starting at position 2.
reverse_frame0	The first reverse frame starting at position 0.
reverse_frame1	The second reverse frame starting at position 1.
reverse_frame2	The third reverse frame starting at position 2.
forward_reverse0	The first forward and first reverse frame.
forward_reverse1	The second forward and second reverse frame.
forward_reverse2	The first third and third reverse frame.
forward_frames	All forward frames.
reverse_frames	All reverse frames.
six_frames	All frames.

◆ update_notifications

enum class seqan3::update_notifications

strong

Indicates whether application allows automatic update notifications by the seqan3::argument_parser.

Enumerator
on	Automatic update notifications should be enabled.
off	Automatic update notifications should be disabled.

Function Documentation

◆ gap_decorator() [1/2]

template<std::ranges::viewable_range urng_t>
requires (!std::ranges::view<std::remove_reference_t<urng_t>>)

seqan3::gap_decorator ( urng_t && range ) -> gap_decorator< std::remove_reference_t< urng_t > const & >

Ranges (not views!) always deduce to const & range_type since they are access-only anyway.

This entity is experimental and subject to change in the future. Experimental since version 3.1.

◆ gap_decorator() [2/2]

template<std::ranges::view urng_t>

seqan3::gap_decorator ( urng_t range ) -> gap_decorator< urng_t >

Views always deduce to their respective type because they are copied.

This entity is experimental and subject to change in the future. Experimental since version 3.1.

◆ small_vector()

template<size_t capacity2, typename value_type >

seqan3::small_vector ( value_type const (&) array[capacity2] ) -> small_vector< value_type, capacity2 >

Deducts the size and value type from an built-in array on construction.

This entity is experimental and subject to change in the future. Experimental since version 3.1.

◆ to_lower()

template<builtin_character char_type>

constexpr char_type seqan3::to_lower ( char_type const c )

constexprnoexcept

Converts 'A'-'Z' to 'a'-'z' respectively; other characters are returned as is.

Template Parameters

char_type Type of the parameter; must model seqan3::builtin_character.

Parameters

c	The parameter.

Returns: The character converted to lower case.

In contrast to std::tolower this function is independent of locale and can be evaluated in a constexpr context.

◆ to_upper()

template<builtin_character char_type>

constexpr char_type seqan3::to_upper ( char_type const c )

constexprnoexcept

Converts 'a'-'z' to 'A'-'Z' respectively; other characters are returned as is.

Template Parameters

char_type Type of the parameter; must model seqan3::builtin_character.

Parameters

c	The parameter.

Returns: The character converted to upper case.

In contrast to std::to_upper this function is independent of locale and can be evaluated in a constexpr context.

◆ tuple_split()

template<size_t pivot_c, template< typename... > typename tuple_t, typename... ts>
requires tuple_like<tuple_t<ts...>>

constexpr auto seqan3::tuple_split ( tuple_t< ts... > && t )

constexpr

Splits a tuple like data structure at the given position.

Template Parameters

pivot_c	A template value specifying the split position.
tuple_t	A template alias for a tuple like object.
...ts	Types `tuple_t` is specified with.

Parameters

[in] t The original tuple to split.

Returns: A new tuple of tuples with the left side of the split and the right side of the split.

Splits a tuple into two tuples, while the element at the split position will be contained in the second tuple. Note, that the returned tuples can be empty. For this reason it is not possible to use tuple like objects, that cannot be empty, i.e. std::pair. Using such an object will emit an compiler error.

example

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: CC0-1.0
 
#include <seqan3/utility/tuple/split.hpp>
 
int main()
{
    // Split at position 2.
    std::tuple<int, char, float, std::string> t{1, 'c', 0.3, "hello"};
    auto [left, right] = seqan3::tuple_split<2>(t);
    static_assert(std::same_as<decltype(left), std::tuple<int, char>>);
    static_assert(std::same_as<decltype(right), std::tuple<float, std::string>>);
 
    // Split at position 0.
    auto [left1, right1] = seqan3::tuple_split<0>(t);
    static_assert(std::same_as<decltype(left1), std::tuple<>>);
    static_assert(std::same_as<decltype(right1), std::tuple<int, char, float, std::string>>);
 
    // Split at position 4.
    auto [left2, right2] = seqan3::tuple_split<4>(t);
    static_assert(std::same_as<decltype(left2), std::tuple<int, char, float, std::string>>);
    static_assert(std::same_as<decltype(right2), std::tuple<>>);
}

Complexity

Linear in the number of elements.

Thread safety

Concurrent invocations of this functions are thread safe.

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Disjunction and Negation

Custom predicates

Standard library predicates

Detailed Description

Enumeration Type Documentation

◆ genetic_code

◆ output_file_open_options

◆ translation_frames

◆ update_notifications

Function Documentation

◆ gap_decorator() [1/2]

◆ gap_decorator() [2/2]

◆ small_vector()

◆ to_lower()

◆ to_upper()

◆ tuple_split()

example

Complexity

Thread safety