Debian Med Biology development packages

Bio-Tradis contains a set of tools to analyse the output from TraDIS analyses.

The Bio-Tradis analysis pipeline is implemented as an extensible Perl library which can either be used as is, or as a basis for the development of more advanced analysis tools.

Please note: You need to manually install BioConductor Edger which can not be distributed by Debian in recent version since it is using non-distributable code locfit.

This package contains some tools for processing BAM files, including

  bamsormadup:  parallel sorting and duplicate marking
  bamcollate2:  reads BAM and writes BAM reordered such that alignment
                or collated by query name
  bammarkduplicates: reads BAM and writes BAM with duplicate alignments
                marked using the BAM flags field
  bammaskflags: reads BAM and writes BAM while masking (removing) bits
                from the flags column
  bamrecompress: reads BAM and writes BAM with a defined compression
                 setting. This tool is capable of multi-threading.
  bamsort:       reads BAM and writes BAM resorted by coordinates or
                 query name
  bamtofastq:    reads BAM and writes FastQ; output can be collated
                 or uncollated by query name

The Bioperl project is a coordinated effort to collect computational methods routinely used in bioinformatics into a set of standard CPAN-style, well-documented, and freely available Perl modules. It is well-accepted throughout the community and used in many high-profile projects, e.g., Ensembl.

The recommended packages are needed to run some of the included binaries, for a detailed explanation including the specific Perl modules please see README.Debian.

The suggested package enhances the manual pages.

Contains scripts from the BioPerl-Run package. This package will also install all wrappable applications packaged in Debian. The ones that are not Free are "Suggested" by this package.

SQUID is a library of C code functions for sequence analysis. It also includes a number of small utility programs to convert, show statistics, manipulate and do other functions on sequence files.

The original name of the package is "squid", but since there is already a squid on the archive (a proxy cache), it was renamed to "biosquid".

This package contains some tools to demonstrate the features of the SQUID library.

This is the reference implementation of the Common Workflow Language standards.

The CWL open standards are for describing analysis workflows and tools in a way that makes them portable and scalable across a variety of software and hardware environments, from workstations to cluster, cloud, and high performance computing (HPC) environments. CWL is designed to meet the needs of data-intensive science, such as Bioinformatics, Medical Imaging, Astronomy, Physics, and Chemistry.

The CWL reference implementation (cwltool) is intended to be feature complete and to provide comprehensive validation of CWL files as well as provide other tools related to working with CWL descriptions.

Gffread is a GFF/GTF parsing utility providing format conversions, region filtering, FASTA sequence extraction and more.

Goby is a next-gen data management framework designed to facilitate the implementation of efficient data analysis pipelines.

Goby provides very efficient file formats to store next-generation sequencing data and intermediary analysis results.

Goby also provides utilities that implement common next-gen data computations. These utilities are designed to be relatively easy to use, yet very efficient.

This package provides the entire Goby framework, including application programs (i.e., Goby modes). It is released under the GPL3 license.

AcePerl is an object-oriented Perl interface for the AceDB database. It provides functionality for connecting to remote AceDB databases, performing queries, fetching ACE objects, and updating databases. The programmer's API is compatible with the JADE Java API, and interoperable with the API used by BoulderIO.

AceDB is a genome database system developed since 1989 primarily by Jean Thierry-Mieg (CNRS, Montpellier) and Richard Durbin (Sanger Institute). It was originally developed for the C.elegans genome project , from which its name was derived (A C. elegans DataBase).

This module provides a Perl wrapper for the Fast Artificial Neural Network (FANN) library (http://leenissen.dk/fann/wp/).

The AI::FANN object oriented interface provides an almost direct map to the C library API.

The BAM Format is a binary format for storing sequence data. This is a lightweight C implementation of the read name collation code from the larger bambam C++ project to handle BAM file input and BAM file output.

This package contains the static library and header files.

BamTools facilitates research analysis and data management using BAM files. It copes with the enormous amount of data produced by current sequencing technologies that is typically stored in compressed, binary formats that are not easily handled by the text-based parsers commonly used in bioinformatics research.

BamTools provides both a C++ API for BAM file support as well as a command-line toolkit.

This is the developers API package.

This package provides the files needed to develop with the libBigWig C library for reading/parsing local and remote bigWig and bigBed files.

Indexes Stockholm format alignments such as those from Pfam and Rfam. Returns raw stream data using the ID or a Bio::SimpleAlign object (via Bio::AlignIO).

Bio::AlignIO::stockholm also allows for ID parsing using a callback:

Bio::ASN1::EntrezGene and Bio::ASN1::Sequence are regular expression-based parsers for NCBI Entrez Gene genome databases (http://www.ncbi.nih.gov/entrez/query.fcgi?db=gene).

They parse ASN.1-formatted Entrez Gene records and NCBI sequences, returning data structures that contain all data items from the gene records or the sequence records.

The parser will report error & line number if input data does not conform to the NCBI Entrez Gene genome or NCBI Sequence annotation file format.

Bio::ASN1::Sequence is basically a modified version of the high-performance Bio::ASN1::EntrezGene parser. However this standalone module exists since it is more efficient to keep Sequence-specific code out of EntrezGene.pm.

The module Bio::Chado::Schema is a standard object-relational mapping layer for use with the GMOD Chado database schema. Chado is an open-source modular database schema for biological data.

The ClusterIO module works with the ClusterIO format module to read various cluster formats such as NCBI UniGene.

The Bioperl project is a coordinated effort to collect computational methods routinely used in bioinformatics into a set of standard CPAN-style, well-documented, and freely available Perl modules.

Since BioPerl version 1.7 several modules where split into separate projects. This package provides the Bio::Coordinate module for working with biological coordinates.

Bio::Das::Lite is an implementation of the BioDas protocol for the retrieval of biological data from XML sources over HTTP.

Bio::Das::Lite is designed as a lightweight and more forgiving alternative to the client/retrieval/parsing components of Bio::Das. Bio::Das::Lite itself is not a drop-in replacement for Bio::Das but it can be subclassed to do so.

Bio::DB::BioFetch is a guaranteed best effort sequence entry fetching method. It goes to the Web-based dbfetch server located at the EBI (http://www.ebi.ac.uk/Tools/dbfetch/dbfetch) to retrieve sequences in the EMBL or GenBank sequence repositories.

Bio::DB::BioFetch implements all the Bio::DB::RandomAccessI interface, plus the get_Stream_by_id() and get_Stream_by_acc() methods that are found in the Bio::DB::SwissProt interface.

Allows the dynamic retrieval of sequence objects Bio::Seq from the EMBL database using the dbfetch script at EBI: http://www.ebi.ac.uk/Tools/dbfetch/dbfetch.

In order to make changes transparent host type (currently only ebi) and location (defaults to ebi) were separated out. This allows later additions of more servers in different geographical locations.

The functionality of this module is inherited from Bio::DB::DBFetch which implements Bio::DB::WebDBSeqI.

HTSlib is an implementation of a unified C library for accessing common file formats, such as SAM (Sequence Alignment/Map), CRAM and VCF (Variant Call Format), used for high-throughput sequencing data, and is the core library used by samtools and bcftools. HTSlib only depends on zlib. It is known to be compatible with gcc, g++ and clang.

HTSlib implements a generalized BAM (binary SAM) index, with file extension 'csi' (coordinate-sorted index). The HTSlib file reader first looks for the new index and then for the old if the new index is absent.

This package provides a Perl interface to the HTS library.

Provides a single place to setup some common methods for querying NCBI web databases. Bio::DB::NCBIHelper just centralizes the methods for constructing a URL for querying NCBI GenBank and NCBI GenPept and the common HTML stripping done in postprocess_data().

The base NCBI query URL used is: https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi

The Bioperl project is a coordinated effort to collect computational methods routinely used in bioinformatics into a set of standard CPAN-style, well-documented, and freely available Perl modules. This package provides a programmatic interface to NCBI's Entrez Programming Utilities commonly referred to as E-utilities. Namely, it provides the Bio::DB::EUtilities and Bio::Tools::EUtilities perl modules.

Entrez is a federated search engine at the National Center for Biotechnology Information (NCBI) for a large number of databases covering a variety of biomedical data, including nucleotide and protein sequences, gene records, three-dimensional molecular structures, and the biomedical literature. E-utilities are a set of eight server-side programs that provide a stable interface into the Entrez query and database system at the National Center for Biotechnology Information (NCBI).

An I/O iterator subsystem for genomic sequence features.

Bio::FeatureIO is a handler module for the formats in the FeatureIO set (eg, Bio::FeatureIO::GFF). It is the officially sanctioned way of getting at the format objects, which most people should use.

The Bio::FeatureIO system can be thought of like biological file handles. They are attached to filehandles with smart formatting rules (eg, GFF format, or BED format) and can either read or write feature objects (Bio::SeqFeature objects, or more correctly, Bio::FeatureHolderI implementing objects, of which Bio::SeqFeature is one such object). If you want to know what to do with a Bio::SeqFeatureI object, read Bio::SeqFeatureI.

The idea is that you request a stream object for a particular format. All the stream objects have a notion of an internal file that is read from or written to. A particular FeatureIO object instance is configured for either input or output. A specific example of a stream object is the Bio::FeatureIO::gff object.

The Bio::Graphics::Panel class provides drawing and formatting services for any object that implements the Bio::SeqFeatureI interface, including Ace::Sequence::Feature, Das::Segment::Feature and Bio::DB::Graphics objects. It can be used to draw sequence annotations, physical (contig) maps, protein domains, or any other type of map in which a set of discrete ranges need to be laid out on the number line.

MAGE-TAB (MicroArray Gene Expression Tabular) format is a standard from the Microarray Gene Expression Data Society (MGED). This package contains Perl modules in the Bio::MAGE hierarchy to manipulate MIAME-compliant (Minimum Information About a Microarray Experiment) records of microarray ("DNA chips") experiments.

The Bio::MAGE module contains the following Bio::MAGE classes:

• NameValueType
• Extendable
• Identifiable
• Describable

MAGE-TAB (MicroArray Gene Expression Tabular) format is a standard from the Microarray Gene Expression Data Society (MGED). This package contains Perl modules in the Bio::MAGE hierarchy to manipulate MIAME-compliant (Minimum Information About a Microarray Experiment) records of microarray ("DNA chips") experiments.

Bio-MAGE-Utils contains extra modules for handling MAGE XML and MGED ontology, as well as SQL utilities.

Bio::PrimerDesigner provides a low-level interface to the primer3 and epcr binary executables and supplies methods to return the results. In addition to accessing local installations of primer3 or e-PCR, it also offers the ability to accessing the primer3 binary via a remote server.

Bio::SamTools provides a Perl interface to the libbam library for indexed and unindexed SAM/BAM sequence alignment databases. It provides support for retrieving information on individual alignments, read pairs, and alignment coverage information across large regions. It also provides callback functionality for calling SNPs and performing other base-by-base functions. Most operations are compatible with the BioPerl Bio::SeqFeatureI interface, allowing BAM files to be used as a backend to the GBrowse genome browser application.

The Bio::SCF (Standard Chromatogram Format) module allows you to read and update (in a restricted way) SCF chromatographic sequence files. It is an interface to Roger Staden's io-lib. It has both tied hash and an object-oriented interfaces. It provides the ability to read fields from SCF files and limited ability to modify them and write them back.

This distribution provides a Perl interface to PAML, a suite of programs (baseml, codeml, evolver, and yn00) for phylogenetic analyses of DNA or protein sequences using maximum likelihood.

The Bio::Tools::Run::Phylo::PAML::* modules provide an interface to run the PAML programs while Bio::Tools::Phylo::PAML provides an interface to parse their output files.

This distribution is part of the Bioperl project.

Bio::Tools::Run::Alignment::Clustalw provides a Perl interface to Clustal W, a program for alignment of multiple nucleotide and peptide sequences.

This module distribution is part of the Bioperl project.

Bio::Tools::Run::Alignment::TCoffee provides a Perl interface to T-Coffee, a program for multiple alignments of DNA, RNA, and protein sequences and structures.

This module distribution is part of the Bioperl project.

Class for remote execution of the NCBI Blast via HTTP.

For a description of the many CGI parameters see: https://www.ncbi.nlm.nih.gov/BLAST/Doc/urlapi.html

Various additional options and input formats are available.

The code in this distribution focuses on simple low-dependency variant-related functionality for BioPerl.

Bio::Variation name space contains modules to store sequence variation information as differences between the reference sequence and changes sequences. Also included are classes to write out and recrete objects from EMBL-like flat files and XML. Lastly, there are simple classes to calculate values for sequence change objects.

BioCocoa is an open source Cocoa framework for bioinformatics. It intends to provide Cocoa programmers with a full suite of tools for handling and manipulating biological sequences. Cocoa is a great framework for rapid application development and it is therefore often used to create innovative bioscientific apps. To speed up development even more, BioCocoa wants to offer reusable Cocoa classes that are specific for molecular biology and biofinformatics. At this time, BioCocoa offers model classes for biological sequences, controller classes for alignment, sequence manipulation and I/O, interfacing with ENTREZ and view classes that let you easily display and work with sequences in your own applications.

This package contains the development files, documentation and examples for developing GNUstep applications using the BioCocoa framework.

BioJava is an open-source project dedicated to providing a Java framework for processing biological data. It includes objects for manipulating sequences, file parsers, DAS client and server support, access to BioSQL and Ensembl databases, and powerful analysis and statistical routines including a dynamic programming toolkit.

BioJava is provided by a vibrant community which meets annually at the Bioinformatics Open Source Conference (BOSC) that traditionally accompanies the Intelligent Systems in Molecular Biology (ISMB) meeting. Much like BioPerl, the employment of this library is valuable for everybody active in the field because of the many tricks of the trade one learns just by communicating on the mailing list.

This is a dependency package which should enable smooth upgrades to new versions.

BioJava is an open-source project dedicated to providing a Java framework for processing biological data. It includes objects for manipulating sequences, file parsers, server support, access to BioSQL and Ensembl databases, and powerful analysis and statistical routines including a dynamic programming toolkit.

BioJava is provided by a vibrant community which meets annually at the Bioinformatics Open Source Conference (BOSC) that traditionally accompanies the Intelligent Systems in Molecular Biology (ISMB) meeting. Much like BioPerl, the employment of this library is valuable for everybody active in the field because of the many tricks of the trade one learns just by communicating on the mailing list.

This is a wrapper package which should enable smooth upgrades to new versions.

Bioparser is a c++ implementation of parsers for several bioinformatics formats. It consists of only one header file containing template parsers for FASTA, FASTQ, MHAP, PAF and SAM format. It also supports compressed files with gzip.

Blasr_libcpp is a library used by blasr and other executables such as samtoh5, loadPulses for analyzing PacBio sequences. This library contains three sub-libraries, including pbdata, hdf and alignment.

This package contains the header files and static library for the alignment sublibrary.

Bio++ is a set of C++ libraries for Bioinformatics, including sequence analysis, phylogenetics, molecular evolution and population genetics. Bio++ is Object Oriented and is designed to be both easy to use and computer efficient. Bio++ intends to help programmers to write computer expensive programs, by providing them a set of re-usable tools.

This package contains the static library and the header files of the Bio++ core classes.

Bio++ is a set of C++ libraries for Bioinformatics, including sequence analysis, phylogenetics, molecular evolution and population genetics. Bio++ is Object Oriented and is designed to be both easy to use and computer efficient. Bio++ intends to help programmers to write computer expensive programs, by providing them a set of re-usable tools.

This package contains the static library and the header files of the Bio++ classes for phylogenetics.

Bio++ is a set of C++ libraries for Bioinformatics, including sequence analysis, phylogenetics, molecular evolution and population genetics. Bio++ is Object Oriented and is designed to be both easy to use and computer efficient. Bio++ intends to help programmers to write computer expensive programs, by providing them a set of re-usable tools.

This package contains the static library and the header files of the Bio++ classes dedicated to genomic phylogeny.

Bio++ is a set of C++ libraries for Bioinformatics, including sequence analysis, phylogenetics, molecular evolution and population genetics. Bio++ is Object Oriented and is designed to be both easy to use and computer efficient. Bio++ intends to help programmers to write computer expensive programs, by providing them a set of re-usable tools.

This package contains the static library and the header files of the Bio++ Population Genetics classes.

Bio++ is a set of C++ libraries for Bioinformatics, including sequence analysis, phylogenetics, molecular evolution and population genetics. Bio++ is Object Oriented and is designed to be both easy to use and computer efficient. Bio++ intends to help programmers to write computer expensive programs, by providing them a set of re-usable tools.

Contains development files of the Bio++ graphical classes developed with Qt.

This library contains utilitary and classes to query public databases (GenBank, EMBL, SwissProt, etc) using acnuc. It is part of the Bio++ project.

This package contains header files and static library.

Bio++ is a set of C++ libraries for Bioinformatics, including sequence analysis, phylogenetics, molecular evolution and population genetics. Bio++ is Object Oriented and is designed to be both easy to use and computer efficient. Bio++ intends to help programmers to write computer expensive programs, by providing them a set of re-usable tools.

This package contains the static library and the header files of Bio++ classes for sequence analysis classes.

Bio++ is a set of C++ libraries for Bioinformatics, including sequence analysis, phylogenetics, molecular evolution and population genetics. Bio++ is Object Oriented and is designed to be both easy to use and computer efficient. Bio++ intends to help programmers to write computer expensive programs, by providing them a set of re-usable tools.

This package contains the static library and the header files of the Bio++ classes dedicated to genomic sequencing.

The CDK is a library of Java classes used in computational and information chemistry and in bioinformatics. It includes renderers, file IO, SMILES generation/parsing, maximal common substructure algorithms, fingerprinting and much, much more.

Chado is a relational database schema that underlies many GMOD installations. It is capable of representing many of the general classes of data frequently encountered in modern biology such as sequence, sequence comparisons, phenotypes, genotypes, ontologies, publications, and phylogeny. It has been designed to handle complex representations of biological knowledge and should be considered one of the most sophisticated relational schemas currently available in molecular biology. The price of this capability is that the new user must spend some time becoming familiar with its fundamentals.

Libcifpp is a C++ library used to create and manipulate mmCIF and PDB files containing macro molecular structure information.

This specific package contains all files needed to develop new software using libcifpp.

ConsensusCore is a library of C++ algorithms for Pacific Biosciences multiple sequence consensus that powers Quiver (Python) and ConsensusTools (.NET). This library primarily exists as the backend for GenomicConsensus, which implements Quiver.

This package is part of the SMRT Analysis suite. It provides the header files and static library.

The libdivsufsort project provides a fast, lightweight, and robust C API library to construct the suffix array and the Burrows-Wheeler transformed string for any input string of a constant-size alphabet.

This package installs files needed for development.

A lightweight and super fast C/C++ library for sequence alignment using edit distance.

Calculating edit distance of two strings is as simple as:

 edlibAlign("hello", 5, "world!", 6,
            edlibDefaultAlignConfig()).editDistance;
Features

• Calculates edit distance (Levehnstein distance).
• It can find optimal alignment path (instructions how to transform first sequence into the second sequence).
• It can find just the start and/or end locations of alignment path - can be useful when speed is more important than having exact alignment path.
• Supports multiple alignment methods: global(NW), prefix(SHW) and infix(HW), each of them useful for different scenarios.
• You can extend character equality definition, enabling you to e.g. have wildcard characters, to have case insensitive alignment or to work with degenerate nucleotides.
• It can easily handle small or very large sequences, even when finding alignment path, while consuming very little memory.
• Super fast thanks to Myers's bit-vector algorithm.

This package contains the static library and the header files.

A lightweight C++11 library to read raw signal data from Oxford Nanopore's FAST5 files.

This package provides the header files for development with fast5.

fastahack is a small application for indexing and extracting sequences and subsequences from FASTA files. The included Fasta.cpp library provides a FASTA reader and indexer that can be embedded into applications which would benefit from directly reading subsequences from FASTA files. The library automatically handles index file generation and use.

Features:

• FASTA index (.fai) generation for FASTA files
• Sequence extraction
• Subsequence extraction
• Sequence statistics (currently only entropy is provided)

Sequence and subsequence extraction use fseek64 to provide fastest-possible extraction without RAM-intensive file loading operations. This makes fastahack a useful tool for bioinformaticists who need to quickly extract many subsequences from a reference FASTA sequence.

This is the development package containing the statically linked library and the header files.

FFindex is a very simple index/database for huge amounts of small files. The files are stored concatenated in one big data file, separated by '\0'. A second file contains a plain text index, giving name, offset and length of the small files. The lookup is currently done with a binary search on an array made from the index file.

This package contains the header files and documentation needed to develop applications with libffindex.

Fermi-lite is a standalone C library tool for assembling Illumina short reads in regions from 100bp to 10 million bp in size.

This package contains the C library headers for using libfml in custom tools, along with a static library.

The GATB-CORE project provides a set of highly efficient algorithms to analyse NGS data sets. These methods enable the analysis of data sets of any size on multi-core desktop computers, including very huge amount of reads data coming from any kind of organisms such as bacteria, plants, animals and even complex samples (e.g. metagenomes). Read more about GATB at https://gatb.inria.fr/. By itself GATB-CORE is not an NGS data analysis tool. However, it can be used to create such tools. There already exist a set of ready-to-use tools relying on GATB-CORE library: see https://gatb.inria.fr/software/

This package contains the static library and the header files of the gatb-core library.

This is an eclectic gathering of (mostly) C++ code which upstream used for some bioinformatics projects. The main idea is to provide lean code and efficient data structures, trying to avoid too many code dependencies of heavy libraries while minimizing production cycles (and this also implies a decent compile/build time -- looking at you, bloated configure scripts and lengthy compile times of Boost code or other heavy C++ template code..).

This code was gathered even before the C++ STL had been fully adopted as a cross-platform "standard". Since STL by itself is a bit heavier for most of the C++ needs, it is preferred to use simpler&leaner C++ classes or templates for basic strings, containers, basic algorithms etc.

Header files of Genome Code Lib. It is mainly known for being used by StringTie but with its own release cycle.

libGenome is a freely available toolkit for developing bioinformatic related software in C++. It is intended to take the hassle out of performing common tasks on genetic sequence and annotation data.

Among other things, libGenome can help you:

• Read and write Multi-FastA format files
• Read and write GenBank flat file database entries
• Append, chop, truncate, reverse, complement, translate, and otherwise mangle sequence data
• Access annotation in GenBank flat files

This is the development package containing the statically linked library and the header files.

The MuSiC suite is a set of tools aimed at discovering the significance of somatic mutations found within a given cohort of cancer samples, and with respect to a variety of external data sources.

This is the base namespace module for the Genome software tree.

That tree has several primary components:

Genome::Model: a data modeling pipeline management system for genomics

Genome::Model::Tools a tree of >1000 tools and tool wrappers for genomics

Genome::* a variety of sample tracking classes with an RDBMS back-end

Only the tools system is currently released.

See genome for a complete inventory of all tool packages, and for command-line access to those tools.

This package contains the GenomeTools static library and necessary header files.

Besides basic bioinformatics data structures, the library contains components for sequence and annotation handling, sequence compression, index structure generation and access, efficient matching, annotation visualization and much more.

This is a simple "libraryfication" of the GFF/GTF parsing code that is used in the Cufflinks codebase. There are not many (any?) relatively lightweight GTF/GFF parsers exposing a C++ interface, and the goal of this library is to provide this functionality without the necessity of drawing in a heavy-weight dependency like SeqAn.

Gk-arrays are provided as a simple-to-use C++ library dedicated to queries on large collection of sequences as produced by high-throughput sequencers (e.g. HiSeq 2000 from Illumina, 454 from Roche).

Gk-arrays index k-mers of reads and allows one to answer different queries on that read collection (e.g. how many reads share this k-mer? where does this k-mer occur in the read collection?).

Gk-arrays consist of a space-efficient alternative to hash tables while being similar in terms of query times.

This is the development library for libgkarrays.

This is a collection of perl code for dealing with Gene Ontologies (GO) and Open Biomedical Ontologies (OBO) style ontologies. It is part of the ‘go-dev’ distribution, but this Debian package is made from the CPAN archive. This package contains both scripts (which can be used with no knowledge of perl), and libraries which will be of use to perl programmers using GO or OBO.

Hierarchical Data Format 5 (HDF5) is a file format and library for storing scientific data. HDF5 was designed and implemented to address the deficiencies of HDF4.x. It has a more powerful and flexible data model, supports files larger than 2 GB, and supports parallel I/O.

This package contains development files for serial platforms.

BEAGLE is a high-performance library that can perform the core calculations at the heart of most Bayesian and Maximum Likelihood phylogenetics packages. It can make use of highly-parallel processors such as those in graphics cards (GPUs) found in many PCs.

The project involves an open API and fast implementations of a library for evaluating phylogenetic likelihoods (continuous time Markov processes) of biomolecular sequence evolution.

The aim is to provide high performance evaluation 'services' to a wide range of phylogenetic software, both Bayesian samplers and Maximum Likelihood optimizers. This allows these packages to make use of implementations that make use of optimized hardware such as graphics processing units.

This package contains development files needed to build against Beagle library.

HTSlib is an implementation of a unified C library for accessing common file formats, such as SAM (Sequence Alignment/Map), CRAM and VCF (Variant Call Format), used for high-throughput sequencing data, and is the core library used by samtools and bcftools. HTSlib only depends on zlib. It is known to be compatible with gcc, g++ and clang.

HTSlib implements a generalized BAM (binary SAM) index, with file extension ‘csi’ (coordinate-sorted index). The HTSlib file reader first looks for the new index and then for the old if the new index is absent.

This package contains development files for the HTSlib: headers, static library, manual pages, etc.

For compatibility with sambamba, the internal routine cram_to_bam was exported, hereto adopting a patch found in guix.

This library implements the custom CRAM codecs used for "EXTERNAL" block types. These consist of two variants of the rANS codec (8-bit and 16-bit renormalisation, with run-length encoding and bit-packing also supported in the latter), a dynamic arithmetic coder, and custom codecs for name/ID compression and quality score compression derived from fqzcomp.

They come with small command line test tools to act as both compression exploration programs and as part of the test harness.

This package contains the development headers

HTSJDK is an implementation of a unified Java library for accessing common file formats, such as SAM (Sequence Alignment/Map) and VCF, used for high-throughput sequencing data. There are also an number of useful utilities for manipulating HTS data.

A Java library for evolutionary biology and bioinformatics, including objects representing biomolecular sequences, multiple sequence alignments and phylogenetic trees.

This is a branch of the original JEBL on http://sourceforge.net/projects/jebl/ to develop a new API and class library.

The jloda Java library provides some basic data structures and algorithms used by bioinformatics applications like SplitsTree, Dendroscope and MEGAN.

The kmer package is a suite of tools for DNA sequence analysis. It provides tools for searching (ESTs, mRNAs, sequencing reads); aligning (ESTs, mRNAs, whole genomes); and a variety of analyses based on kmers.

This package contains headers and static libraries for kmer.

libMems is a freely available software development library to support DNA string matching and comparative genomics. Among other things, libMems implements an algorithm to perform approximate multi-MUM and multi-MEM identification. The algorithm uses spaced seed patterns in conjunction with a seed-and-extend style hashing method to identify matches. The method is efficient, requiring a maximum of only 16 bytes per base of the largest input sequence, and this data can be stored externally (i.e. on disk) to further reduce memory requirements.

This is the development package containing the statically linked library and the header files.

Minimap2 is a versatile sequence alignment program that aligns DNA or mRNA sequences against a large reference database. Typical use cases include: (1) mapping PacBio or Oxford Nanopore genomic reads to the human genome; (2) finding overlaps between long reads with error rate up to ~15%; (3) splice-aware alignment of PacBio Iso-Seq or Nanopore cDNA or Direct RNA reads against a reference genome; (4) aligning Illumina single- or paired-end reads; (5) assembly-to-assembly alignment; (6) full- genome alignment between two closely related species with divergence below ~15%.

This package contains the C library headers for using minimap in custom tools, along with a static library.

MacroMoleculeBuilder, previously known as RNABuilder, can be used for morphing, homology modeling, folding (e.g. using base pairing contacts), redesigning complexes, fitting to low-resolution density maps, predicting local rearrangements upon mutation, and many other applications.

This package contains the development files.

MUSCLE is a multiple alignment program for protein sequences. MUSCLE stands for multiple sequence comparison by log-expectation. In the authors tests, MUSCLE achieved the highest scores of all tested programs on several alignment accuracy benchmarks, and is also one of the fastest programs out there.

This library was derived from the original MUSCLE and turned into a library.

This package contains the static library and header files.

Much of the data submitted these days, for example in BAM, Illumina export.txt, and Complete Genomics formats, contain alignment information. With aligned data, NCBI uses Compression by Reference, which only stores the differences in base pairs between sequence data and the segment it aligns to. The process to restore original data, for example as FastQ, requires fast access to the reference sequences that the original data was aligned to. NCBI recommends that SRA users dedicate local disk space to store references downloaded from the NCBI SRA site. As of Fall 2014, the complete collection of these reference sequences is 66 GB. While it isn't usually necessary to download the entirety of the reference sequences, this should give you an idea of the scale of the storage requirement. By default, the Toolkit will download missing reference sequences on demand and cache them in the user's home directory. The location of this cache is configurable, as is whether the download is automatic or manual.

This is the development package.

This package supplies development versions of NCBI's non-graphical C libraries, along with the corresponding header files.

The NEXUS Class Library is a C++ library for parsing NEXUS files.

The NEXUS file format is widely used in bioinformatics. Several popular phylogenetic programs such as Paup, MrBayes, Mesquite, and MacClade use this format.

This package contains the static library and header files of the NEXUS library.

NGS is a new, domain-specific API for accessing reads, alignments and pileups produced from Next Generation Sequencing. The API itself is independent from any particular back-end implementation, and supports use of multiple back-ends simultaneously. It also provides a library for building new back-end "engines". The engine for accessing SRA data is contained within the sister repository ncbi-vdb.

The API is currently expressed in C++, Java and Python languages. The design makes it possible to maintain a high degree of similarity between the code in one language and code in another - especially between C++ and Java.

Java bindings.

NGS is a new, domain-specific API for accessing reads, alignments and pileups produced from Next Generation Sequencing. The API itself is independent from any particular back-end implementation, and supports use of multiple back-ends simultaneously. It also provides a library for building new back-end "engines". The engine for accessing SRA data is contained within the sister repository ncbi-vdb.

The API is currently expressed in C++, Java and Python languages. The design makes it possible to maintain a high degree of similarity between the code in one language and code in another - especially between C++ and Java.

This is the development package.

NHGRI::Blastall will enable usage of BLAST out of a Perl script, if BLAST2 or WU-BLAST are installed locally. Main features are:

• run BLAST (also via network, which requires blastcl3)
• BLAST single sequences against each other or against a given library
• format databases
• mask out repetitive DNA
• read, parse and filter existing BLAST reports