Composition

Meta-header for the composition submodule; includes all headers from alphabet/composition/. composition.

Author
Marcel Ehrhardt <marcel.ehrhardt AT fu-berlin.de>

Contains cartesian_composition.

Author
Hannes Hauswedell <hannes.hauswedell AT fu-berlin.de>

namespace seqan3

The main SeqAn3 namespace.

Helpers for seqan3::semi_alphabet_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::semi_alphabet_concept.

Helpers for seqan3::alphabet_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::alphabet_concept.

Helpers for seqan3::nucleotide_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::nucleotide_concept.

Alphabet aliases

Other names (typedefs) for seqan3::nucl16

Range concepts

Adapted from the Ranges TS.

Container concepts

Container concepts as defined by the standard library (or very close).

Container-of-container concepts

Shortcuts for multi-dimensional container concepts.

template <typename derived_type, typename first_alphabet_type, typename... alphabet_types>
struct cartesian_composition
#include <alphabet/composition/cartesian_composition.hpp>

The CRTP base of alphabets that contain multiple (different) letters at one position.

This data structure is CRTP base class for combined alphabets, where the different alphabet letters exist independently, similar to a tuple. In fact this class provides a tuple-like interface with get<0>(t) and objects can be brace-initialized with the individual members.

Template Parameters
  • first_alphabet_type: Type of the first letter; must satisfy alphabet_concept.
  • alphabet_types: Types of further letters (up to 4); must satisfy alphabet_concept.

To make a derived class “complete”, you should add at least the following:

Attention
This is a “pure base class”, you cannot instantiate it, you can only inherit from it. Most likely you are interested in using one of it’s descendents like quality_composition.

See
quality_composition
See
mask_composition

Inherits from seqan3::pod_tuple< first_alphabet_type, alphabet_types... >

Read functions

constexpr rank_type to_rank() const

Return the letter combination’s numeric value (or “rank”) in the alphabet composition.

Complexity
Linear in the number of alphabets.

template <typename type>
constexpr operator type() const

Explicit cast to a single letter. Works only if the type is unique in the type list.

Complexity
Linear in the number of alphabets.

Write functions

constexpr derived_type &assign_rank(rank_type const i)

Assign from a numeric value.

Complexity
Linear in the number of alpahabets.
Exceptions
Asserts that the parameter is smaller than value_size [only in debug mode].

Comparison operators

Lexicographically compares the values in the tuple.

Public Types

template<>
using rank_type = detail::min_viable_uint_t<(alphabet_size_v<first_alphabet_type> * ... * alphabet_size_v<alphabet_types>)>

The type of value_size and alphabet_size_v<cartesian_composition<...>>

Public Static Attributes

constexpr rank_type value_size = {(alphabet_size_v<first_alphabet_type> * ... * alphabet_size_v<alphabet_types>)}

The product of the sizes of the individual alphabets.

Private Functions

cartesian_composition()

declared private to prevent direct use of the CRTP base

constexpr cartesian_composition(cartesian_composition const&)

declared private to prevent direct use of the CRTP base

constexpr cartesian_composition(cartesian_composition&&)

declared private to prevent direct use of the CRTP base

constexpr cartesian_composition &operator=(cartesian_composition const&)

declared private to prevent direct use of the CRTP base

constexpr cartesian_composition &operator=(cartesian_composition&&)

declared private to prevent direct use of the CRTP base

~cartesian_composition()

declared private to prevent direct use of the CRTP base

template <std::size_t... idx>
constexpr rank_type to_rank_impl(std::index_sequence<idx...> const&) const

Implementation of to_rank().

template <std::size_t j>
constexpr void assign_rank_impl(rank_type const i)

Implementation of assign_rank().

Private Members

friend seqan3::cartesian_composition::derived_type

befriend the derived type so that it can instantiate

See
https://isocpp.org/blog/2017/04/quick-q-prevent-user-from-derive-from-incorrect-crtp-base

Private Static Attributes

constexpr std::array<rank_type, sizeof...(alphabet_types) + 1> cummulative_alph_sizes = { [] () constexpr { std::array<rank_type, sizeof...(alphabet_types) + 1> ret{}; size_t count = 0; meta::for_each(meta::list<first_alphabet_type, alphabet_types...>{}, [&] (auto && alph) constexpr { ret[count] = static_cast<rank_type>( alphabet_size_v<std::decay_t<decltype(alph)>> * (count > 0 ? ret[count - 1] : 1)); ++count; }); return std::move(ret); }() }

the cummulative alphabet size products (first, first*second, first*second*third...) are cached

constexpr auto positions = std::make_index_sequence<sizeof...(alphabet_types)>{}

An index sequence up to the number of contained letters.

Contains seqan3::union_composition.

Author
Marcel Ehrhardt <marcel.ehrhardt AT fu-berlin.de>
Author
David Heller <david.heller AT fu-berlin.de>

namespace seqan3

The main SeqAn3 namespace.

Helpers for seqan3::semi_alphabet_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::semi_alphabet_concept.

Helpers for seqan3::alphabet_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::alphabet_concept.

Helpers for seqan3::nucleotide_concept

These functions and metafunctions expose member variables and types so that they satisfy seqan3::nucleotide_concept.

Alphabet aliases

Other names (typedefs) for seqan3::nucl16

Range concepts

Adapted from the Ranges TS.

Container concepts

Container concepts as defined by the standard library (or very close).

Container-of-container concepts

Shortcuts for multi-dimensional container concepts.

template <typename first_alphabet_type, typename... alphabet_types>
class union_composition
#include <alphabet/composition/union_composition.hpp>

A composition that merges different regular alphabets as a single alphabet.

The union alphabet represents the union of two or more alphabets (e.g. the four letter DNA alphabet + the gap alphabet). Note that you cannot assign regular characters, but additional functions for this are available.

Template Parameters
  • first_alphabet_type: Type of the first letter, e.g. dna4; must satisfy seqan3::alphabet_concept.
  • alphabet_types: Types of further letters; must satisfy seqan3::alphabet_concept.

This class has a similar behavior as std::variant.

union_composition<dna4, gap> my_letter{};
union_composition<dna4, gap> converted_letter{dna4::C};
// doesn't work:
// union_composition<dna4, gap> my_letter{'A'};

union_composition<dna4, gap>{}.assign_char('C'); // <- this does!
union_composition<dna4, gap>{}.assign_char('-'); // gap character
union_composition<dna4, gap>{}.assign_char('K'); // unknown characters map to the default/unknown
                                              // character of the first alphabet type (i.e. A of dna4)
if (my_letter.to_char() == 'A')
   std::cout << "yeah\n"; // "yeah";

The union alphabet can also be constructed directly from one of the base alphabets.

using alphabet_t = union_composition<dna4, dna5, gap>;

constexpr alphabet_t letter0{dna4::A};
constexpr alphabet_t letter1 = dna4::C;
constexpr alphabet_t letter2 = {dna4::G};
constexpr alphabet_t letter3 = static_cast<alphabet_t>(dna4::T);

assert(letter0.to_rank() == 0);
assert(letter1.to_rank() == 1);
assert(letter2.to_rank() == 2);
assert(letter3.to_rank() == 3);

Or can be assigned by one of the base alphabets.

using alphabet_t = union_composition<dna4, dna5, gap>;

alphabet_t letter;

letter = dna5::A;
assert(letter.to_rank() == 4);

letter = {dna5::C};
assert(letter.to_rank() == 5);

letter = static_cast<alphabet_t>(dna5::G);
assert(letter.to_rank() == 6);

Default constructors

constexpr union_composition()
constexpr union_composition(union_composition const&)
constexpr union_composition(union_composition&&)

Default assignment operators

constexpr union_composition &operator=(union_composition const&)
constexpr union_composition &operator=(union_composition&&)

Conversion constructors

template <typename alphabet_t>
constexpr union_composition(alphabet_t const &alphabet)

Construction via a value of the base alphabets. 

union_composition<dna4, gap> letter1{dna4::C}; // or
union_composition<dna4, gap> letter2 = gap::GAP;
Template Parameters
  • alphabet_t: One of the base alphabet types

template <size_t I, typename alphabet_t>
constexpr union_composition(std::in_place_index_t<I>, alphabet_t const &alphabet)

Construction via a value of reoccurring alphabets. 

using alphabet_t = union_composition<dna4, dna4>;

constexpr alphabet_t letter0{std::in_place_index_t<0>{}, dna4::A};
constexpr alphabet_t letter4{std::in_place_index_t<1>{}, dna4::A};

EXPECT_EQ(letter0.to_rank(), 0);
EXPECT_EQ(letter4.to_rank(), 4);
Template Parameters
  • I: The index of the i-th base alphabet
  • alphabet_t: The i-th given base alphabet type

Conversion assignment operators

template <typename alphabet_t>
constexpr union_composition &operator=(alphabet_t const &alphabet)

Assignment via a value of the base alphabets. 

union_composition<dna4, gap> letter1{};
letter1 = gap::GAP;
Template Parameters
  • alphabet_t: One of the base alphabet types

Read functions

constexpr char_type to_char() const

Return the letter as a character of char_type.

constexpr rank_type to_rank() const

Return the letter’s numeric value or rank in the alphabet.

Write functions

constexpr union_composition &assign_char(char_type const c)

Assign from a character.

constexpr union_composition &assign_rank(rank_type const i)

Assign from a numeric value.

Comparison operators

constexpr bool operator==(union_composition const &rhs) const
constexpr bool operator!=(union_composition const &rhs) const
constexpr bool operator<(union_composition const &rhs) const
constexpr bool operator>(union_composition const &rhs) const
constexpr bool operator<=(union_composition const &rhs) const
constexpr bool operator>=(union_composition const &rhs) const

Public Types

template<>
using char_type = typename first_alphabet_type::char_type

The type of the alphabet when converted to char (e.g. via to_char)

template<>
using rank_type = detail::min_viable_uint_t<value_size>

The type of the alphabet when represented as a number (e.g. via to_rank)

Public Static Functions

template <typename alphabet_t>
static constexpr bool has_type()

Returns true if alphabet_t is one of the given alphabet types.

Template Parameters
  • alphabet_t: The type to check

Public Static Attributes

constexpr size_t value_size = (alphabet_types::value_size + ... + first_alphabet_type::value_size)

The size of the alphabet, i.e. the number of different values it can take.

Private Members

rank_type _value

The data member.

Private Static Functions

template <size_t index, typename alphabet_t>
static constexpr rank_type rank_by_index_(alphabet_t const &alphabet)

Converts an object of one of the given alphabets into the internal representation.

template <typename alphabet_t>
static constexpr rank_type rank_by_type_(alphabet_t const &alphabet)

Converts an object of one of the given alphabets into the internal representation.

Finds the index of alphabet_t in the given types.

Private Static Attributes

constexpr auto prefix_sum_sizes

Compile-time generated lookup table which contains the prefix sum up to the position of each alphabet.

See
alphabet_prefix_sum_sizes

constexpr auto value_to_char

Compile-time generated lookup table which maps the rank to char.

See
value_to_char_table

constexpr auto char_to_value

Compile-time generated lookup table which maps the char to rank.

See
char_to_value_table

Related

template <typename... alphabet_types>
constexpr auto alphabet_prefix_sum_sizes()

Returns an array which contains the prefix sum over all alphabet_types::value_size’s. 

using namespace seqan3::detail;

constexpr auto prefix_sum = alphabet_prefix_sum_sizes<dna4, gap, dna5>();
assert(prefix_sum.size() == 4);
assert(prefix_sum[0] == 0);
assert(prefix_sum[1] == 4);
assert(prefix_sum[2] == 5);
assert(prefix_sum[3] == 10);

template <typename char_t, typename... alphabet_types>
constexpr auto value_to_char_table()

Returns an map at compile time where the key is the rank of the union of all alphabets and the value is the corresponding char of that rank and alphabet. 

using namespace seqan3::detail::union_composition;

constexpr auto value_to_char = value_to_char_table<char, dna4, gap, dna5>();
assert(value_to_char.size() == 10);
assert(value_to_char[0] == 'A');
assert(value_to_char[1] == 'C');
assert(value_to_char[2] == 'G');
assert(value_to_char[3] == 'T');
assert(value_to_char[4] == '-');
assert(value_to_char[5] == 'A');
assert(value_to_char[6] == 'C');
// and so on

template <typename char_t, typename... alphabet_types>
constexpr auto char_to_value_table()

Returns an map at compile time where the key is the char of one of the alphabets and the value is the corresponding rank over all alphabets (by conflict will default to the first). 

using namespace seqan3::detail::union_composition;

constexpr auto char_to_value = char_to_value_table<char, dna4, gap, dna5>();
assert(char_to_value.size() == 256);
assert(char_to_value['A'] == 0);
assert(char_to_value['C'] == 1);
assert(char_to_value['G'] == 2);
assert(char_to_value['T'] == 3);
assert(char_to_value['-'] == 4);
assert(char_to_value['A'] == 0);
assert(char_to_value['C'] == 1);
assert(char_to_value['G'] == 2);
assert(char_to_value['T'] == 3);
assert(char_to_value['N'] == 9);
assert(char_to_value['*'] == 0); // every other character defaults to 0

namespace detail

The internal SeqAn3 namespace.

The contents of this namespace are not visible to consumers of the library and the documentation is only generated for developers.

See
https://github.com/seqan/seqan3/wiki/Documentation

namespace union_composition

Functions

template <size_t max_value_size, typename char_t, typename alphabet_t>
constexpr auto value_to_char_table_I(alphabet_t alphabet)

Returns an fixed sized map at compile time where the key is the rank of alphabet_t and the value is the corresponding char of that rank. 

using namespace seqan3::detail::union_composition;

constexpr auto table1 = value_to_char_table_I<5, char>(dna4{});
assert(table1.size() == 5);
assert(table1[0] == 'A');
assert(table1[1] == 'C');
assert(table1[2] == 'G');
assert(table1[3] == 'T');
assert(table1[4] == '\0');
See
value_to_char_table