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

#include <seqan3/alphabet/structure/wuss.hpp>

Inheritance diagram for seqan3::wuss< SIZE >:

Public Member Functions
constexpr char_type	to_char () const noexcept
	Return the letter as a character of char_type.

constexpr rank_type	to_rank () const noexcept
	Return the letter's numeric value (rank in the alphabet).

Constructors, destructor and assignment
constexpr	wuss () noexcept=default
	Defaulted.

constexpr	wuss (wuss const &) noexcept=default
	Defaulted.

constexpr	wuss (wuss &&) noexcept=default
	Defaulted.

constexpr wuss &	operator= (wuss const &) noexcept=default
	Defaulted.

constexpr wuss &	operator= (wuss &&) noexcept=default
	Defaulted.

	~wuss () noexcept=default
	Defaulted.

Public Member Functions inherited from seqan3::alphabet_base< derived_type, size, char_t >
constexpr	alphabet_base () noexcept=default
	Defaulted.

constexpr	alphabet_base (alphabet_base const &) noexcept=default
	Defaulted.

constexpr	alphabet_base (alphabet_base &&) noexcept=default
	Defaulted.

constexpr alphabet_base &	operator= (alphabet_base const &) noexcept=default
	Defaulted.

constexpr alphabet_base &	operator= (alphabet_base &&) noexcept=default
	Defaulted.

	~alphabet_base () noexcept=default
	Defaulted.

constexpr char_type	to_char () const noexcept
	Return the letter as a character of char_type.

constexpr rank_type	to_rank () const noexcept
	Return the letter's numeric value (rank in the alphabet).

constexpr derived_type &	assign_char (char_type const chr) noexcept
	Assign from a character, implicitly converts invalid characters.

constexpr derived_type &	assign_rank (rank_type const c) noexcept
	Assign from a numeric value.

Static Public Attributes
static constexpr detail::min_viable_uint_t< size >	alphabet_size
	The size of the alphabet, i.e. the number of different values it can take.

Static Public Attributes inherited from seqan3::alphabet_base< derived_type, size, char_t >
static constexpr detail::min_viable_uint_t< size >	alphabet_size = size
	The size of the alphabet, i.e. the number of different values it can take.

Protected Types
using	char_type = std::conditional_t< std::same_as< char_t, void >, char, char_t >
	The char representation; conditional needed to make semi alphabet definitions legal.

using	rank_type = detail::min_viable_uint_t< size - 1 >
	The type of the alphabet when represented as a number (e.g. via to_rank()).

Protected Types inherited from seqan3::alphabet_base< derived_type, size, char_t >
using	char_type = std::conditional_t< std::same_as< char_t, void >, char, char_t >
	The char representation; conditional needed to make semi alphabet definitions legal.

using	rank_type = detail::min_viable_uint_t< size - 1 >
	The type of the alphabet when represented as a number (e.g. via to_rank()).

Private Types
using	base_t = alphabet_base< wuss< SIZE >, SIZE >
	The base class.

Static Private Member Functions
static constexpr rank_type	char_to_rank (char_type const chr)
	Returns the rank representation of character.

static constexpr char_type	rank_to_char (rank_type const rank)
	Returns the character representation of rank.

Private Attributes
friend	base_t
	Befriend seqan3::alphabet_base.

Static Private Attributes
static constexpr std::array< rank_type, 256 >	char_to_rank_table
	The lookup table used in char_to_rank.

static constexpr std::array< int8_t, SIZE >	interaction_tab
	Lookup table for interactions: unpaired (0), pair-open (< 0), pair-close (> 0). Paired brackets have the same absolute value.

static constexpr std::array< char_type, alphabet_size >	rank_to_char_table
	The lookup table used in rank_to_char.

Related Symbols
(Note that these are not member symbols.)
using	wuss51 = wuss< 51 >
	Alias for the default type wuss51.

Structure literals
constexpr wuss51	operator""_wuss51 (char const ch) noexcept
	The seqan3::wuss51 char literal.

constexpr std::vector< wuss51 >	operator""_wuss51 (char const *str, std::size_t len)
	The seqan3::wuss51 string literal.

Related Symbols inherited from semialphabet
template<cereal_output_archive archive_t, semialphabet alphabet_t>
alphabet_rank_t< alphabet_t >	save_minimal (archive_t const &, alphabet_t const &l)
	Save an alphabet letter to stream.

template<cereal_input_archive archive_t, typename wrapped_alphabet_t >
void	load_minimal (archive_t const &, wrapped_alphabet_t &&l, alphabet_rank_t< detail::strip_cereal_wrapper_t< wrapped_alphabet_t > > const &r)
	Restore an alphabet letter from a saved rank.

RNA structure properties
static constexpr uint8_t	max_pseudoknot_depth {static_cast<uint8_t>((alphabet_size - 7) / 2)}
	The ability of this alphabet to represent pseudoknots, i.e. crossing interactions, up to a certain depth. It is the number of distinct pairs of interaction symbols the format supports: 4..30 (depends on size)

constexpr bool	is_pair_open () const noexcept
	Check whether the character represents a rightward interaction in an RNA structure.

constexpr bool	is_pair_close () const noexcept
	Check whether the character represents a leftward interaction in an RNA structure.

constexpr bool	is_unpaired () const noexcept
	Check whether the character represents an unpaired position in an RNA structure.

constexpr std::optional< uint8_t >	pseudoknot_id () const noexcept
	Get an identifier for a pseudoknotted interaction, where opening and closing brackets of the same type have the same id.

Detailed Description

template<uint8_t SIZE = 51>
class seqan3::wuss< SIZE >

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

Template Parameters

SIZE	The alphabet size defaults to 51 and must be an odd number in range 15..67. It determines the allowed pseudoknot depth by adding characters AaBb..Zz to the alphabet.

The symbols .:,-_~; denote unpaired characters, brackets <>()[]{} represent base pair interactions and AaBbCcDd... form pseudoknots in the structure. The default alphabet has size 51 (letters until Rr). The size can be varied with the optional template parameter between 15 (no letters for pseudoknots) and 67 (all Aa-Zz for pseudoknots).

<<<___>>>,,<<<__>>>

<<<<_AAAA____>>>>aaaa

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/alphabet/structure/wuss.hpp>
#include <seqan3/core/debug_stream.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::wuss51 letter{':'_wuss51};
 
    letter.assign_char('~');
    seqan3::debug_stream << letter << '\n'; // prints "~"
 
    letter.assign_char('#');                // Unknown characters are implicitly converted to ';'.
    seqan3::debug_stream << letter << '\n'; // prints ";"
}

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

Member Typedef Documentation

◆ char_type

template<uint8_t SIZE = 51>

using seqan3::alphabet_base< derived_type, size, char_t >::char_type = std::conditional_t<std::same_as<char_t, void>, char, char_t>

protected

The char representation; conditional needed to make semi alphabet definitions legal.

We need a return type for seqan3::alphabet_base::to_char and seqan3::alphabet_base::assign_char other than void to make these in-class definitions valid when char_t is void.

Attention: Please use seqan3::alphabet_char_t to access this type.

This entity is stable. Since version 3.1.

◆ rank_type

template<uint8_t SIZE = 51>

using seqan3::alphabet_base< derived_type, size, char_t >::rank_type = detail::min_viable_uint_t<size - 1>

protected

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

Attention: Please use seqan3::alphabet_rank_t to access this type.

This entity is stable. Since version 3.1.

Member Function Documentation

◆ char_to_rank()

template<uint8_t SIZE = 51>

static constexpr rank_type seqan3::wuss< SIZE >::char_to_rank ( char_type const chr )

inlinestaticconstexprprivate

Returns the rank representation of character.

This function is required by seqan3::alphabet_base.

◆ is_pair_close()

template<uint8_t SIZE = 51>

constexpr bool seqan3::wuss< SIZE >::is_pair_close ( ) const

inlineconstexprnoexcept

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

Returns: True if the letter represents a leftward interaction, False otherwise.

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

◆ is_pair_open()

template<uint8_t SIZE = 51>

constexpr bool seqan3::wuss< SIZE >::is_pair_open ( ) const

inlineconstexprnoexcept

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

Returns: True if the letter represents a rightward interaction, False otherwise.

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

◆ is_unpaired()

template<uint8_t SIZE = 51>

constexpr bool seqan3::wuss< SIZE >::is_unpaired ( ) const

inlineconstexprnoexcept

Check whether the character represents an unpaired position in an RNA structure.

Returns: True if the letter represents an unpaired site, False otherwise.

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

◆ pseudoknot_id()

template<uint8_t SIZE = 51>

constexpr std::optional< uint8_t > seqan3::wuss< SIZE >::pseudoknot_id ( ) const

inlineconstexprnoexcept

Get an identifier for a pseudoknotted interaction, where opening and closing brackets of the same type have the same id.

Returns: The pseudoknot id, if alph denotes an interaction, and no value otherwise.

It is guaranteed to be smaller than seqan3::max_pseudoknot_depth.

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

◆ rank_to_char()

template<uint8_t SIZE = 51>

static constexpr char_type seqan3::wuss< SIZE >::rank_to_char ( rank_type const rank )

inlinestaticconstexprprivate

Returns the character representation of rank.

This function is required by seqan3::alphabet_base.

◆ to_char()

template<uint8_t SIZE = 51>

constexpr char_type seqan3::alphabet_base< derived_type, size, char_t >::to_char ( ) const

inlineconstexprnoexcept

Return the letter as a character of char_type.

Provides an implementation for seqan3::to_char, required to model seqan3::alphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

This entity is stable. Since version 3.1.

◆ to_rank()

template<uint8_t SIZE = 51>

constexpr rank_type seqan3::alphabet_base< derived_type, size, char_t >::to_rank ( ) const

inlineconstexprnoexcept

Return the letter's numeric value (rank in the alphabet).

Provides an implementation for seqan3::to_rank, required to model seqan3::semialphabet.

Complexity

Constant.

Exceptions

Guaranteed not to throw.

This entity is stable. Since version 3.1.

Friends And Related Symbol Documentation

◆ operator""_wuss51() [1/2]

template<uint8_t SIZE = 51>

constexpr std::vector< wuss51 > operator""_wuss51	(	char const *	str,
		std::size_t	len
	)

Parameters

[in]	str	A pointer to the character string to assign.
[in]	len	The size of the character string to assign.

Returns: std::vector<seqan3::wuss51>

You can use this string literal to easily assign to std::vector<seqan3::wuss51>:

// 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/alphabet/structure/wuss.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    std::vector<seqan3::wuss51> sequence1{".<..>."_wuss51};
    std::vector<seqan3::wuss51> sequence2 = ".<..>."_wuss51;
    auto sequence3 = ".<..>."_wuss51;
}

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

◆ operator""_wuss51() [2/2]

template<uint8_t SIZE = 51>

constexpr wuss51 operator""_wuss51 ( char const ch )

Parameters

[in] ch The character to represent as wuss.

Returns: seqan3::wuss51

You can use this char literal to assign a seqan3::wuss51 character:

// 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/alphabet/structure/wuss.hpp>
 
int main()
{
    using namespace seqan3::literals;
 
    seqan3::wuss51 letter1{'('_wuss51};
    auto letter2 = '('_wuss51;
}

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

Member Data Documentation

◆ alphabet_size

template<uint8_t SIZE = 51>

constexpr detail::min_viable_uint_t<size> seqan3::alphabet_base< derived_type, size, char_t >::alphabet_size

staticconstexpr

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

This entity is stable. Since version 3.1.

◆ char_to_rank_table

template<uint8_t SIZE = 51>

constexpr std::array<rank_type, 256> seqan3::wuss< SIZE >::char_to_rank_table

staticconstexprprivate

Initial value:

{
        []() constexpr {
            std::array<rank_type, 256> rank_table{};
 
            rank_table.fill(6u);
 
            
            for (rank_type rnk = 0u; rnk < alphabet_size; ++rnk)
                rank_table[rank_to_char_table[rnk]] = rnk;
 
            return rank_table;
        }()
    }

The lookup table used in char_to_rank.

We would have defined these lookup tables directly within their respective constexpr functions, but at the time of writing this, gcc did not (clang >= 4 did!) auto-generate lookup tables.

static constexpr char_type rank_to_char(rank_type const rank)
{
    // not possible because of static not being allowed within a constexpr function
    static constexpr lookup_table = ...;
    return lookup_table[rank];
}
 
static constexpr char_type rank_to_char(rank_type const rank)
{
    // up-to the compiler to optimise, no guarantee that a lookup table is used.
    constexpr lookup_table = ...;
    return lookup_table[rank];
}

See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99320 for the progress on gcc

◆ interaction_tab

template<uint8_t SIZE = 51>

constexpr std::array<int8_t, SIZE> seqan3::wuss< SIZE >::interaction_tab

staticconstexprprivate

Initial value:

{
        []() constexpr {
            static_assert(static_cast<int16_t>(std::numeric_limits<int8_t>::max()) >= SIZE);
            static_assert(- static_cast<int16_t>(std::numeric_limits<int8_t>::min()) >= SIZE);
 
            std::array<int8_t, alphabet_size> interaction_table{};
            int8_t cnt_open = 0;
            int8_t cnt_close = 0;
 
            for (rank_type rnk = 0u; rnk <= 6u; ++rnk)
                interaction_table[rnk] = 0;
 
            for (rank_type rnk = 7u; rnk <= 10u; ++rnk)
                interaction_table[rnk] = --cnt_open;
 
            for (rank_type rnk = 11u; rnk <= 14u; ++rnk)
                interaction_table[rnk] = ++cnt_close;
 
            for (rank_type rnk = 15u; rnk + 1u < alphabet_size; rnk += 2u)
            {
                interaction_table[rnk] = --cnt_open;
                interaction_table[rnk + 1u] = ++cnt_close;
            }
 
            return interaction_table;
        }()
    }

Lookup table for interactions: unpaired (0), pair-open (< 0), pair-close (> 0). Paired brackets have the same absolute value.

◆ max_pseudoknot_depth

template<uint8_t SIZE = 51>

constexpr uint8_t seqan3::wuss< SIZE >::max_pseudoknot_depth {static_cast<uint8_t>((alphabet_size - 7) / 2)}

staticconstexpr

The ability of this alphabet to represent pseudoknots, i.e. crossing interactions, up to a certain depth. It is the number of distinct pairs of interaction symbols the format supports: 4..30 (depends on size)

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

◆ rank_to_char_table

template<uint8_t SIZE = 51>

constexpr std::array<char_type, alphabet_size> seqan3::wuss< SIZE >::rank_to_char_table

staticconstexprprivate

Initial value:

{
        []() constexpr {
            std::array<char_type, alphabet_size> chars{'.', ':', ',', '-', '_', '~', ';', '<', '(', '[', '{', '>', ')',
                                                       ']', '}'};
 
            
            for (rank_type rnk = 15u; rnk + 1u < alphabet_size; rnk += 2u)
            {
                char_type const off = static_cast<char_type>((rnk - 15u) / 2u);
                chars[rnk] = 'A' + off;
                chars[rnk + 1u] = 'a' + off;
            }
 
            return chars;
        }()
    }

The lookup table used in rank_to_char.

We would have defined these lookup tables directly within their respective constexpr functions, but at the time of writing this, gcc did not (clang >= 4 did!) auto-generate lookup tables.

static constexpr char_type rank_to_char(rank_type const rank)
{
    // not possible because of static not being allowed within a constexpr function
    static constexpr lookup_table = ...;
    return lookup_table[rank];
}
 
static constexpr char_type rank_to_char(rank_type const rank)
{
    // up-to the compiler to optimise, no guarantee that a lookup table is used.
    constexpr lookup_table = ...;
    return lookup_table[rank];
}

See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99320 for the progress on gcc

The documentation for this class was generated from the following file:

wuss.hpp

Public Member Functions

Static Public Attributes

Protected Types

Private Types

Static Private Member Functions

Private Attributes

Static Private Attributes

Related Symbols

RNA structure properties

Detailed Description

Example

Member Typedef Documentation

◆ char_type

◆ rank_type

Member Function Documentation

◆ char_to_rank()

◆ is_pair_close()

◆ is_pair_open()

◆ is_unpaired()

◆ pseudoknot_id()

◆ rank_to_char()

◆ to_char()

Complexity

Exceptions

◆ to_rank()

Complexity

Exceptions

Friends And Related Symbol Documentation

◆ operator""_wuss51() [1/2]

◆ operator""_wuss51() [2/2]

Member Data Documentation

◆ alphabet_size

◆ char_to_rank_table

◆ interaction_tab

◆ max_pseudoknot_depth

◆ rank_to_char_table