SeqAn3 3.1.0
The Modern C++ library for sequence analysis.
Changelog

This changelog contains a top-level entry for each release with sections on new features, API changes and notable bug-fixes (not all bug-fixes will be listed).

Get to know SeqAn3 with our tutorials.

Please see the release announcement: https://www.seqan.de/announcing-seqan3/

See the porting guide for some help on porting: https://docs.seqan.de/seqan/3-master-user/howto_porting.html

See the documentation on API stability to learn about when API changes are allowed.

3.1.0

New features

Build system

  • We now use Doxygen version 1.9.2 to build our documentation (#2765).

Notable Bug-fixes

Argument Parser

  • Fixed an issue that led to the wrong option type being printed on errors (#2836).

Search

  • Resolved an issue that prevented the FM-Index from being constructed correctly for inputs larger than 4 GiB (#2756).

API changes

The files deprecated in 3.0.3 (denoted by [deleted without replacement]) have been removed.

3.0.3

Note that 3.1.0 will be the first API stable release and interfaces in this release might still change.

  • Check out our updated SeqAn3 Cookbook. It contains a listing of code examples on how to perform particular tasks using the library.
  • SeqAn 3.0.3 is known to compile with GCC 7.5, 8.4, 9.3, 10.3, and 11.1. Future versions (e.g. GCC 11.2 and 12) might work, but were not yet available at the time of this release.

New features

Alphabet

  • Added seqan3::phred94, a quality type that represents the full Phred Score range (Sanger format) and is used for PacBio Phred scores of HiFi reads (#2290).

Argument Parser

Build system

  • We now use Doxygen version 1.9.1 to build our documentation (#2327).

I/O

  • Explicit record-classes with explicit member accessor for our file implementations. We added seqan3::sequence_record for seqan3::sequence_file_(in|out)put, seqan3::sam_record for seqan3::sam_file_(in|out)put and seqan3::structure_record for seqan3::structure_file_(in|out)put. You can now access the id in a sequence file (e.g. fasta file) record via record.id() instead of seqan3::get<seqan3::field::id>(record). This will allow us to add convenient functions that compute information based on the record itself and to provide better documentation. (#2340, #2380, #2389)

Search

Notable Bug-fixes

Argument Parser

Range

  • The seqan3::views::kmer_hash does not return wrong values when combined with std::views::reverse on a text of the same size as the kmer (#2416).

I/O

  • The SAM/BAM format reads the quality field (or any other text field) that starts with an asterisk (*) but is not empty correctly now (#2184).
  • Requesting the alignment without also requesting the sequence for BAM files containing empty CIGAR strings does now not result in erroneous parsing (#2418).
  • BAM files with 64 references are now parsed correctly (#2423).
  • BAM files not containing a plain text header are now accepted (#2536).
  • Writing gz-compressed output no longer results in bgzf-compressed output. This change may have following effects (#2458):
    • A noticeable slowdown when writing gz-compressed content since, in contrast to bgzf, gz does not feature parallelisation (magnitude depends on the application and level of parallelisation).
    • A reduced output size when writing gz-compressed content due to gz storing less metadata than bgzf (up to 20% smaller file size).
    • The processed data should experience no negative effects since gz and bgzf are fully compatible.
    • This bug may also cause unexpected parallelisation when reading gz-compressed input. This is the case when the gz-compressed input was also generated with SeqAn.
  • The following requirements of parsing a SAM/BAM header where relaxed as they were in violation of the specification (#2605):
    • The order of tags within the header may be arbitrary. Before, necessary tags where required to be first.
    • Unknown tags will emit a warning. Before, a error was raised.

API changes

Most of our API or header file changes will trigger a deprecation warning to let you know if something changed and, if applicable, when it will be removed. We recommend upgrading version-by-version to check whether you need to change code. You can either directly check the reported code or verify with our documentation how the new API should be used.

For a complete list of behavioural changes in our public and internal API, you can consult our API stability regression test suite and patches at https://github.com/seqan/seqan3/tree/master/test/api_stability/3.0.2.

Alignment

Header Changes:

#include <seqan3/alignment/band/static_band.hpp> [deleted without replacement]
#include <seqan3/alignment/matrix/advanceable_alignment_coordinate.hpp> [deleted without replacement]
#include <seqan3/alignment/scoring/gap_scheme.hpp> [deleted without replacement]

Alphabet

Header Changes:

#include <seqan3/alphabet/cigar/{cigar_op => cigar}.hpp>
#include <seqan3/alphabet/nucleotide/{sam_dna16 => dna16sam}.hpp}>
#include <seqan3/alphabet/quality/{phred68legacy => phred68solexa}.hpp>
#include <seqan3/alphabet/quality/{quality_base => phred_base}.hpp>
@ cigar
The cigar vector (std::vector<seqan3::cigar>) representing the alignment in SAM/BAM format.

Argument Parser

  • seqan3::output_file_validator cannot be constructed with the extension list alone anymore, you need to specify one of the seqan3::output_file_open_options options. (#2009).
  • The enum names of seqan3::option_spec were changed to lower case (#2285):
    • seqan3::option_spec::DEFAULT is replaced by seqan3::option_spec::standard.
    • seqan3::option_spec::REQUIRED is replaced by seqan3::option_spec::required.
    • seqan3::option_spec::ADVANCED is replaced by seqan3::option_spec::advanced.
    • seqan3::option_spec::HIDDEN is replaced by seqan3::option_spec::hidden.

Core

  • Deprecated seqan3::range_compatible_concept and it will be removed in 3.1.0 (#2265).

Header Changes:

#include <seqan3/core/algorithm/bound.hpp> [Functionality included in alignment/configuration/align_config_band.hpp]
#include <seqan3/core/{algorithm => configuration}/configuration.hpp>
#include <seqan3/core/{algorithm => configuration}/pipeable_config_element.hpp>
#include <seqan3/{core => utility}/char_operations/predicate.hpp>
#include <seqan3/{core => utility}/char_operations/transform.hpp>
#include <seqan3/{core => utility/tuple}/common_tuple.hpp>
#include <seqan3/{core/concept/tuple => utility/tuple/concept}.hpp>
#include <seqan3/{core => utility}/math.hpp>
#include <seqan3/{core => utility/tuple}/pod_tuple.hpp>
#include <seqan3/{core => utility}/simd/concept.hpp>
#include <seqan3/{core => utility}/simd/{simd_algorithm => algorithm}.hpp>
#include <seqan3/{core => utility}/simd/simd.hpp>
#include <seqan3/{core => utility}/simd/simd_traits.hpp>
#include <seqan3/{core => utility}/simd/{view_iota_simd => views/iota_simd}.hpp>
#include <seqan3/{core => utility}/simd/{view_to_simd => views/to_simd}.hpp>
#include <seqan3/{core/tuple_utility => utility/tuple/pop_front}.hpp>
#include <seqan3/{core/tuple_utility => utility/tuple/split}.hpp>
#include <seqan3/{core => utility}/type_list/traits.hpp>
#include <seqan3/{core => utility}/type_list/type_list.hpp>
#include <seqan3/{core => utility}/type_traits/basic.hpp>
#include <seqan3/{core => utility}/type_traits/concept.hpp>
#include <seqan3/{core => utility}/type_traits/function{ =>_traits}.hpp>
#include <seqan3/{core => utility}/type_traits/{lazy => lazy_conditional.hpp>
#include <seqan3/{core/type_traits/pack => utility/type_pack/traits}.hpp>
#include <seqan3/{core => utility}/type_traits/pre.hpp> [deleted without replacement]
#include <seqan3/core/{type_traits/range => range/type_traits}.hpp>
configuration(config_t) -> configuration< config_t >
Deduces the correct configuration element type from the passed seqan3::pipeable_config_element.
@ alignment
The (pairwise) alignment stored in an object that models seqan3::detail::pairwise_alignment.
::ranges::common_tuple common_tuple
A common tuple type that behaves like a regular std::tuple, but can be used as a reference type proxy...
Definition: common_tuple.hpp:30
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:471
constexpr detail::iota_simd_view_fn< index_simd_t > iota_simd
An iota view over a simd vector.
Definition: iota_simd.hpp:274
constexpr auto to_simd
A view that transforms a range of ranges into chunks of seqan3::simd vectors.
Definition: to_simd.hpp:791
pod_tuple(types &&...) -> pod_tuple< types... >
User defined deduction guide enables easy use.

I/O

Header Changes:

#include <seqan3/io/{alignment_file=> sam_file}/format_bam.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/format_sam.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/header.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/input.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/input_format_concept.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/input_options.hpp>
#include <seqan3/io/{alignment_file/misc => sam_file/sam_flag}.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/output.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/output_format_concept.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/output_options.hpp>
#include <seqan3/io/{alignment_file=> sam_file}/sam_tag_dictionary.hpp>
sam_flag
An enum flag that describes the properties of an aligned read (given as a SAM record).
Definition: sam_flag.hpp:76

Range

Header Changes:

#include <seqan3/{range/concept => alphabet/range/sequence}.hpp>
#include <seqan3/{range/concept => alphabet/range/concept}.hpp>
#include <seqan3/{range => utility}/container/aligned_allocator.hpp>
#include <seqan3/{range => alphabet}/container/{bitcompressed_vector => bitpacked_sequence}.hpp>
#include <seqan3/{range => alphabet}/container/concatenated_sequences.hpp>
#include <seqan3/{range => utility}/container/concept.hpp>
#include <seqan3/{range => utility}/container/dynamic_bitset.hpp>
#include <seqan3/{range => utility}/container/small_string.hpp>
#include <seqan3/{range => utility}/container/small_vector.hpp>
#include <seqan3/{range => alignment}/decorator/gap_decorator.hpp>
#include <seqan3/{range => alphabet/range}/hash.hpp>
#include <seqan3/{range => io}/views/async_input_buffer.hpp>
#include <seqan3/{range => alphabet}/views/char_to.hpp>
#include <seqan3/{range => utility}/views/chunk.hpp>
#include <seqan3/{range => alphabet}/views/complement.hpp>
#include <seqan3/{range => utility}/views/convert.hpp>
#include <seqan3/{range => utility}/views/deep.hpp>
#include <seqan3/{range => utility}/views/enforce_random_access.hpp>
#include <seqan3/{range => utility}/views/{get => elements}.hpp>
#include <seqan3/{range => utility}/views/interleave.hpp>
#include <seqan3/range/views/istreambuf.hpp> [deleted without replacement]
#include <seqan3/{range => utility}/views/{join => join_with}.hpp>
#include <seqan3/{range => search}/views/kmer_hash.hpp>
#include <seqan3/{range => search}/views/minimiser.hpp>
#include <seqan3/{range => search}/views/minimiser_hash.hpp>
#include <seqan3/{range => utility}/views/pairwise_combine.hpp>
#include <seqan3/range/views/persist> [deleted without replacement]
#include <seqan3/{range => alphabet}/views/rank_to.hpp>
#include <seqan3/{range => utility}/views/repeat.hpp>
#include <seqan3/{range => utility}/views/repeat_n.hpp>
#include <seqan3/{range => utility}/views/single_pass_input.hpp>
#include <seqan3/{range => utility}/views/slice.hpp>
#include <seqan3/range/views/take.hpp> [deleted without replacement]
#include <seqan3/range/views/take_exactly.hpp> [deleted without replacement]
#include <seqan3/range/views/take_line.hpp> [deleted without replacement]
#include <seqan3/range/views/take_until.hpp> [deleted without replacement]
#include <seqan3/{range => utility}/views/to.hpp>
#include <seqan3/{range => alphabet}/views/to_char.hpp>
#include <seqan3/{range => alphabet}/views/to_rank.hpp>
#include <seqan3/{range => alphabet}/views/translate.hpp>
#include <seqan3/{range => alphabet}/views/translate_join.hpp>
#include <seqan3/{range => alphabet}/views/trim_quality.hpp>
#include <seqan3/{range => utility}/views/type_reduce.hpp>
#include <seqan3/{range => utility}/views/zip.hpp>
small_string(char const(&)[N]) -> small_string< N - 1 >
Deduces small_string from string literals.
deep(underlying_adaptor_t &&inner) -> deep< underlying_adaptor_t >
Template argument deduction helper that preserves lvalue references and turns rvalue references into ...
constexpr auto complement
Return the complement of a nucleotide object.
Definition: concept.hpp:104
constexpr auto translate_join
A view that translates nucleotide into aminoacid alphabet with 1, 2, 3 or 6 frames....
Definition: translate_join.hpp:383
constexpr auto minimiser_hash
Computes minimisers for a range with a given shape, window size and seed.
Definition: minimiser_hash.hpp:188
constexpr auto translate
A view that translates nucleotide into aminoacid alphabet with 1, 2, 3 or 6 frames.
Definition: translate.hpp:813
auto const rank_to
A view over an alphabet, given a range of ranks.
Definition: rank_to.hpp:68
auto const char_to
A view over an alphabet, given a range of characters.
Definition: char_to.hpp:67
constexpr auto trim_quality
A view that does quality-threshold trimming on a range of seqan3::quality_alphabet.
Definition: trim_quality.hpp:127
constexpr auto to_char
Return the char representation of an alphabet object.
Definition: concept.hpp:387
constexpr auto to_rank
Return the rank representation of a (semi-)alphabet object.
Definition: concept.hpp:155
constexpr auto & get(configuration< configs_t... > &config) noexcept
Returns the stored element.
Definition: configuration.hpp:419
constexpr auto async_input_buffer
A view adapter that returns a concurrent-queue-like view over the underlying range.
Definition: async_input_buffer.hpp:479
constexpr auto minimiser
Computes minimisers for a range of comparable values. A minimiser is the smallest value in a window.
Definition: minimiser.hpp:585
constexpr auto kmer_hash
Computes hash values for each position of a range via a given shape.
Definition: kmer_hash.hpp:785
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.
Definition: search.hpp:104
constexpr auto join_with
A join view, please use std::views::join if you don't need a separator.
Definition: join_with.hpp:29
constexpr auto single_pass_input
A view adapter that decays most of the range properties and adds single pass behavior.
Definition: single_pass_input.hpp:361
constexpr auto chunk
A chunk view.
Definition: chunk.hpp:29
constexpr auto to
A to view.
Definition: to.hpp:30
constexpr auto slice
A view adaptor that returns a half-open interval on the underlying range.
Definition: slice.hpp:183
constexpr auto zip
A zip view.
Definition: zip.hpp:29
constexpr auto convert
A view that converts each element in the input range (implicitly or via static_cast).
Definition: convert.hpp:69
constexpr detail::repeat_fn repeat
A view factory that repeats a given value infinitely.
Definition: repeat.hpp:347
constexpr auto repeat_n
A view factory that repeats a given value n times.
Definition: repeat_n.hpp:91
constexpr auto enforce_random_access
A view adaptor that converts a pseudo random access range to a std::ranges::random_access_range.
Definition: enforce_random_access.hpp:367
constexpr auto elements
A view calling get on each element in a range.
Definition: elements.hpp:80
constexpr auto type_reduce
A view adaptor that behaves like std::views::all, but type erases certain ranges.
Definition: type_reduce.hpp:153
constexpr auto pairwise_combine
A view adaptor that generates all pairwise combinations of the elements of the underlying range.
Definition: pairwise_combine.hpp:710
constexpr auto interleave
A view that interleaves a given range into another range at regular intervals.
Definition: interleave.hpp:380
The generic alphabet concept that covers most data types used in ranges.
The (most general) container concept as defined by the standard library.
The generic concept for a (biological) sequence.
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.
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.

Search

  • We removed the concepts seqan3::[bi_]fm_index[_cursor]_specialisation. We did this because we currently have only one implementation modelling each concept and are not completely sure if the current definition of the concepts is the right one. If you used those concepts, you can check whether the cursor type is seqan3::[bi_]fm_index_cursor as a substitute. (#2348)

3.0.2

Note that 3.1.0 will be the first API stable release and interfaces in this release might still change.

  • Check out our new SeqAn3 Cookbook. It contains a listing of code examples on how to perform particular tasks using the library.
  • SeqAn 3.0.2 is known to compile with GCC 7.5, 8.4, 9.3 and 10.2. Future versions (e.g. GCC 10.3 and 11) might work, but were not yet available at the time of this release.

New features

Alignment

Argument Parser

I/O

Build system

  • Add top-level CMakeLists.txt (#1475).
  • We now use Doxygen version 1.8.20 to build our documentation (#2081).

Range

Search

API changes

  • The required version of the ranges-v3 library has increased: We now support the versions >= 0.11.0 and < 0.12.0, increasing the previous requirement of >= 0.10.0 and < 0.11.0 (#2014).

Alignment

Header Changes:

#include <seqan3/alignment/configuration/{align_config_max_error.hpp => align_config_min_score.hpp}>
#include <seqan3/alignment/configuration/{align_config_scoring.hpp => align_config_scoring_scheme.hpp}>
#include <seqan3/alignment/configuration/{align_config_vectorise.hpp => align_config_vectorised.hpp}>
#include <seqan3/alignment/configuration/{align_config_gap.hpp => align_config_gap_cost_affine.hpp}>
#include <seqan3/alignment/configuration/{align_config_mode.hpp => align_config_method.hpp}>
#include <seqan3/alignment/configuration/{align_config_result.hpp => align_config_score_type.hpp}>
#include <seqan3/alignment/configuration/align_config_aligned_ends.hpp> [deleted without replacement; is now part of seqan3::align_cfg::method_global]
#include <seqan3/{alignment/pairwise => core/algorithm}/alignment_range.hpp>
Sets the global alignment method.
Definition: align_config_method.hpp:122

Core

  • In accordance with the standard, the following concepts have been renamed:
    • std::default_constructible to std::default_initializable
    • std::readable to std::indirectly_readable
    • std::writable to std::indirectly_writable (#1860).
  • The seqan3::remove_cvref_t has been replaced by std::remove_cvref_t (#2079).

Range

  • The seqan3::begin(), seqan3::end(), seqan3::cbegin(), seqan3::cend(), seqan3::size(), seqan3::empty() functions have been deprecated. Use std::ranges::{begin|end|cbegin|cend|size|empty}() instead (#1663).
  • The seqan3::forward_range has been removed. Use std::ranges::borrowed_range instead (#2038).
  • The seqan3::views:trim has been renamed to seqan3::views:trim_quality (#2025).

Header Changes:

#include <seqan3/range/views/{trim.hpp => trim_quality.hpp}>

Search

Header Changes:

#include <seqan3/search/{algorithm => }/search.hpp>
#include <seqan3/{search/search_result_range.hpp => core/algorithm/algorithm_result_generator_range.hpp}>
#include <seqan3/search/configuration/{mode.hpp => hit.hpp}>
#include <seqan3/search/configuration/{max_error_rate.hpp => max_error.hpp AND max_error_common.hpp}>
algorithm_result_generator_range(algorithm_executor_type &&) -> algorithm_result_generator_range< std::remove_reference_t< algorithm_executor_type > >
Deduces from the passed algorithm_executor_type.

Notable Bug-fixes

Alignment

  • When invoking the alignment algorithm with a user defined thread count using the seqan3::align_cfg::parallel configuration element, all available threads were used. This is now fixed and only the specified number of threads will be spawned (#1854).
  • Using an unsigned score type via the seqan3::align_cfg::score_type configuration is prevented with a static assert, since gaps and mismatches have negative scores and thus need a signed score type (#1891).

Argument Parser

  • Long option identifiers and their value must be separated by a space or equal sign =. Applying this restriction resolves an ambiguity that occurs if one long option identifier is the prefix of another (#1792).

    Valid short id value pairs: -iValue, -i=Value, -i Value Valid long id value pairs: --id=Value, --id Value (prohibited now: --idValue)

I/O

  • The seqan3::field::cigar was added to the default fields for reading and writing alignment files (#1642). This has the following impact:
    1. Reading and writing in one line is now possible without additional reference information: seqan3::alignment_file_output{"foo.sam"} = seqan3::alignment_file_input{"bar.sam"};
    2. The seqan3::alignment_file_output now accepts seqan3::field::cigar and seqan3::field::alignment although they store redundant information. For the SAM/BAM format this ambiguity is handled by favouring the CIGAR information at all times if present. Note that this breaks your code if you have not selected custom fields and used structural bindings!

Search

Range

3.0.1

Note that 3.1.0 will be the first API stable release and interfaces in this release might still change.

New features

Alphabet

Alignment

Argument parser

Build system

  • find_package(SeqAn3) is now case-insensitive and always populates SEQAN3_* variables in all upper-case (#1427).

Core

  • Added seqan3::lzcnt, seqan3::tzcnt, and seqan3::popcount for bit manipulation (#1141).
  • Added traits for "metaprogramming" with seqan3::type_list and type packs (#1204, #1214, #1273).
  • Added SIMD functions seqan3::upcast and seqan3::upcast_signed (#1190).

I/O

  • We increased our input performance using a faster iterator on the stream buffer (#1030).
  • Support of padded alignments in the SAM/BAM format was added (#1173).
  • Reading seqan3::field::cigar into a vector over seqan3::cigar is supported via seqan3::alignment_file_input (#1192).
  • Writing seqan3::field::cigar into a vector over seqan3::cigar is supported via seqan3::alignment_file_output (#1192).
  • Asynchronous input (background file reading) supported via seqan3::view::async_input_buffer (#1205).

Range

Search

  • The memory footprint of FM-indices over text collections was reduced (#1363).

Std

  • We provide a std::to_chars overload for floating point data types in our seqan3/std/from_chars header (#1160).

API changes

  • The required version of the ranges-v3 library has increased: We now support the versions >= 0.10.0 and < 0.11.0, increasing the previous requirement of >= 0.5.0 and < 0.6.0 (#1471).
  • Customising for third party types has changes slightly: You are only affected if you added types to seqan3::custom::. Please see About Customisation (#1225).
  • All our concepts are named in the snake_case style (e.g. seqan3::WritableAlphabet -> seqan3::writable_alphabet)! This change was motivated by the decision of the ISO C++ committee to also use snake case everywhere (#1235).

Alphabet

Argument parser

Build system

  • find_package accepts minimum versions (e.g. find_package(SEQAN3 3.0.1) requires at least SeqAn3 with a version of >= 3.0.1 and < 4.0.0) (#1425).
  • The variable SEQAN3_VERSION_STRING defined by find_package(SEQAN3) was renamed to SEQAN3_VERSION (#1425).

Core

  • The type_list header has moved: If you included <seqan3/core/type_list.hpp> you need to change the path to <seqan3/core/type_list/type_list.hpp> (#1204).

I/O

  • Removed the field-based in- and output interface for sequence and structure files through std::get and std::tie: Output can instead be achieved with seqan3::views:zip(), for input we will implement unzip() in the future (#1398 #1412).
  • The seqan3::field::flag of SAM/BAM input and output is now an enum instead of an integer, see seqan3::sam_flag (#1390).
  • Uppercase seqan3::field names are deprecated. Use the lower case field names instead. You can easily find and replace all occurrences by the following regex: find field::([A-Z_]+) replace field::\L$1 (#1421).
  • Removed the char type from the input and output files: Most user code will be unaffected; however, if you have fully specified all templates of any of the input or output files in your code, you need to remove the template parameter to select the char type of the stream, e.g. change seqan3::sequence_file_input<traits_t, fields_t, formats_t, char> to seqan3::sequence_file_input<traits_t, fields_t, formats_t>. Before this change, setting the char type gave the impression that also streams over wide characters are supported which is not the case yet (#1400).

Range

Search

Notable Bug-fixes

  • All our headers are self contained (#1085).
  • The alignment algorithm with edit distance returns the correct back coordinate (#1093).
  • Inserting or deleting gaps into an empty seqan3::gap_decorator does not cause assert anymore (#1109).
  • Some fixes to edge cases in BAM file writing (#1110).
  • The application name of the seqan3::argument_parser is restricted to alpha-numeric characters and _ and - (#1133).
  • Copying and moving the seqan3::fm_index and seqan3::bi_fm_index now work properly (#1144).
  • Searching in the seqan3::fm_index and seqan3::bi_fm_index constructed from a text collection containing a single text now returns the correct result (#1316).
  • The view seqan3::views::take is sized if the underlying range is sized (#1146).
  • The detection of the pthread library works correctly on linux based systems (#1200).
  • The translation table for nucleotide to amino acid translation was corrected (#1485).
  • The amino acid score matrices were corrected (#1455).

3.0.0 ("Escala")

This is the initial release of SeqAn3. It is an entirely new library so there is no changelog that covers the differences to SeqAn2.

Note that 3.1.0 will be the first API stable release and interfaces in this release might still change.