Software for Computing and Annotating Genomic Ranges — TEI-tagged view

Michael Lawrence, Wolfgang Huber, Hervé Pagès, Patrick Aboyoun, Marc Carlson, Robert Gentleman, Martin T. Morgan, Vincent J. Carey · 2013 · genomics · doi:10.1371/journal.pcbi.1003118 · TEI xml · tagged edition · index · concepts · authors
Where this record's text came from. 2026-08-31 schema-0.3 pass: every quote verified as an exact substring of the staged text and anchored at merge time; concept terms verified present; every edge endpoint an existing node.
Other fields define these differently the same word, defined another way in another discipline
metadata 7 fields · interoperability 6 fields · coverage 4 fields · abstraction 2 fields · DataFrame 2 fields · parallel computing 2 fields · and 1 more →
Tags on this paper every tag the record carries, whether or not the words occur in the text below — a number is how many papers in the corpus carry that tag; a tag with no number is unique to this paper
Bioconductor infrastructure annotated genomic ranges IRanges GenomicRanges GenomicFeatures core of the infrastructure scalable data structures transcript structures read alignments coverage vectors overlap detection nearest neighbor detection range operations linear sequence annotations3 primary experimental measurements common scaffold genomic data analysis intersection2 union complement specialized, formal data structures application programming interface (API) interoperability9 abstraction2 robust, maintainable software per-range metadata generic function method range ordered set of consecutive integers IRanges class GRanges class reference genome sequence GRangesList compound feature TranscriptDb DataFrame2 primary data metadata9 coverage4 number of features in the data set overlapping each position in the… Rle run-length encoded vector BAM file GappedAlignments SummarizedExperiment ExpressionSet2 allele-specific protein-DNA binding alternate nucleotide proportion ANP base-call quality technical artifacts2 growing ecosystem of packages core infrastructure for sequence analysis parallel computing2 other software tools ctcfReads object GRanges countOverlaps summarizeOverlaps system-or-tool-building173
Method, as described: formal range classes, generic-function specialization, interval-tree overlap, genomic metadata, hierarchical GRangesList objects, TranscriptDb access, run-length encoding, and SummarizedExperiment containers

Colour legend

PLoS Computational Biology<title level="j">A work — the journal / venue title.
2013<date>A year or date.

Michael LawrencepersName, Wolfgang HuberpersName, Hervé PagèspersName, Patrick AboyounpersName, Marc CarlsonpersName, Robert GentlemanpersName, Martin T. MorganpersName, Vincent J. CareypersName (2013date). “Software for Computing and Annotating Genomic Ranges.” PLoS Computational Biologytitle·j.

Object of study — software infrastructure for representing, computing on, annotating, and integrating genomic rangesterm in R

Research question — how to make range-based genomic analysis efficient, interoperable, reproducible, and statistically integrated across packages and data types

Contribution — the IRangesterm, GenomicRangesterm, and GenomicFeaturesterm infrastructure with scalable rangeterm structures, operations, annotationterm access, and experiment containers

Cross-disciplinary analysis
content-tags & facets: phenomenon · claim-type · cross-domain-transfer · mechanism · claim-relation · replication-status · limitation — grounded in the full text
phenomenongenome-coordinate integration, interval overlap, hierarchical range structure, compressed coverage, genomic annotation, and reproducible cross-package analysis — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”
claim-typemethod — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”
method — evidence — “This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structures for annotated genomic ranges and genome-length vectors, and efficient algorithms for overlap detection and other range operations. The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRanges package provides the fundamental range data structures and operations, while GenomicRanges builds upon it to add biological semantics to the metadata, including explicit treatment of sequence name and strand. Finally, GenomicFeatures enables access to and manipulation of gene models and other annotations. Together, these packages support more than 80 other packages in Bioconductor.”
object of study — evidence — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”
research question — evidence — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”
contribution — evidence — “This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structures for annotated genomic ranges and genome-length vectors, and efficient algorithms for overlap detection and other range operations. The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRanges package provides the fundamental range data structures and operations, while GenomicRanges builds upon it to add biological semantics to the metadata, including explicit treatment of sequence name and strand. Finally, GenomicFeatures enables access to and manipulation of gene models and other annotations. Together, these packages support more than 80 other packages in Bioconductor.”
mechanismcommon genome-range scaffold Represents annotations and measurements on the same coordinate intervals. — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”mechanisms[0]
mechanismformal range classes Communicates structure definitions to R and delegates integrity and dispatch to the language. — “These data structures are represented as classes, through which we communicate the formal definition of each data structure to the programming language. One benefit is that we can defer the regulation of data access and the tracking of data integrity to the language. In the case of functional object-oriented languages, there is another benefit: we can implement behaviors as methods on generic functions. A generic function is one that dispatches to a particular implementation, termed a method, based on the classes of passed arguments. This means that the same API will exhibit specialized behavior depending on the input. For example calling start on a range data structure would return the starting positions for the ranges, while calling the same function on a base R time-series object would behave differently.”mechanisms[1]
mechanismshared in-memory data structures Allows routines across packages to interoperate without repeated conversion. — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”mechanisms[2]
mechanismgeneric-function specialization Uses one interface with class-specific behavior for simple and genomic ranges. — “The GRanges class supports many of the same range operations as IRanges and specializes them for genomic data. We achieved API specialization by implementing methods for both classes on the same generic functions. In general, we believe method specialization is an effective practice for providing the same interface on top of different data structures. Abstracting implementation details leads to user code that is more robust and easier to write and maintain.”mechanisms[3]
mechanisminterval-tree overlap detection Indexes ranges once and answers vectorized queries in logarithmic time. — “A recurrent operation is overlap detection; various instances are illustrated in Figure 3 . In later sections, we apply overlap counting for finding the percentage of ChIP-seq peaks that overlap a promoter, counting the number of RNA-seq reads for each transcript, and other tasks. The findOverlaps function uses an efficient interval tree algorithm [4] to detect overlaps between two IRanges objects, as well as the more complex range-based data structures introduced later. The algorithm supports several types of overlap, including those defined by Allen's Interval Algebra [5] . The one-time cost of constructing the interval tree is , and queries are performed in logarithmic time. In accordance with the vectorized semantics of R, if multiple queries are submitted, they are efficiently processed in batch, without restarting at the root of the tree for each query. The language of implementation is C, which avoids the potentially expensive iteration over the tree in R.”mechanisms[4]
mechanismgenomic semantic metadata Adds sequence name, strand, and reference-build tracking to range objects. — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”mechanisms[5]
mechanismcompound-feature lists Groups exons, transcripts, or alignment segments into GRangesList elements. — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”mechanisms[6]
mechanismannotation-source normalization Distills UCSC, Biomart, and GTF/GFF sources into a TranscriptDb schema. — “Recalling our KRAS gene model example, there are multiple models for representing transcript structures, and the applicability of each depends on the use case. To support the analyst in asking a broad range of questions, there is a need for a mechanism that draws from a data source of gene annotations and returns them in a variety of different data models. The GenomicFeatures package fills that role by distilling multiple data sources into a single database schema and wrapping that database in an API that returns, for example, the exons grouped by gene, or the bounds for every transcript. The databases are implemented in SQLite and are thus accessible from environments outside of R. For reproducibility, a database may be encapsulated in a redistributable R package.”mechanisms[7]
mechanismcomplex-column metadata Stores annotations in a DataFrame capable of vector-like genomic columns. — “Every multi-element data structure in the IRanges suite supports the storage of per-element metadata: data about data. In this case, the metadata are the annotations, and the primary data are the ranges being annotated. This includes all of the data structures for storing ranges, such as IRanges, GRanges and GRangesList . The metadata are stored in a DataFrame with as many rows as there are elements in the object. We introduce a DataFrame class that behaves similarly to the base R data.frame , but supports storage of complex vector-like objects (e.g., a DNAStringSet , representing DNA sequences, or a GRanges ) in columns.”mechanisms[8]
mechanismrun-length encoding Compresses repeated genome-length vector values behind a standard vector API. — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”mechanisms[9]
mechanismalignment coercion Converts gapped read alignments to GRanges or GRangesList according to the desired unit. — “Read alignments may be loaded from a BAM file as a GappedAlignments or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignment results in terms of the position, chromosome, strand, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operations and can be coerced to GRanges and GRangesList . The GRanges representation holds the ungapped extents of the read alignments, whereas the GRangesList represents the alignments as ranges with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.”mechanisms[10]
mechanismfeature-by-sample summarization Counts overlaps into a matrix and retains region, sample, and experiment annotations. — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”mechanisms[11]
builds-on R statistical computing and Bioconductor extensions — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”claim_relations[0]
extends IRanges with biological sequence and strand semantics — “The IRanges package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges class to represent a vector of ranges. The GenomicRanges package builds on IRanges to include biologically relevant features such as strand and sequence (e.g., chromosome) name.”claim_relations[1]
contrasts-with file-centered UNIX range workflows — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”claim_relations[2]
supports shared range structures as a cross-package foundation — “There is a growing ecosystem of packages based on this infrastructure. By current count, more than 80 packages depend directly on the packages presented here. This includes packages for input and output of ranges ( rtracklayer , Rsamtools ) [12] , [13] , quality assessment ( ShortRead ) [7] , sequence analysis ( Biostrings ) [14] , variant calling ( VariantTools ) [15] , and other tasks. To summarize the different use cases addressed by dependent packages, Table 5 tabulates the descriptive labels chosen from a controlled vocabulary by the package authors.”claim_relations[3]
qualifies allele-dependent CTCF calls as direct biological findings — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”claim_relations[4]
sensegenome as a coordinate scaffold linking processed annotations and primary measurements — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”senses[0]
senserange as an ordered integer interval rather than an informal genomic region — “We use the term “range” to denote an ordered set of consecutive integers.”senses[1]
senserange API as conceptual language hiding optimized implementation detail — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”senses[2]
senseinteroperability as shared in-memory structures across Bioconductor packages — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”senses[3]
senseGRanges as IRanges plus chromosome, strand, and reference-build semantics — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”senses[4]
senseGRangesList as hierarchy-preserving compound-feature representation — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”senses[5]
sensecoverage as the count of features overlapping each genomic position — “A common method of summarizing a genomic data set is to calculate the coverage, i.e., the number of features in the data set overlapping each position in the genome. This is useful in ChIP-seq analysis, where many peak detection methods operate on the coverage.”senses[6]
senseRle as compressed storage with ordinary-vector behavior — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”senses[7]
senseSummarizedExperiment as coordinated feature, sample, region, and experiment data — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”senses[8]
senseallelic imbalance as a signal requiring separation of biology from technical artifacts — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”senses[9]
controlGFP antibody sample — rules out non-specific ChIP enrichment — “For this example, mouse genomic DNA was cross-linked with DNA-binding proteins, fragmented and precipitated with an antibody for CTCF. An antibody for GFP was used for the control. The CTCF and GFP samples were each sequenced in a single lane on an Illumina sequencer, which generated reads 35 nt in length [6] . We excluded the last 11 nt of each read due to insufficient quality, so the effective read length was 24 nt. The reads were aligned to the mm9 build of the mouse genome using MAQ. We parsed the MAQ output using the ShortRead package [7] , and the alignments for three chromosomes (chr10, chr11 and chr12) were extracted for use as a demonstration data set in the chipseq package [8] .”controls[0]
controlfunders' role — held — “This work was funded by the National Institutes of Health, National Human Genome Research Group through grants P41 HG004059 and U41 HG004059 and (for VJC) by National Heart, Lung and Blood Institute grants R01 HL086601, R01 HL093076 and R01 HL094635. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.” — rules out funder control over design, analysis, publication, or manuscript preparation — “This work was funded by the National Institutes of Health, National Human Genome Research Group through grants P41 HG004059 and U41 HG004059 and (for VJC) by National Heart, Lung and Blood Institute grants R01 HL086601, R01 HL093076 and R01 HL094635. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.”controls[1]
noteR statistical computing and Bioconductor extensions — The infrastructure integrates range data with established R facilities. — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”claim_relations[0]
weightR statistical computing and Bioconductor extensions — 0.95 — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”claim_relations[0]
noteIRanges with biological sequence and strand semantics — GenomicRanges builds on the general range package. — “The IRanges package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges class to represent a vector of ranges. The GenomicRanges package builds on IRanges to include biologically relevant features such as strand and sequence (e.g., chromosome) name.”claim_relations[1]
weightIRanges with biological sequence and strand semantics — 0.95 — “The IRanges package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges class to represent a vector of ranges. The GenomicRanges package builds on IRanges to include biologically relevant features such as strand and sequence (e.g., chromosome) name.”claim_relations[1]
notefile-centered UNIX range workflows — The paper contrasts in-memory integration with heterogeneous scripts and files. — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”claim_relations[2]
weightfile-centered UNIX range workflows — 0.95 — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”claim_relations[2]
noteshared range structures as a cross-package foundation — The direct dependent-package count documents adoption. — “There is a growing ecosystem of packages based on this infrastructure. By current count, more than 80 packages depend directly on the packages presented here. This includes packages for input and output of ranges ( rtracklayer , Rsamtools ) [12] , [13] , quality assessment ( ShortRead ) [7] , sequence analysis ( Biostrings ) [14] , variant calling ( VariantTools ) [15] , and other tasks. To summarize the different use cases addressed by dependent packages, Table 5 tabulates the descriptive labels chosen from a controlled vocabulary by the package authors.”claim_relations[3]
weightshared range structures as a cross-package foundation — 0.95 — “There is a growing ecosystem of packages based on this infrastructure. By current count, more than 80 packages depend directly on the packages presented here. This includes packages for input and output of ranges ( rtracklayer , Rsamtools ) [12] , [13] , quality assessment ( ShortRead ) [7] , sequence analysis ( Biostrings ) [14] , variant calling ( VariantTools ) [15] , and other tasks. To summarize the different use cases addressed by dependent packages, Table 5 tabulates the descriptive labels chosen from a controlled vocabulary by the package authors.”claim_relations[3]
noteallele-dependent CTCF calls as direct biological findings — The authors attribute the observed imbalance to a mixture of biology and artifacts. — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”claim_relations[4]
weightallele-dependent CTCF calls as direct biological findings — 0.9 — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”claim_relations[4]
noteIRanges —part-of→ core of the infrastructure — Direct package containment. — “The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures .”concept_edges[0]
relationIRanges —part-of→ core of the infrastructure — IRanges is included in the core infrastructure. — “The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures .”concept_edges[0]
noteGenomicRanges —part-of→ core of the infrastructure — Direct package containment. — “The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures .”concept_edges[1]
relationGenomicRanges —part-of→ core of the infrastructure — GenomicRanges is included in the core infrastructure. — “The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures .”concept_edges[1]
noteGenomicFeatures —part-of→ core of the infrastructure — Direct package containment. — “The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures .”concept_edges[2]
relationGenomicFeatures —part-of→ core of the infrastructure — GenomicFeatures is included in the core infrastructure. — “The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures .”concept_edges[2]
noteBioconductor infrastructure —contrasted-with→ other software tools — Flat methodological comparison. — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”concept_edges[3]
relationBioconductor infrastructure —contrasted-with→ other software tools — The Bioconductor infrastructure is contrasted with file-centered command-line tools. — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”concept_edges[3]
weightBioconductor infrastructure —contrasted-with→ other software tools — 0.95 — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”concept_edges[3]
noteGenomicRanges —distinct-from→ IRanges — Explicit missing-feature distinction. — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”concept_edges[4]
relationGenomicRanges —distinct-from→ IRanges — IRanges omits chromosome and strand while GenomicRanges adds genomic semantics. — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”concept_edges[4]
weightGenomicRanges —distinct-from→ IRanges — 0.95 — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”concept_edges[4]
noteGRanges —distinct-from→ GRangesList — Flat representation distinction. — “Read alignments may be loaded from a BAM file as a GappedAlignments or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignment results in terms of the position, chromosome, strand, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operations and can be coerced to GRanges and GRangesList . The GRanges representation holds the ungapped extents of the read alignments, whereas the GRangesList represents the alignments as ranges with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.”concept_edges[5]
relationGRanges —distinct-from→ GRangesList — GRanges holds ungapped extents whereas GRangesList retains gaps. — “Read alignments may be loaded from a BAM file as a GappedAlignments or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignment results in terms of the position, chromosome, strand, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operations and can be coerced to GRanges and GRangesList . The GRanges representation holds the ungapped extents of the read alignments, whereas the GRangesList represents the alignments as ranges with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.”concept_edges[5]
weightGRanges —distinct-from→ GRangesList — 0.95 — “Read alignments may be loaded from a BAM file as a GappedAlignments or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignment results in terms of the position, chromosome, strand, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operations and can be coerced to GRanges and GRangesList . The GRanges representation holds the ungapped extents of the read alignments, whereas the GRangesList represents the alignments as ranges with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.”concept_edges[5]
notecountOverlaps —contrasted-with→ summarizeOverlaps — Flat method comparison. — “More complex counting algorithms are available via the summarizeOverlaps function, which counts over multiple samples and returns the results as a SummarizedExperiment object. Unlike the call to countOverlaps above, reads that map to multiple features are discarded.”concept_edges[6]
relationcountOverlaps —contrasted-with→ summarizeOverlaps — summarizeOverlaps discards multi-feature reads unlike countOverlaps. — “More complex counting algorithms are available via the summarizeOverlaps function, which counts over multiple samples and returns the results as a SummarizedExperiment object. Unlike the call to countOverlaps above, reads that map to multiple features are discarded.”concept_edges[6]
weightcountOverlaps —contrasted-with→ summarizeOverlaps — 0.95 — “More complex counting algorithms are available via the summarizeOverlaps function, which counts over multiple samples and returns the results as a SummarizedExperiment object. Unlike the call to countOverlaps above, reads that map to multiple features are discarded.”concept_edges[6]
auditSummarizedExperiment —distinct-from→ ExpressionSet — Audit 2026-09-28: DOUBTFUL - read against its full span and kept, but the span says SummarizedExperiment follows the same pattern as ExpressionSet with one primary difference; distinct-from is loose. — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”concept_edges[7]
noteSummarizedExperiment —distinct-from→ ExpressionSet — The paper explicitly names the primary difference. — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”concept_edges[7]
relationSummarizedExperiment —distinct-from→ ExpressionSet — SummarizedExperiment differs from ExpressionSet by being based on IRanges. — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”concept_edges[7]
weightSummarizedExperiment —distinct-from→ ExpressionSet — 0.95 — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”concept_edges[7]
notecoverage —operationalised-as→ number of features in the data set overlapping each position in the genome — Exact operational definition. — “A common method of summarizing a genomic data set is to calculate the coverage, i.e., the number of features in the data set overlapping each position in the genome. This is useful in ChIP-seq analysis, where many peak detection methods operate on the coverage.”concept_edges[8]
relationcoverage —operationalised-as→ number of features in the data set overlapping each position in the genome — Coverage is defined as the number of overlapping features at each genomic position. — “A common method of summarizing a genomic data set is to calculate the coverage, i.e., the number of features in the data set overlapping each position in the genome. This is useful in ChIP-seq analysis, where many peak detection methods operate on the coverage.”concept_edges[8]
notealternate nucleotide proportion —same-as→ ANP — Parenthetical naming equivalence. — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”concept_edges[9]
relationalternate nucleotide proportion —same-as→ ANP — Alternate nucleotide proportion is abbreviated ANP. — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”concept_edges[9]
auditabstraction —causes→ robust, maintainable software — Audit 2026-09-28: DOUBTFUL - read against its full span and kept, but the span says efficiency, interoperability and abstraction TOGETHER lead to robust, maintainable software; the cause is shared. — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concept_edges[10]
effect directionabstraction —causes→ robust, maintainable software — increases — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concept_edges[10]
noteabstraction —causes→ robust, maintainable software — The causal sentence attributes the outcome jointly to the listed benefits. — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concept_edges[10]
relationabstraction —causes→ robust, maintainable software — Abstraction and related benefits lead to more robust, maintainable software. — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concept_edges[10]
weightabstraction —causes→ robust, maintainable software — 0.9 — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concept_edges[10]
notectcfReads object —is-a→ GRanges — Direct categorical statement. — “The ctcfReads object, listed in Table 3 , is a GRanges holding the read alignments from the CTCF sample. The GRanges stores the chromosome names, ranges, and strand for each alignment, as well as a list of chromosome names and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.”concept_edges[11]
relationctcfReads object —is-a→ GRanges — The ctcfReads object is a GRanges. — “The ctcfReads object, listed in Table 3 , is a GRanges holding the read alignments from the CTCF sample. The GRanges stores the chromosome names, ranges, and strand for each alignment, as well as a list of chromosome names and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.”concept_edges[11]
outcomecontrol — held — “This work was funded by the National Institutes of Health, National Human Genome Research Group through grants P41 HG004059 and U41 HG004059 and (for VJC) by National Heart, Lung and Blood Institute grants R01 HL086601, R01 HL093076 and R01 HL094635. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.”controls[1]
relationrange → ordered set of consecutive integers — The paper uses the term range to denote an ordered set of consecutive integers. — “We use the term “range” to denote an ordered set of consecutive integers.”unhoused_relations[0]
relationGenomicRanges → IRanges — GenomicRanges builds on IRanges by adding biological semantics. — “The IRanges package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges class to represent a vector of ranges. The GenomicRanges package builds on IRanges to include biologically relevant features such as strand and sequence (e.g., chromosome) name.”unhoused_relations[1]
weightGenomicRanges → IRanges — 0.95 — “The IRanges package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges class to represent a vector of ranges. The GenomicRanges package builds on IRanges to include biologically relevant features such as strand and sequence (e.g., chromosome) name.”unhoused_relations[1]
relationsame data structures → cumbersome conversions — Shared structures remove the need for cumbersome cross-package conversions. — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”unhoused_relations[2]
weightsame data structures → cumbersome conversions — 0.95 — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”unhoused_relations[2]
relationtracking chromosome information → genome-assembly mixing errors — Chromosome tracking guards against mixing assemblies. — “The ctcfReads object, listed in Table 3 , is a GRanges holding the read alignments from the CTCF sample. The GRanges stores the chromosome names, ranges, and strand for each alignment, as well as a list of chromosome names and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.”unhoused_relations[3]
weighttracking chromosome information → genome-assembly mixing errors — 0.95 — “The ctcfReads object, listed in Table 3 , is a GRanges holding the read alignments from the CTCF sample. The GRanges stores the chromosome names, ranges, and strand for each alignment, as well as a list of chromosome names and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.”unhoused_relations[3]
relationTranscriptDb class → database — The annotation database is represented by TranscriptDb. — “The database is represented by the TranscriptDb class and stores the range of each exon, the coding range, the transcript ID, the gene ID, and metadata about the source of the transcript information. The GenomicFeatures package provides an automated mechanism for constructing a TranscriptDb object from tracks defined in the UCSC genome browser, Biomart, or GTF/GFF files. Bioconductor provides pre-built packages for the most widely adopted gene models, like the UCSC known gene annotations on hg19. These packages follow a standard naming convention, e.g., TxDb.Hsapiens.UCSC.hg19.knownGene .”unhoused_relations[4]
weightTranscriptDb class → database — 0.95 — “The database is represented by the TranscriptDb class and stores the range of each exon, the coding range, the transcript ID, the gene ID, and metadata about the source of the transcript information. The GenomicFeatures package provides an automated mechanism for constructing a TranscriptDb object from tracks defined in the UCSC genome browser, Biomart, or GTF/GFF files. Bioconductor provides pre-built packages for the most widely adopted gene models, like the UCSC known gene annotations on hg19. These packages follow a standard naming convention, e.g., TxDb.Hsapiens.UCSC.hg19.knownGene .”unhoused_relations[4]
relationRle → run-length encoded vector — Rle represents a run-length encoded vector. — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”unhoused_relations[5]
relationsummarizeOverlaps → reads that map to multiple features — summarizeOverlaps discards reads mapping to multiple features. — “More complex counting algorithms are available via the summarizeOverlaps function, which counts over multiple samples and returns the results as a SummarizedExperiment object. Unlike the call to countOverlaps above, reads that map to multiple features are discarded.”unhoused_relations[6]
weightsummarizeOverlaps → reads that map to multiple features — 0.95 — “More complex counting algorithms are available via the summarizeOverlaps function, which counts over multiple samples and returns the results as a SummarizedExperiment object. Unlike the call to countOverlaps above, reads that map to multiple features are discarded.”unhoused_relations[6]
relationbase-call quality → replication — Low base-call quality implies that off-SNP imbalance findings are unlikely to replicate. — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”unhoused_relations[7]
weightbase-call quality → replication — 0.7 — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”unhoused_relations[7]
relationtechnical artifacts → apparent imbalances — Technical artifacts contribute to the mixture observed as apparent allelic imbalance. — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”unhoused_relations[8]
weighttechnical artifacts → apparent imbalances — 0.7 — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”unhoused_relations[8]
relationGRangesList → GRanges objects — Multiple GRanges objects are combined into a GRangesList. — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”unhoused_relations[9]
weightGRangesList → GRanges objects — 0.95 — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”unhoused_relations[9]
no type for thisrange → ordered set of consecutive integers — The paper uses the term range to denote an ordered set of consecutive integers. — “We use the term “range” to denote an ordered set of consecutive integers.”unhoused_relations[0]
no type for thisGenomicRanges → IRanges — GenomicRanges builds on IRanges by adding biological semantics. — “The IRanges package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges class to represent a vector of ranges. The GenomicRanges package builds on IRanges to include biologically relevant features such as strand and sequence (e.g., chromosome) name.”unhoused_relations[1]
no type for thissame data structures → cumbersome conversions — Shared structures remove the need for cumbersome cross-package conversions. — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”unhoused_relations[2]
no type for thistracking chromosome information → genome-assembly mixing errors — Chromosome tracking guards against mixing assemblies. — “The ctcfReads object, listed in Table 3 , is a GRanges holding the read alignments from the CTCF sample. The GRanges stores the chromosome names, ranges, and strand for each alignment, as well as a list of chromosome names and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.”unhoused_relations[3]
no type for thisTranscriptDb class → database — The annotation database is represented by TranscriptDb. — “The database is represented by the TranscriptDb class and stores the range of each exon, the coding range, the transcript ID, the gene ID, and metadata about the source of the transcript information. The GenomicFeatures package provides an automated mechanism for constructing a TranscriptDb object from tracks defined in the UCSC genome browser, Biomart, or GTF/GFF files. Bioconductor provides pre-built packages for the most widely adopted gene models, like the UCSC known gene annotations on hg19. These packages follow a standard naming convention, e.g., TxDb.Hsapiens.UCSC.hg19.knownGene .”unhoused_relations[4]
no type for thisRle → run-length encoded vector — Rle represents a run-length encoded vector. — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”unhoused_relations[5]
no type for thissummarizeOverlaps → reads that map to multiple features — summarizeOverlaps discards reads mapping to multiple features. — “More complex counting algorithms are available via the summarizeOverlaps function, which counts over multiple samples and returns the results as a SummarizedExperiment object. Unlike the call to countOverlaps above, reads that map to multiple features are discarded.”unhoused_relations[6]
no type for thisbase-call quality → replication — Low base-call quality implies that off-SNP imbalance findings are unlikely to replicate. — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”unhoused_relations[7]
no type for thistechnical artifacts → apparent imbalances — Technical artifacts contribute to the mixture observed as apparent allelic imbalance. — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”unhoused_relations[8]
no type for thisGRangesList → GRanges objects — Multiple GRanges objects are combined into a GRangesList. — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”unhoused_relations[9]
limitationFile-format interoperability can yield heterogeneous workflows that are hard to maintain and reproduce. — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”limitations[0]
limitationIRanges alone omits chromosome, strand, and other genomic semantics. — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”limitations[1]
limitationWhether exons should be individual ranges or compound transcripts depends on the use case. — “Data structures should support the storage of per-range metadata, because genomic data is multivariate and consists of much more than the ranges alone. This enables the storage of gene identifiers and other symbols with the gene ranges, and the peak heights or confidence scores with the peak ranges. Some metadata merit special treatment, such as the chromosome name and the strand. Also necessary is a data structure for storing summaries and processing results for a common set of ranges across multiple samples. Such a structure would hold, for example, the RNA-seq per-exon counts or a set of variant calls. Finally, there should be support for storing hierarchies of ranges, at least for one level of nesting, to represent, for example, the nesting of exons into transcripts. Whether it is appropriate to treat the exons as individual ranges or the transcript as a compound range depends on the use case; both should be supported.”limitations[2]
limitationThe best alignment structure depends on whether analysis counts pairs, reads, or gap-separated segments. — “Read alignments may be loaded from a BAM file as a GappedAlignments or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignment results in terms of the position, chromosome, strand, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operations and can be coerced to GRanges and GRangesList . The GRanges representation holds the ungapped extents of the read alignments, whereas the GRangesList represents the alignments as ranges with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.”limitations[3]
limitationCTCF binding inferences require explicit treatment of base-calling and mapping errors plus wet-lab validation. — “In the murine ChIP-seq example discussed previously, the ranges infrastructure was used to compute and display variation in read coverage over the mouse genome. In this example, we use tools based on the ranges infrastructure to examine both coverage and content of reads from a larger ChIP-seq experiment on human cell lines. Our basic intent is to show how the infrastructure can be used to evaluate the roles of genotype and genetic diversity in the genomic sequences where CTCF is reported to bind, with an understanding that ultimate inferences on protein binding locations and on base-call distributions over heterozygous loci will need to directly incorporate risks of base calling and read mapping errors, and will need to be followed up with wet-lab validation.”limitations[4]
limitationAberrant quality distributions and batch-specific quality scales required exclusion and correction. — “For an investigation of the prevalence of allele-specific protein-DNA binding [10] , BAM files on 22 ChIP-seq experiments addressing CTCF binding to DNA from immortalized B-cells were collected from the ENCODE project portal. Exclusion of files with aberrant quality score distributions left 16 BAM files corresponding to 12 distinct individuals; two technical replicates were available for each of four individuals. Furthermore, different base-call quality score scales were used for two batches of samples; by subtracting 31 from the reported mean quality scores for one set of samples, approximately identical medians and interquartile ranges were established for mean quality scores for all retained samples. Base calls for reads bound at all genomic locations with positive coverage were tabulated using the VariantTools tallyVariants function, and reduced to locations exhibiting statistical evidence of allele-dependent CTCF binding using the callVariants function. Each of these variant assessment tools makes use of infrastructure derived from GSNAP [11] with key results materialized as GRanges instances. Table 4 depicts an excerpt from a callVariants output.”limitations[5]
limitationOff-SNP imbalance calls were frequently low quality and unlikely to replicate. — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”limitations[6]
limitationApparent allele imbalance mixes biology with sequencing and read-mapping artifacts. — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”limitations[7]
limitationThe infrastructure still lacked better range visualizations for RNA-seq and variant-calling diagnostics. — “All of the packages described, including IRanges , GenomicRanges and GenomicFeatures , form the core infrastructure for sequence analysis in Bioconductor and are available from the project website: http://bioconductor.org (see also Software S1 - S3 ). We aim to continue to support scientists in their drive to further science by asking increasingly complex and integrative questions about increasingly complex and heterogeneous data. For example, we are working towards better support for detecting alternative and novel splicing, measuring isoform-specific expression, annotating sequence variants, mapping between genome, transcript and protein coordinate spaces, and integrating transcript annotations with gene-level metadata. There is also an unmet need in the visualization of genomic ranges. In particular, we need better visualizations for relating RNA-seq coverage and junction counts to transcript structures, and for diagnosing read alignments in the context of variant calling. Finally, as datasets continue to expand in size, we continue to seek more efficient algorithms and data structures, and we are vigilant for opportunities to leverage parallel computing.”limitations[8]
limitationGrowing data volume creates continuing demand for more efficient and parallel algorithms. — “All of the packages described, including IRanges , GenomicRanges and GenomicFeatures , form the core infrastructure for sequence analysis in Bioconductor and are available from the project website: http://bioconductor.org (see also Software S1 - S3 ). We aim to continue to support scientists in their drive to further science by asking increasingly complex and integrative questions about increasingly complex and heterogeneous data. For example, we are working towards better support for detecting alternative and novel splicing, measuring isoform-specific expression, annotating sequence variants, mapping between genome, transcript and protein coordinate spaces, and integrating transcript annotations with gene-level metadata. There is also an unmet need in the visualization of genomic ranges. In particular, we need better visualizations for relating RNA-seq coverage and junction counts to transcript structures, and for diagnosing read alignments in the context of variant calling. Finally, as datasets continue to expand in size, we continue to seek more efficient algorithms and data structures, and we are vigilant for opportunities to leverage parallel computing.”limitations[9]
Content tags
content-observations: finding · quantity · variable · definition · key-term — grounded in the full text
findingTreating annotations and measurements as genome ranges provides a common scaffold for integration. — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”content_tags.findings[0]
findingRange operations underlie gene-model manipulation, coverage, peak annotation, and expression estimation. — “For example, ranges are integral to the manipulation of gene model annotations. Examples include deriving candidate promoter regions, finding introns, calculating the total exonic length of a transcript or finding the exonic regions that are unique to a particular transcript in an alternatively spliced gene. Ranges also play a central role in the analysis of experimental data, where they are used to represent read alignments. In the analysis of ChIP-seq data, it is typical to calculate the depth of alignment coverage, which then serves as input to calling algorithms which output peaks as ranges. These ranges are then annotated according to their overlap with and proximity to other ranges, such as gene structures. Similarly, for RNA-seq data, analysts measure gene expression based on counting the alignments overlapping exons.”content_tags.findings[1]
findingExplicit range APIs improve efficiency, readability, interoperability, and maintainability. — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”content_tags.findings[2]
findingShared formal classes let the language regulate access, integrity, and method dispatch. — “These data structures are represented as classes, through which we communicate the formal definition of each data structure to the programming language. One benefit is that we can defer the regulation of data access and the tracking of data integrity to the language. In the case of functional object-oriented languages, there is another benefit: we can implement behaviors as methods on generic functions. A generic function is one that dispatches to a particular implementation, termed a method, based on the classes of passed arguments. This means that the same API will exhibit specialized behavior depending on the input. For example calling start on a range data structure would return the starting positions for the ranges, while calling the same function on a base R time-series object would behave differently.”content_tags.findings[3]
findingThe three core packages directly support more than eighty other Bioconductor packages. — “This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structures for annotated genomic ranges and genome-length vectors, and efficient algorithms for overlap detection and other range operations. The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRanges package provides the fundamental range data structures and operations, while GenomicRanges builds upon it to add biological semantics to the metadata, including explicit treatment of sequence name and strand. Finally, GenomicFeatures enables access to and manipulation of gene models and other annotations. Together, these packages support more than 80 other packages in Bioconductor.”content_tags.findings[4]
findingCommand-line, file-centered workflows can be difficult to maintain and reproduce. — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”content_tags.findings[5]
findingInterval-tree overlap queries are vectorized and implemented in C to avoid expensive R iteration. — “A recurrent operation is overlap detection; various instances are illustrated in Figure 3 . In later sections, we apply overlap counting for finding the percentage of ChIP-seq peaks that overlap a promoter, counting the number of RNA-seq reads for each transcript, and other tasks. The findOverlaps function uses an efficient interval tree algorithm [4] to detect overlaps between two IRanges objects, as well as the more complex range-based data structures introduced later. The algorithm supports several types of overlap, including those defined by Allen's Interval Algebra [5] . The one-time cost of constructing the interval tree is , and queries are performed in logarithmic time. In accordance with the vectorized semantics of R, if multiple queries are submitted, they are efficiently processed in batch, without restarting at the root of the tree for each query. The language of implementation is C, which avoids the potentially expensive iteration over the tree in R.”content_tags.findings[6]
findingGenomicRanges adds chromosome, strand, and genome-build semantics absent from simple IRanges. — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”content_tags.findings[7]
findingMethod specialization provides one interface over different data structures and makes user code more robust. — “The GRanges class supports many of the same range operations as IRanges and specializes them for genomic data. We achieved API specialization by implementing methods for both classes on the same generic functions. In general, we believe method specialization is an effective practice for providing the same interface on top of different data structures. Abstracting implementation details leads to user code that is more robust and easier to write and maintain.”content_tags.findings[8]
findingGenomicFeatures normalizes multiple annotation sources behind a reproducible database API. — “Recalling our KRAS gene model example, there are multiple models for representing transcript structures, and the applicability of each depends on the use case. To support the analyst in asking a broad range of questions, there is a need for a mechanism that draws from a data source of gene annotations and returns them in a variety of different data models. The GenomicFeatures package fills that role by distilling multiple data sources into a single database schema and wrapping that database in an API that returns, for example, the exons grouped by gene, or the bounds for every transcript. The databases are implemented in SQLite and are thus accessible from environments outside of R. For reproducibility, a database may be encapsulated in a redistributable R package.”content_tags.findings[9]
findingRun-length encoding compresses genome-length vectors while preserving an ordinary-vector interface. — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”content_tags.findings[10]
findingSummarizedExperiment stores feature-by-sample summaries together with region, sample, and experiment annotations. — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”content_tags.findings[11]
findingThe CTCF example yielded thousands of allele-dependent sites but exposed quality-linked replication risk. — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”content_tags.findings[12]
findingObserved CTCF imbalances likely mix biological signal with sequencing and mapping artifacts. — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”content_tags.findings[13]
findingMore than eighty packages formed a dependent ecosystem around the ranges infrastructure. — “There is a growing ecosystem of packages based on this infrastructure. By current count, more than 80 packages depend directly on the packages presented here. This includes packages for input and output of ranges ( rtracklayer , Rsamtools ) [12] , [13] , quality assessment ( ShortRead ) [7] , sequence analysis ( Biostrings ) [14] , variant calling ( VariantTools ) [15] , and other tasks. To summarize the different use cases addressed by dependent packages, Table 5 tabulates the descriptive labels chosen from a controlled vocabulary by the package authors.”content_tags.findings[14]
quantitythree — packages at the core of the infrastructure — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”content_tags.quantities[0]
quantitymore than 80 — Bioconductor packages directly supported — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”content_tags.quantities[1]
quantitytwo — broad genomic-data categories — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”content_tags.quantities[2]
quantity35 nt — original CTCF and GFP read length — “For this example, mouse genomic DNA was cross-linked with DNA-binding proteins, fragmented and precipitated with an antibody for CTCF. An antibody for GFP was used for the control. The CTCF and GFP samples were each sequenced in a single lane on an Illumina sequencer, which generated reads 35 nt in length [6] . We excluded the last 11 nt of each read due to insufficient quality, so the effective read length was 24 nt. The reads were aligned to the mm9 build of the mouse genome using MAQ. We parsed the MAQ output using the ShortRead package [7] , and the alignments for three chromosomes (chr10, chr11 and chr12) were extracted for use as a demonstration data set in the chipseq package [8] .”content_tags.quantities[3]
quantity24 nt — effective read length after quality trimming — “For this example, mouse genomic DNA was cross-linked with DNA-binding proteins, fragmented and precipitated with an antibody for CTCF. An antibody for GFP was used for the control. The CTCF and GFP samples were each sequenced in a single lane on an Illumina sequencer, which generated reads 35 nt in length [6] . We excluded the last 11 nt of each read due to insufficient quality, so the effective read length was 24 nt. The reads were aligned to the mm9 build of the mouse genome using MAQ. We parsed the MAQ output using the ShortRead package [7] , and the alignments for three chromosomes (chr10, chr11 and chr12) were extracted for use as a demonstration data set in the chipseq package [8] .”content_tags.quantities[4]
quantity120 nt — assumed fragment length in the CTCF demonstration — “Each read represents only 24 nt from one end of a fragment of DNA. Since it was the fragment, but not necessarily the sequenced region, that was cross-linked to CTCF, we need to consider the entire fragment when predicting binding sites. We assume that the fragment length was approximately 120 nt and call resize to extend our read ranges to fragment-sized ranges:”content_tags.quantities[5]
quantity22 — CTCF ChIP-seq experiments initially collected — “For an investigation of the prevalence of allele-specific protein-DNA binding [10] , BAM files on 22 ChIP-seq experiments addressing CTCF binding to DNA from immortalized B-cells were collected from the ENCODE project portal. Exclusion of files with aberrant quality score distributions left 16 BAM files corresponding to 12 distinct individuals; two technical replicates were available for each of four individuals. Furthermore, different base-call quality score scales were used for two batches of samples; by subtracting 31 from the reported mean quality scores for one set of samples, approximately identical medians and interquartile ranges were established for mean quality scores for all retained samples. Base calls for reads bound at all genomic locations with positive coverage were tabulated using the VariantTools tallyVariants function, and reduced to locations exhibiting statistical evidence of allele-dependent CTCF binding using the callVariants function. Each of these variant assessment tools makes use of infrastructure derived from GSNAP [11] with key results materialized as GRanges instances. Table 4 depicts an excerpt from a callVariants output.”content_tags.quantities[6]
quantity16 — BAM files retained after quality-score exclusion — “For an investigation of the prevalence of allele-specific protein-DNA binding [10] , BAM files on 22 ChIP-seq experiments addressing CTCF binding to DNA from immortalized B-cells were collected from the ENCODE project portal. Exclusion of files with aberrant quality score distributions left 16 BAM files corresponding to 12 distinct individuals; two technical replicates were available for each of four individuals. Furthermore, different base-call quality score scales were used for two batches of samples; by subtracting 31 from the reported mean quality scores for one set of samples, approximately identical medians and interquartile ranges were established for mean quality scores for all retained samples. Base calls for reads bound at all genomic locations with positive coverage were tabulated using the VariantTools tallyVariants function, and reduced to locations exhibiting statistical evidence of allele-dependent CTCF binding using the callVariants function. Each of these variant assessment tools makes use of infrastructure derived from GSNAP [11] with key results materialized as GRanges instances. Table 4 depicts an excerpt from a callVariants output.”content_tags.quantities[7]
quantity12 — distinct individuals represented by retained BAM files — “For an investigation of the prevalence of allele-specific protein-DNA binding [10] , BAM files on 22 ChIP-seq experiments addressing CTCF binding to DNA from immortalized B-cells were collected from the ENCODE project portal. Exclusion of files with aberrant quality score distributions left 16 BAM files corresponding to 12 distinct individuals; two technical replicates were available for each of four individuals. Furthermore, different base-call quality score scales were used for two batches of samples; by subtracting 31 from the reported mean quality scores for one set of samples, approximately identical medians and interquartile ranges were established for mean quality scores for all retained samples. Base calls for reads bound at all genomic locations with positive coverage were tabulated using the VariantTools tallyVariants function, and reduced to locations exhibiting statistical evidence of allele-dependent CTCF binding using the callVariants function. Each of these variant assessment tools makes use of infrastructure derived from GSNAP [11] with key results materialized as GRanges instances. Table 4 depicts an excerpt from a callVariants output.”content_tags.quantities[8]
quantity19655 — locations with evidence of allele-dependent CTCF binding — “The genome-wide searches for allele-dependent CTCF binding events employed default settings for variant calling by VariantTools callVariants , which include criteria on minimum coverage, minimum diversity of read cycles at which base is found, and limitation of risk of strand bias. This process yielded a total of 19655 locations with evidence of allele-dependent CTCF binding, corresponding to 50750 events over the 12 individuals. We obtained GRanges representations of dbSNP build 137 with the scanVcf function of the VariantAnnotation . This facilitated distributed computation for partitioning allele-dependent CTCF binding events into 12691 coincident with known polymorphisms and 6964 at locations where no SNP has been reported in dbSNP.”content_tags.quantities[9]
quantity50750 — binding events over twelve individuals — “The genome-wide searches for allele-dependent CTCF binding events employed default settings for variant calling by VariantTools callVariants , which include criteria on minimum coverage, minimum diversity of read cycles at which base is found, and limitation of risk of strand bias. This process yielded a total of 19655 locations with evidence of allele-dependent CTCF binding, corresponding to 50750 events over the 12 individuals. We obtained GRanges representations of dbSNP build 137 with the scanVcf function of the VariantAnnotation . This facilitated distributed computation for partitioning allele-dependent CTCF binding events into 12691 coincident with known polymorphisms and 6964 at locations where no SNP has been reported in dbSNP.”content_tags.quantities[10]
quantity12691 — events coincident with known polymorphisms — “The genome-wide searches for allele-dependent CTCF binding events employed default settings for variant calling by VariantTools callVariants , which include criteria on minimum coverage, minimum diversity of read cycles at which base is found, and limitation of risk of strand bias. This process yielded a total of 19655 locations with evidence of allele-dependent CTCF binding, corresponding to 50750 events over the 12 individuals. We obtained GRanges representations of dbSNP build 137 with the scanVcf function of the VariantAnnotation . This facilitated distributed computation for partitioning allele-dependent CTCF binding events into 12691 coincident with known polymorphisms and 6964 at locations where no SNP has been reported in dbSNP.”content_tags.quantities[11]
quantity6964 — events at locations with no dbSNP report — “The genome-wide searches for allele-dependent CTCF binding events employed default settings for variant calling by VariantTools callVariants , which include criteria on minimum coverage, minimum diversity of read cycles at which base is found, and limitation of risk of strand bias. This process yielded a total of 19655 locations with evidence of allele-dependent CTCF binding, corresponding to 50750 events over the 12 individuals. We obtained GRanges representations of dbSNP build 137 with the scanVcf function of the VariantAnnotation . This facilitated distributed computation for partitioning allele-dependent CTCF binding events into 12691 coincident with known polymorphisms and 6964 at locations where no SNP has been reported in dbSNP.”content_tags.quantities[12]
quantity41% — stated low-quality frequency for off-SNP calls with ANP below 20 percent — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”content_tags.quantities[13]
variablechromosome name (special genomic-range metadata) — “Data structures should support the storage of per-range metadata, because genomic data is multivariate and consists of much more than the ranges alone. This enables the storage of gene identifiers and other symbols with the gene ranges, and the peak heights or confidence scores with the peak ranges. Some metadata merit special treatment, such as the chromosome name and the strand. Also necessary is a data structure for storing summaries and processing results for a common set of ranges across multiple samples. Such a structure would hold, for example, the RNA-seq per-exon counts or a set of variant calls. Finally, there should be support for storing hierarchies of ranges, at least for one level of nesting, to represent, for example, the nesting of exons into transcripts. Whether it is appropriate to treat the exons as individual ranges or the transcript as a compound range depends on the use case; both should be supported.”content_tags.variables[0]
variablestrand (directional genomic-range metadata) — “Data structures should support the storage of per-range metadata, because genomic data is multivariate and consists of much more than the ranges alone. This enables the storage of gene identifiers and other symbols with the gene ranges, and the peak heights or confidence scores with the peak ranges. Some metadata merit special treatment, such as the chromosome name and the strand. Also necessary is a data structure for storing summaries and processing results for a common set of ranges across multiple samples. Such a structure would hold, for example, the RNA-seq per-exon counts or a set of variant calls. Finally, there should be support for storing hierarchies of ranges, at least for one level of nesting, to represent, for example, the nesting of exons into transcripts. Whether it is appropriate to treat the exons as individual ranges or the transcript as a compound range depends on the use case; both should be supported.”content_tags.variables[1]
variablestart (range boundary and API coordinate) — “The available range operations are listed in Table 1 . The IRanges object supports direct manipulation of the start, end and width of the contained ranges. In applications, many of these operations follow recurrent patterns, and manipulating start and end directly can be needlessly tedious and error-prone. For this reason, shift , resize and similar frequently useful range operations are provided. Ranges can be simplified and summarized with several functions, including range , reduce and disjoin . Figure 2 illustrates the latter two. It is often appropriate to conceive of an IRanges object as a mathematical set of integers, or, in the biological context, a set of nucleotide positions. gaps (complement), union , intersect and setdiff support this notion. For example, taking the union of two transcripts would yield the ranges covered by any KRAS exon. The flank function could be used to demarcate putative promoter regions of transcripts.”content_tags.variables[2]
variableend (range boundary and API coordinate) — “The available range operations are listed in Table 1 . The IRanges object supports direct manipulation of the start, end and width of the contained ranges. In applications, many of these operations follow recurrent patterns, and manipulating start and end directly can be needlessly tedious and error-prone. For this reason, shift , resize and similar frequently useful range operations are provided. Ranges can be simplified and summarized with several functions, including range , reduce and disjoin . Figure 2 illustrates the latter two. It is often appropriate to conceive of an IRanges object as a mathematical set of integers, or, in the biological context, a set of nucleotide positions. gaps (complement), union , intersect and setdiff support this notion. For example, taking the union of two transcripts would yield the ranges covered by any KRAS exon. The flank function could be used to demarcate putative promoter regions of transcripts.”content_tags.variables[3]
variablecoverage (input to peak detection and per-position genomic summary) — “A common method of summarizing a genomic data set is to calculate the coverage, i.e., the number of features in the data set overlapping each position in the genome. This is useful in ChIP-seq analysis, where many peak detection methods operate on the coverage.”content_tags.variables[4]
variablealternate nucleotide proportion (allelic-imbalance measure) — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”content_tags.variables[5]
variablebase-call quality (artifact and replication-risk indicator) — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”content_tags.variables[6]
definitionrange — “We use the term “range” to denote an ordered set of consecutive integers.”content_tags.definitions[0]
definitioncoverage — “A common method of summarizing a genomic data set is to calculate the coverage, i.e., the number of features in the data set overlapping each position in the genome. This is useful in ChIP-seq analysis, where many peak detection methods operate on the coverage.”content_tags.definitions[1]
definitiongeneric function — “These data structures are represented as classes, through which we communicate the formal definition of each data structure to the programming language. One benefit is that we can defer the regulation of data access and the tracking of data integrity to the language. In the case of functional object-oriented languages, there is another benefit: we can implement behaviors as methods on generic functions. A generic function is one that dispatches to a particular implementation, termed a method, based on the classes of passed arguments. This means that the same API will exhibit specialized behavior depending on the input. For example calling start on a range data structure would return the starting positions for the ranges, while calling the same function on a base R time-series object would behave differently.”content_tags.definitions[2]
definitionmethod — “These data structures are represented as classes, through which we communicate the formal definition of each data structure to the programming language. One benefit is that we can defer the regulation of data access and the tracking of data integrity to the language. In the case of functional object-oriented languages, there is another benefit: we can implement behaviors as methods on generic functions. A generic function is one that dispatches to a particular implementation, termed a method, based on the classes of passed arguments. This means that the same API will exhibit specialized behavior depending on the input. For example calling start on a range data structure would return the starting positions for the ranges, while calling the same function on a base R time-series object would behave differently.”content_tags.definitions[3]
definitionGRangesList — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”content_tags.definitions[4]
definitionmetadata — “Every multi-element data structure in the IRanges suite supports the storage of per-element metadata: data about data. In this case, the metadata are the annotations, and the primary data are the ranges being annotated. This includes all of the data structures for storing ranges, such as IRanges, GRanges and GRangesList . The metadata are stored in a DataFrame with as many rows as there are elements in the object. We introduce a DataFrame class that behaves similarly to the base R data.frame , but supports storage of complex vector-like objects (e.g., a DNAStringSet , representing DNA sequences, or a GRanges ) in columns.”content_tags.definitions[5]
definitionRle — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”content_tags.definitions[6]
definitionSummarizedExperiment — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”content_tags.definitions[7]
definitionallelic imbalance — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”content_tags.definitions[8]
Concepts
terms this paper carries, each with the sentence it was cut from — the layer that joins one paper to another. Terms with no quote yet are on CONCEPTS.html.
conceptBioconductor infrastructure — not defined in this paper's own words; shared software infrastructure for genomic ranges — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[0]
conceptannotated genomic ranges — not defined in this paper's own words; genome intervals carrying biological metadata — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[1]
conceptIRanges — not defined in this paper's own words; core package for integer-range structures and operations — “This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structures for annotated genomic ranges and genome-length vectors, and efficient algorithms for overlap detection and other range operations. The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRanges package provides the fundamental range data structures and operations, while GenomicRanges builds upon it to add biological semantics to the metadata, including explicit treatment of sequence name and strand. Finally, GenomicFeatures enables access to and manipulation of gene models and other annotations. Together, these packages support more than 80 other packages in Bioconductor.”concepts[2]
conceptGenomicRanges — not defined in this paper's own words; core package adding genomic semantics to ranges — “This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structures for annotated genomic ranges and genome-length vectors, and efficient algorithms for overlap detection and other range operations. The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRanges package provides the fundamental range data structures and operations, while GenomicRanges builds upon it to add biological semantics to the metadata, including explicit treatment of sequence name and strand. Finally, GenomicFeatures enables access to and manipulation of gene models and other annotations. Together, these packages support more than 80 other packages in Bioconductor.”concepts[3]
conceptGenomicFeatures — not defined in this paper's own words; core package for gene-model access and manipulation — “This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structures for annotated genomic ranges and genome-length vectors, and efficient algorithms for overlap detection and other range operations. The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRanges package provides the fundamental range data structures and operations, while GenomicRanges builds upon it to add biological semantics to the metadata, including explicit treatment of sequence name and strand. Finally, GenomicFeatures enables access to and manipulation of gene models and other annotations. Together, these packages support more than 80 other packages in Bioconductor.”concepts[4]
conceptcore of the infrastructure — not defined in this paper's own words; three-package foundation of the range framework — “This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structures for annotated genomic ranges and genome-length vectors, and efficient algorithms for overlap detection and other range operations. The packages that form the core of the infrastructure include IRanges , GenomicRanges and GenomicFeatures . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRanges package provides the fundamental range data structures and operations, while GenomicRanges builds upon it to add biological semantics to the metadata, including explicit treatment of sequence name and strand. Finally, GenomicFeatures enables access to and manipulation of gene models and other annotations. Together, these packages support more than 80 other packages in Bioconductor.”concepts[5]
conceptscalable data structures — not defined in this paper's own words; range representations designed to scale — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[6]
concepttranscript structures — not defined in this paper's own words; nested genomic models of transcripts and exons — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[7]
conceptread alignments — not defined in this paper's own words; mapped sequencing reads represented as genomic ranges — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[8]
conceptcoverage vectors — not defined in this paper's own words; per-position counts across genome coordinates — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[9]
conceptoverlap detection — not defined in this paper's own words; detection of intersecting genomic ranges — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[10]
conceptnearest neighbor detection — not defined in this paper's own words; detection of nearby genomic ranges — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[11]
conceptrange operations — not defined in this paper's own words; set-like and geometric operations over ranges — “We describe Bioconductor infrastructure for representing and computing on annotated genomic ranges and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructure are three packages: IRanges , GenomicRanges , and GenomicFeatures . These packages provide scalable data structures for representing annotated ranges on the genome, with special support for transcript structures, read alignments and coverage vectors. Computational facilities include efficient algorithms for overlap and nearest neighbor detection, coverage calculation and other range operations. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.”concepts[12]
conceptlinear sequence — not defined in this paper's own words; coordinate representation of a chromosome-split genome — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”concepts[13]
conceptannotations — not defined in this paper's own words; processed genomic metadata such as gene models and scores — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”concepts[14]
conceptprimary experimental measurements — not defined in this paper's own words; direct assay output such as sequencing alignments — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”concepts[15]
conceptcommon scaffold — not defined in this paper's own words; shared genome-coordinate basis for data integration — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”concepts[16]
conceptgenomic data analysis — not defined in this paper's own words; analysis centered on coordinate-linked genomic data — “The genome is typically represented as a linear sequence, split over multiple chromosomes, and data are linked to the genome by occupying a range of positions on the sequence. These data fall into two broad categories. First, there are the annotations, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotations are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurements, such as read alignments from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as ranges on the genome, which acts as a common scaffold. Thus, ranges play a central role in genomic data analysis, and statistical tools should consider ranges to be as fundamental as quantitative and categorical data types.”concepts[17]
conceptintersection — not defined in this paper's own words; set operation on ranges — “All these analyses depend on specialized, range-based algorithms and data structures. For example, computations on gene models involve set operations on ranges, including intersection, union and complement. Coverage calculation is important for detecting regions of enrichment and for producing visual summaries. Overlap and nearest neighbor detection is fundamental to the annotation of ChIP-seq peaks, estimating expression from RNA-seq data and many other integrative analyses.”concepts[18]
conceptunion — not defined in this paper's own words; set operation combining ranges — “All these analyses depend on specialized, range-based algorithms and data structures. For example, computations on gene models involve set operations on ranges, including intersection, union and complement. Coverage calculation is important for detecting regions of enrichment and for producing visual summaries. Overlap and nearest neighbor detection is fundamental to the annotation of ChIP-seq peaks, estimating expression from RNA-seq data and many other integrative analyses.”concepts[19]
conceptcomplement — not defined in this paper's own words; set operation returning gaps — “All these analyses depend on specialized, range-based algorithms and data structures. For example, computations on gene models involve set operations on ranges, including intersection, union and complement. Coverage calculation is important for detecting regions of enrichment and for producing visual summaries. Overlap and nearest neighbor detection is fundamental to the annotation of ChIP-seq peaks, estimating expression from RNA-seq data and many other integrative analyses.”concepts[20]
conceptspecialized, formal data structures — not defined in this paper's own words; explicit range types exposed through an API — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concepts[21]
conceptapplication programming interface (API) — not defined in this paper's own words; range-oriented interface hiding implementation details — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concepts[22]
conceptinteroperability — not defined in this paper's own words; cross-package operation without cumbersome conversion — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concepts[23]
conceptabstraction — not defined in this paper's own words; interface hiding optimized implementation details — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concepts[24]
conceptrobust, maintainable software — not defined in this paper's own words; software quality attributed to shared structures and abstraction — “The primary argument for storing ranges in specialized, formal data structures is efficiency, in terms of both implementation and language. The notion of ranges can be made explicit in the application programming interface (API), permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperability: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstraction that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable software.”concepts[25]
conceptper-range metadata — not defined in this paper's own words; annotations stored alongside individual ranges — “Data structures should support the storage of per-range metadata, because genomic data is multivariate and consists of much more than the ranges alone. This enables the storage of gene identifiers and other symbols with the gene ranges, and the peak heights or confidence scores with the peak ranges. Some metadata merit special treatment, such as the chromosome name and the strand. Also necessary is a data structure for storing summaries and processing results for a common set of ranges across multiple samples. Such a structure would hold, for example, the RNA-seq per-exon counts or a set of variant calls. Finally, there should be support for storing hierarchies of ranges, at least for one level of nesting, to represent, for example, the nesting of exons into transcripts. Whether it is appropriate to treat the exons as individual ranges or the transcript as a compound range depends on the use case; both should be supported.”concepts[26]
conceptgeneric function — not defined in this paper's own words; function dispatching implementation by argument class — “These data structures are represented as classes, through which we communicate the formal definition of each data structure to the programming language. One benefit is that we can defer the regulation of data access and the tracking of data integrity to the language. In the case of functional object-oriented languages, there is another benefit: we can implement behaviors as methods on generic functions. A generic function is one that dispatches to a particular implementation, termed a method, based on the classes of passed arguments. This means that the same API will exhibit specialized behavior depending on the input. For example calling start on a range data structure would return the starting positions for the ranges, while calling the same function on a base R time-series object would behave differently.”concepts[27]
conceptmethod — not defined in this paper's own words; class-specific implementation of a generic function — “These data structures are represented as classes, through which we communicate the formal definition of each data structure to the programming language. One benefit is that we can defer the regulation of data access and the tracking of data integrity to the language. In the case of functional object-oriented languages, there is another benefit: we can implement behaviors as methods on generic functions. A generic function is one that dispatches to a particular implementation, termed a method, based on the classes of passed arguments. This means that the same API will exhibit specialized behavior depending on the input. For example calling start on a range data structure would return the starting positions for the ranges, while calling the same function on a base R time-series object would behave differently.”concepts[28]
conceptrange — ordered set of consecutive integers — “We use the term “range” to denote an ordered set of consecutive integers.”concepts[29]
conceptordered set of consecutive integers — not defined in this paper's own words; formal meaning assigned to range — “We use the term “range” to denote an ordered set of consecutive integers.”concepts[30]
conceptIRanges class — not defined in this paper's own words; vector representation of simple ranges — “The IRanges package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges class to represent a vector of ranges. The GenomicRanges package builds on IRanges to include biologically relevant features such as strand and sequence (e.g., chromosome) name.”concepts[31]
conceptGRanges class — not defined in this paper's own words; genomic range representation including chromosome and strand — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”concepts[32]
conceptreference genome sequence — not defined in this paper's own words; versioned chromosome or contig coordinate system — “The IRanges class encodes only the start and end of ranges but not the chromosome, strand nor other information that is important in genomic applications. The GenomicRanges package adds biological semantics on top of IRanges . At its core is the GRanges class. Each element of a GRanges instance includes a chromosome identifier and strand designation. Each data set is associated with a particular, versioned reference genome sequence consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges class thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.”concepts[33]
conceptGRangesList — not defined in this paper's own words; hierarchical list of compound genomic features — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”concepts[34]
conceptcompound feature — not defined in this paper's own words; multi-range biological feature — “Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRanges objects may be combined into a GRangesList , where each GRanges is considered a compound feature. GRangesList groups transcripts by gene, groups exons by transcript, and represents read alignments, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesList . A note on performance: although the user interface presents each element of a GRangesList as a GRanges , internally there is only a single GRanges , along with an assoicated partitioning that forms the list elements.”concepts[35]
conceptTranscriptDb — not defined in this paper's own words; database-backed gene-model representation — “The database is represented by the TranscriptDb class and stores the range of each exon, the coding range, the transcript ID, the gene ID, and metadata about the source of the transcript information. The GenomicFeatures package provides an automated mechanism for constructing a TranscriptDb object from tracks defined in the UCSC genome browser, Biomart, or GTF/GFF files. Bioconductor provides pre-built packages for the most widely adopted gene models, like the UCSC known gene annotations on hg19. These packages follow a standard naming convention, e.g., TxDb.Hsapiens.UCSC.hg19.knownGene .”concepts[36]
conceptDataFrame — not defined in this paper's own words; metadata table supporting complex vector-like columns — “Every multi-element data structure in the IRanges suite supports the storage of per-element metadata: data about data. In this case, the metadata are the annotations, and the primary data are the ranges being annotated. This includes all of the data structures for storing ranges, such as IRanges, GRanges and GRangesList . The metadata are stored in a DataFrame with as many rows as there are elements in the object. We introduce a DataFrame class that behaves similarly to the base R data.frame , but supports storage of complex vector-like objects (e.g., a DNAStringSet , representing DNA sequences, or a GRanges ) in columns.”concepts[37]
conceptprimary data — ranges being annotated — “Every multi-element data structure in the IRanges suite supports the storage of per-element metadata: data about data. In this case, the metadata are the annotations, and the primary data are the ranges being annotated. This includes all of the data structures for storing ranges, such as IRanges, GRanges and GRangesList . The metadata are stored in a DataFrame with as many rows as there are elements in the object. We introduce a DataFrame class that behaves similarly to the base R data.frame , but supports storage of complex vector-like objects (e.g., a DNAStringSet , representing DNA sequences, or a GRanges ) in columns.”concepts[38]
conceptmetadata — not defined in this paper's own words; annotations about the primary ranges — “Every multi-element data structure in the IRanges suite supports the storage of per-element metadata: data about data. In this case, the metadata are the annotations, and the primary data are the ranges being annotated. This includes all of the data structures for storing ranges, such as IRanges, GRanges and GRangesList . The metadata are stored in a DataFrame with as many rows as there are elements in the object. We introduce a DataFrame class that behaves similarly to the base R data.frame , but supports storage of complex vector-like objects (e.g., a DNAStringSet , representing DNA sequences, or a GRanges ) in columns.”concepts[39]
conceptcoverage — not defined in this paper's own words; per-position count of overlapping features — “A common method of summarizing a genomic data set is to calculate the coverage, i.e., the number of features in the data set overlapping each position in the genome. This is useful in ChIP-seq analysis, where many peak detection methods operate on the coverage.”concepts[40]
conceptnumber of features in the data set overlapping each position in the genome — not defined in this paper's own words; operational definition of coverage — “A common method of summarizing a genomic data set is to calculate the coverage, i.e., the number of features in the data set overlapping each position in the genome. This is useful in ChIP-seq analysis, where many peak detection methods operate on the coverage.”concepts[41]
conceptRle — not defined in this paper's own words; run-length encoded vector class — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”concepts[42]
conceptrun-length encoded vector — not defined in this paper's own words; compressed vector representation — “Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rle class represents a run-length encoded vector and provides features beyond those of ordinary vectors. For example, one can use ranges to extract values from an Rle . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverage on chr10, and, in order to display the coverage in context, we extract a 5000 nt region centered around that position:”concepts[43]
conceptBAM file — not defined in this paper's own words; file containing mapped sequencing reads — “Read alignments may be loaded from a BAM file as a GappedAlignments or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignment results in terms of the position, chromosome, strand, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operations and can be coerced to GRanges and GRangesList . The GRanges representation holds the ungapped extents of the read alignments, whereas the GRangesList represents the alignments as ranges with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.”concepts[44]
conceptGappedAlignments — not defined in this paper's own words; read-alignment representation retaining gaps — “Read alignments may be loaded from a BAM file as a GappedAlignments or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignment results in terms of the position, chromosome, strand, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operations and can be coerced to GRanges and GRangesList . The GRanges representation holds the ungapped extents of the read alignments, whereas the GRangesList represents the alignments as ranges with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.”concepts[45]
conceptSummarizedExperiment — not defined in this paper's own words; matrix-centered genomic experiment container — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”concepts[46]
conceptExpressionSet — not defined in this paper's own words; microarray infrastructure pattern reused by SummarizedExperiment — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”concepts[47]
conceptallele-specific protein-DNA binding — not defined in this paper's own words; genotype-dependent CTCF binding — “For an investigation of the prevalence of allele-specific protein-DNA binding [10] , BAM files on 22 ChIP-seq experiments addressing CTCF binding to DNA from immortalized B-cells were collected from the ENCODE project portal. Exclusion of files with aberrant quality score distributions left 16 BAM files corresponding to 12 distinct individuals; two technical replicates were available for each of four individuals. Furthermore, different base-call quality score scales were used for two batches of samples; by subtracting 31 from the reported mean quality scores for one set of samples, approximately identical medians and interquartile ranges were established for mean quality scores for all retained samples. Base calls for reads bound at all genomic locations with positive coverage were tabulated using the VariantTools tallyVariants function, and reduced to locations exhibiting statistical evidence of allele-dependent CTCF binding using the callVariants function. Each of these variant assessment tools makes use of infrastructure derived from GSNAP [11] with key results materialized as GRanges instances. Table 4 depicts an excerpt from a callVariants output.”concepts[48]
conceptalternate nucleotide proportion — not defined in this paper's own words; proportion used to characterize allelic imbalance — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”concepts[49]
conceptANP — not defined in this paper's own words; abbreviation for alternate nucleotide proportion — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”concepts[50]
conceptbase-call quality — not defined in this paper's own words; quality indicator for nucleotide calls — “Allelic imbalance in CTCF binding corresponds to departure of the alternate nucleotide proportion (ANP) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANP stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANP and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANP below 20%, there is also an indication that base-call quality for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANP below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.”concepts[51]
concepttechnical artifacts — not defined in this paper's own words; apparent imbalances produced by sequencing or mapping errors — “Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalance in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifacts originating from, e.g., sequencing and read mapping errors. Careful analysis of metadata collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.”concepts[52]
conceptgrowing ecosystem of packages — not defined in this paper's own words; dependent package ecosystem built on the range infrastructure — “There is a growing ecosystem of packages based on this infrastructure. By current count, more than 80 packages depend directly on the packages presented here. This includes packages for input and output of ranges ( rtracklayer , Rsamtools ) [12] , [13] , quality assessment ( ShortRead ) [7] , sequence analysis ( Biostrings ) [14] , variant calling ( VariantTools ) [15] , and other tasks. To summarize the different use cases addressed by dependent packages, Table 5 tabulates the descriptive labels chosen from a controlled vocabulary by the package authors.”concepts[53]
conceptcore infrastructure for sequence analysis — not defined in this paper's own words; range packages forming Bioconductor's sequence foundation — “All of the packages described, including IRanges , GenomicRanges and GenomicFeatures , form the core infrastructure for sequence analysis in Bioconductor and are available from the project website: http://bioconductor.org (see also Software S1 - S3 ). We aim to continue to support scientists in their drive to further science by asking increasingly complex and integrative questions about increasingly complex and heterogeneous data. For example, we are working towards better support for detecting alternative and novel splicing, measuring isoform-specific expression, annotating sequence variants, mapping between genome, transcript and protein coordinate spaces, and integrating transcript annotations with gene-level metadata. There is also an unmet need in the visualization of genomic ranges. In particular, we need better visualizations for relating RNA-seq coverage and junction counts to transcript structures, and for diagnosing read alignments in the context of variant calling. Finally, as datasets continue to expand in size, we continue to seek more efficient algorithms and data structures, and we are vigilant for opportunities to leverage parallel computing.”concepts[54]
conceptparallel computing — not defined in this paper's own words; future path for scaling range computations — “All of the packages described, including IRanges , GenomicRanges and GenomicFeatures , form the core infrastructure for sequence analysis in Bioconductor and are available from the project website: http://bioconductor.org (see also Software S1 - S3 ). We aim to continue to support scientists in their drive to further science by asking increasingly complex and integrative questions about increasingly complex and heterogeneous data. For example, we are working towards better support for detecting alternative and novel splicing, measuring isoform-specific expression, annotating sequence variants, mapping between genome, transcript and protein coordinate spaces, and integrating transcript annotations with gene-level metadata. There is also an unmet need in the visualization of genomic ranges. In particular, we need better visualizations for relating RNA-seq coverage and junction counts to transcript structures, and for diagnosing read alignments in the context of variant calling. Finally, as datasets continue to expand in size, we continue to seek more efficient algorithms and data structures, and we are vigilant for opportunities to leverage parallel computing.”concepts[55]
conceptother software tools — not defined in this paper's own words; command-line genomic-range tools used for comparison — “Other software tools provide facilities for working with genomic ranges, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructure is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic ranges and utilities, such as overlap detection, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.”concepts[56]
conceptctcfReads object — not defined in this paper's own words; GRanges containing CTCF sample alignments — “The ctcfReads object, listed in Table 3 , is a GRanges holding the read alignments from the CTCF sample. The GRanges stores the chromosome names, ranges, and strand for each alignment, as well as a list of chromosome names and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.”concepts[57]
conceptGRanges — not defined in this paper's own words; genomic range class name — “The ctcfReads object, listed in Table 3 , is a GRanges holding the read alignments from the CTCF sample. The GRanges stores the chromosome names, ranges, and strand for each alignment, as well as a list of chromosome names and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.”concepts[58]
conceptcountOverlaps — not defined in this paper's own words; single-count overlap operation — “More complex counting algorithms are available via the summarizeOverlaps function, which counts over multiple samples and returns the results as a SummarizedExperiment object. Unlike the call to countOverlaps above, reads that map to multiple features are discarded.”concepts[59]
conceptsummarizeOverlaps — not defined in this paper's own words; multi-sample overlap summarization workflow — “The typical workflow in a genomic data analysis is to reduce a complex raw data set, such as a set of RNA-seq read alignments, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic ranges. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperiment class is designed to hold such values, along with annotations on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSet in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperiment is based on IRanges data structures. A SummarizedExperiment may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM files, the summarizeOverlaps function counts the overlaps between the read alignments and a database of transcripts.”concepts[60]

Full text — tagged

Software for Computing and Annotating Genomic Rangesterm Abstract We describe Bioconductor infrastructureterm for representing and computing on annotated genomic rangesterm and integrating genomic data with the statistical computing features of R and its extensions. At the core of the infrastructureterm are three packages: IRangesterm , GenomicRangesterm , and GenomicFeaturesterm . These packages provide scalable data structuresterm·mth for representing annotated rangesterm on the genome, with special support for transcript structuresterm, read alignmentsterm and coverage vectorsterm. Computational facilities include efficient algorithms for overlap and nearest neighbor detectionterm, coverageterm calculation and other range operationsterm. This infrastructure directly supports more than 80 other Bioconductor packages, including those for sequence analysis, differential expression analysis and visualization.

This is a PLOS Computational Biology Software Article.

Introduction The genome is typically represented as a linear sequenceterm, split over multiple chromosomes, and data are linked to the genome by occupying a rangeterm of positions on the sequence. These data fall into two broad categories. First, there are the annotationsterm, such as gene models, transcription factor binding site predictions, GC percentage, polymorphisms, and conservation scores. Such annotationsterm are highly processed and are often served by public databases such as NCBI or EBI. Second, there are primary experimental measurementsterm, such as read alignmentsterm from high-throughput sequencing. Data integration, within and between those two categories, is made possible by treating the data as rangesterm on the genome, which acts as a common scaffoldterm. Thus, rangesterm play a central role in genomic data analysisterm·dom, and statistical tools should consider rangesterm to be as fundamental as quantitative and categorical data types.

For example, rangesterm are integral to the manipulation of gene model annotationsterm. Examples include deriving candidate promoter regions, finding introns, calculating the total exonic length of a transcript or finding the exonic regions that are unique to a particular transcript in an alternatively spliced gene. Rangesterm also play a central role in the analysis of experimental data, where they are used to represent read alignmentsterm. In the analysis of ChIP-seq data, it is typical to calculate the depth of alignment coverageterm, which then serves as input to calling algorithms which output peaks as rangesterm. These rangesterm are then annotated according to their overlap with and proximity to other rangesterm, such as gene structures. Similarly, for RNA-seq data, analysts measure gene expression based on counting the alignments overlapping exons.

All these analyses depend on specialized, range-based algorithms and data structures. For example, computations on gene models involve set operations on rangesterm, including intersectionterm, unionterm and complementterm. Coverageterm calculation is important for detecting regions of enrichment and for producing visual summaries. Overlap and nearest neighbor detectionterm is fundamental to the annotationterm of ChIP-seq peaks, estimating expression from RNA-seq data and many other integrative analyses.

The primary argument for storing rangesterm in specialized, formal data structuresterm·mth is efficiency, in terms of both implementation and language. The notion of rangesterm can be made explicit in the application programming interface (API)term·mth, permitting the expression of algorithms in a succinct and readable language that illustrates concepts instead of exposing implementation details. Another goal is interoperabilityterm: by using the same data structures, multiple routines, spread across different packages, can operate on the data without cumbersome conversions. Also, a data structure can be accessed through an abstractionterm·mth that hides the details of the optimized implementation, and this results in looser coupling between components. Together, these benefits lead to more robust, maintainable softwareterm.

Data structures should support the storage of per-range metadataterm, because genomic data is multivariate and consists of much more than the rangesterm alone. This enables the storage of gene identifiers and other symbols with the gene rangesterm, and the peak heights or confidence scores with the peak rangesterm. Some metadataterm merit special treatment, such as the chromosome nameterm·var and the strandterm·var. Also necessary is a data structure for storing summaries and processing results for a common set of rangesterm across multiple samples. Such a structure would hold, for example, the RNA-seq per-exon counts or a set of variant calls. Finally, there should be support for storing hierarchies of rangesterm, at least for one level of nesting, to represent, for example, the nesting of exons into transcripts. Whether it is appropriate to treat the exons as individual rangesterm or the transcript as a compound rangeterm depends on the use case; both should be supported.

These data structures are represented as classes, through which we communicate the formal definition of each data structure to the programming language. One benefit is that we can defer the regulation of data access and the tracking of data integrity to the language. In the case of functional object-oriented languages, there is another benefit: we can implement behaviors as methodsterm·mth on generic functionsterm·mth. A generic functionterm·mth is one that dispatches to a particular implementation, termed a methodterm·mth, based on the classes of passed arguments. This means that the same API will exhibit specialized behavior depending on the input. For example calling startterm·var on a rangeterm data structure would return the starting positions for the rangesterm, while calling the same function on a base R time-series object would behave differently.

This paper describes the infrastructure in Bioconductor [1] for the integrative statistical analysis of range-based genomic data. Main features include scalable data structuresterm·mth for annotated genomic rangesterm and genome-length vectors, and efficient algorithms for overlap detectionterm and other range operationsterm. The packages that form the core of the infrastructureterm include IRangesterm , GenomicRangesterm and GenomicFeaturesterm . Source code for the packages is included in the supplement, under Software S1 , S2 , and S3 , respectively. The IRangesterm package provides the fundamental rangeterm data structures and operations, while GenomicRangesterm builds upon it to add biological semantics to the metadataterm, including explicit treatment of sequence name and strandterm·var. Finally, GenomicFeaturesterm enables access to and manipulation of gene models and other annotationsterm. Together, these packages support more than 80 other packages in Bioconductor.

Other software toolsterm provide facilities for working with genomic rangesterm, e.g., bedtools [2] and cisGenome [3] . Those provide UNIX command-line interfaces and rely on common file formats (which are often incompletely specified) to interoperate with other tools, leading to workflows embodied as: collections of heterogeneous scripts, system dependencies and data files. Such workflows can be difficult to maintain and challenging to reproduce. In contrast, the Bioconductor infrastructureterm is tightly integrated with other R packages through in-memory data structures, while still supporting interaction with external tools. The Bioconductor package genomeIntervals provides data structures for representing genomic rangesterm and utilities, such as overlap detectionterm, that have much in common with the tools described here, but our tools are more extensive and have been more widely adopted.

Design and Implementation Working with Simple Rangesterm We use the term “rangeterm” to denote an ordered set of consecutive integersterm. A rangeterm is represented by a pair of integers satisfying . In Figure 1 , and correspond to the startterm·var and endterm·var columns, respectively. The “width” of a rangeterm is given by , so a rangeterm for a single integer (modeling, for example, a single nucleotide position) has .

Tabular (top) and visual (bottom) representation of the exons for the human KRAS gene, derived from the UCSC known gene annotationterm. In the table, the columns seqnames , startterm·var and endterm·var locate the exons in the genome. The strandterm·var column indicates the direction of transcription. The exons are grouped into transcripts by tx_id , and the exon IDs are given by exon_id . Virtually all genomic data sets fit this pattern: genomic location, followed by a series of columns, often including strandterm·var and/or score, that annotate that location. In the plot, the rectangles represent exonic regions, and the arrows represent the introns, as well as the strandterm·var.

The IRangesterm package, which is designed to be general and thus avoids biology-specific considerations, introduces the IRanges classterm·mth to represent a vector of rangesterm. The GenomicRangesterm package builds on IRangesterm to include biologically relevant features such as strandterm·var and sequence (e.g., chromosome) name.

In Figure 1 , we show a table of the exons of the human gene KRAS . The tx_id column indicates the transcripts to which each exon belongs. A single IRangesterm object can store those exon rangesterm, and this model is appropriate for per-exon analyses.

The IRanges classterm·mth supports the basic R vector API, including the length accessor, extraction and subsetting functions like [[ and [ , concatenation with c, etc. This will hold true for all vector-like objects in the rangeterm infrastructure.

The available range operationsterm are listed in Table 1 . The IRangesterm object supports direct manipulation of the startterm·var, endterm·var and width of the contained rangesterm. In applications, many of these operations follow recurrent patterns, and manipulating startterm·var and endterm·var directly can be needlessly tedious and error-prone. For this reason, shift , resize and similar frequently useful range operationsterm are provided. Rangesterm can be simplified and summarized with several functions, including rangeterm , reduce and disjoin . Figure 2 illustrates the latter two. It is often appropriate to conceive of an IRangesterm object as a mathematical set of integers, or, in the biological context, a set of nucleotide positions. gaps (complementterm), unionterm , intersect and setdiff support this notion. For example, taking the unionterm of two transcripts would yield the rangesterm covered by any KRAS exon. The flank function could be used to demarcate putative promoter regions of transcripts.

Summary of the Rangesterm API.

Illustration of the reduce and disjoin operations on the last exon from each of the KRAS transcripts.

A recurrent operation is overlap detectionterm; various instances are illustrated in Figure 3 . In later sections, we apply overlap counting for finding the percentage of ChIP-seq peaks that overlap a promoter, counting the number of RNA-seq reads for each transcript, and other tasks. The findOverlaps function uses an efficient interval tree algorithm [4] to detect overlaps between two IRangesterm objects, as well as the more complex range-based data structures introduced later. The algorithm supports several types of overlap, including those defined by Allen's Interval Algebra [5] . The one-time cost of constructing the interval tree is , and queries are performed in logarithmic time. In accordance with the vectorized semantics of R, if multiple queries are submitted, they are efficiently processed in batch, without restarting at the root of the tree for each query. The language of implementation is C, which avoids the potentially expensive iteration over the tree in R.

Illustration of overlap (top) and adjacency (bottom) relationships. The any mode detects hits with partial or complete overlap, while within requires that the query rangeterm represents a subregion of the subject rangeterm.

Working with Genomic Rangesterm The IRanges classterm·mth encodes only the startterm·var and endterm·var of rangesterm but not the chromosome, strandterm·var nor other information that is important in genomic applications. The GenomicRangesterm package adds biological semantics on top of IRangesterm . At its core is the GRanges classterm·mth. Each element of a GRangesterm·mth instance includes a chromosome identifier and strandterm·var designation. Each data set is associated with a particular, versioned reference genome sequenceterm consisting of a discrete set of chromosomes or contigs, along with their lengths, if known. The GRanges classterm·mth thus fully represents the data in Figure 1 , and encourages best-practices (e.g., tracking genome build) to minimize book-keeping errors.

The GRanges classterm·mth supports many of the same range operationsterm as IRangesterm and specializes them for genomic data. We achieved API specialization by implementing methodsterm·mth for both classes on the same generic functionsterm·mth. In general, we believe methodterm·mth specialization is an effective practice for providing the same interface on top of different data structures. Abstracting implementation details leads to user code that is more robust and easier to write and maintain.

The GRangesterm·mth methodsterm·mth give special consideration to the chromosome and, when appropriate, the strandterm·var. For instance, the findOverlaps generic has methodsterm·mth for both IRangesterm and GRangesterm·mth , and the GRangesterm·mth methodterm·mth is specifically able to take advantage of the chromosome information when detecting overlaps. Operations that depend on a notion of direction optionally consider strandterm·var. For example, the resize function will resize from the startterm·var or endterm·var of the rangesterm in a IRangesterm object. For a GRangesterm·mth object, resize will take the startterm·var to be the leftmost position for positive strandterm·var features and the rightmost position for negative strandterm·var features.

Some types of genomic data, for example gene models or aligned paired-end reads, have a hierarchical structure. To represent this, multiple GRangesterm·mth objects may be combined into a GRangesListterm·mth , where each GRangesterm·mth is considered a compound featureterm. GRangesListterm·mth groups transcripts by gene, groups exons by transcript, and represents read alignmentsterm, where each alignment consists of multiple segments separated by gaps. For example, we group the KRAS exons by transcript using a GRangesListterm·mth . A note on performance: although the user interface presents each element of a GRangesListterm·mth as a GRangesterm·mth , internally there is only a single GRangesterm·mth , along with an assoicated partitioning that forms the list elements.

For a GRangesListterm·mth , overlap detectionterm reports a hit at the element level, i.e., when any rangeterm within an element overlaps a query rangeterm. See Figure 4 for an illustration. This semantic is convenient, for example, when counting the total number of RNA-seq read pairs overlapping the exonic regions of each transcript. In that case, both the reads and the transcripts are GRangesListterm·mth objects.

Illustration of overlap computations between two GRangesListterm·mth objects. Each set of rectangles linked by solid lines represents a compound rangeterm, i.e., an element of the list. Rangesterm in the query (top) are being matched against rangesterm in the subject (bottom). The labels between them indicate the type of overlap (any, within, none).

Accessing Gene Models Recalling our KRAS gene model example, there are multiple models for representing transcript structuresterm, and the applicability of each depends on the use case. To support the analyst in asking a broad rangeterm of questions, there is a need for a mechanism that draws from a data source of gene annotationsterm and returns them in a variety of different data models. The GenomicFeaturesterm package fills that role by distilling multiple data sources into a single database schema and wrapping that database in an API that returns, for example, the exons grouped by gene, or the bounds for every transcript. The databases are implemented in SQLite and are thus accessible from environments outside of R. For reproducibility, a database may be encapsulated in a redistributable R package.

The database is represented by the TranscriptDbterm·mth class and stores the rangeterm of each exon, the coding rangeterm, the transcript ID, the gene ID, and metadataterm about the source of the transcript information. The GenomicFeaturesterm package provides an automated mechanism for constructing a TranscriptDbterm·mth object from tracks defined in the UCSC genome browser, Biomart, or GTF/GFF files. Bioconductor provides pre-built packages for the most widely adopted gene models, like the UCSC known gene annotationsterm on hg19. These packages follow a standard naming convention, e.g., TxDb.Hsapiens.UCSC.hg19.knownGene .

There are functions for performing common queries that return the exons, coding regions, and transcript boundaries as a GRangesterm·mth object. Transcript and gene-level groupings are preserved by GRangesListterm·mth objects. The rangesterm in Figure 1 were derived from the TxDb.Hsapiens.UCSC.hg19.knownGene package using the following call to the function exons: > library(“TxDb.Hsapiens.UCSC.hg19.knownGene”) > library(“org.Hs.eg.db”) > kras_gene <- org.Hs.egSYMBOL2EG$KRAS > kras_exons <- exons(TxDb.Hsapiens.UCSC.hg19.knownGene, + vals = list(gene_id = kras_gene), + columns = c(“tx_id”, “exon_id”)) To retrieve the exons corresponding to a particular transcript, such as transcript 48666 of KRAS, we call exonsBy , which returns a GRangesListterm·mth of exons grouped by transcript, and extract the element corresponding to the desired transcript identifier: > exonsByTx <- exonsBy(TxDb.Hsapiens.UCSC.hg19.knownGene) > krasA <- exonsByTx[[“48666”]] The contents of krasA are shown in Table 2 .

Contents of the krasA object, representing the exons in isoform A of KRAS.

Associating Annotationsterm with Rangesterm Figure 1 demonstrates how genomic data consist of both rangesterm and uni- or multivariate annotationsterm on those rangesterm. In that table, the annotationsterm are the exon ID and a variable grouping the exons into transcripts. If we had read alignmentsterm from an RNA-seq experiment, we might use countOverlapsterm to generate a read count for each exon. Other examples of annotationterm would include the reference and alternate bases for a single nucleotide variant (SNV) or the position weight matrix (PWM) score for a putative transcription factor binding site.

Every multi-element data structure in the IRangesterm suite supports the storage of per-element metadataterm: data about data. In this case, the metadataterm are the annotationsterm, and the primary dataterm are the rangesterm being annotated. This includes all of the data structures for storing rangesterm, such as IRangesterm, GRangesterm·mth and GRangesListterm·mth . The metadataterm are stored in a DataFrameterm·mth with as many rows as there are elements in the object. We introduce a DataFrameterm·mth class that behaves similarly to the base R data.frame , but supports storage of complex vector-like objects (e.g., a DNAStringSet , representing DNA sequences, or a GRangesterm·mth ) in columns.

Working with Coverageterm and Similar Vectors A common methodterm·mth of summarizing a genomic data set is to calculate the coverageterm, i.e., the number of features in the data set overlapping each position in the genometerm. This is useful in ChIP-seq analysis, where many peak detection methodsterm·mth operate on the coverageterm.

For this example, mouse genomic DNA was cross-linked with DNA-binding proteins, fragmented and precipitated with an antibody for CTCF. An antibody for GFP was used for the control. The CTCF and GFP samples were each sequenced in a single lane on an Illumina sequencer, which generated reads 35 nt in length [6] . We excluded the last 11 nt of each read due to insufficient quality, so the effective read length was 24 nt. The reads were aligned to the mm9 build of the mouse genome using MAQ. We parsed the MAQ output using the ShortRead package [7] , and the alignments for three chromosomes (chr10, chr11 and chr12) were extracted for use as a demonstration data set in the chipseq package [8] .

> library(“chipseq”) > data(“cstest”) > ctcfReads <- cstest$ctcf The ctcfReads objectterm, listed in Table 3 , is a GRangesterm·mth holding the read alignmentsterm from the CTCF sample. The GRangesterm·mth stores the chromosome namesterm·var, rangesterm, and strandterm·var for each alignment, as well as a list of chromosome namesterm·var and lengths for the mm9 genome. Tracking the chromosome information guards against errors that could arise, for example, from mixing data across genome assemblies.

Rangesterm for the first three reads in the ctcfReads objectterm, storing the read alignmentsterm for the CTCF sample.

Each read represents only 24 nt from one endterm·var of a fragment of DNA. Since it was the fragment, but not necessarily the sequenced region, that was cross-linked to CTCF, we need to consider the entire fragment when predicting binding sites. We assume that the fragment length was approximately 120 nt and call resize to extend our read rangesterm to fragment-sized rangesterm: > ctcfFragments <- resize(ctcfReads, 120) Note that the strandterm·var of the alignment was automatically taken into account.

The coverageterm function calculates the coverageterm for a set of rangesterm. We calculate the coverageterm on the CTCF fragments from our ChIP-seq data set as follows: > ctcfCoverage <- coverageterm(ctcfFragments) > ctcfCoverage10 <- ctcfCoverage$chr10 The ctcfCoverage object is a list, with one coverage vectorterm per chromosome. For simplicity, we extract the element corresponding to “chr10”. The ctcfCoverage10 object is of class Rleterm·mth .

Vectors along the genome tend to have many repeated values. For the sake of compactness, we compress the data using a run-length encoding compression scheme. Through the R class system, we abstract this efficient implementation behind an API that supports the features of ordinary R vectors; the complexity is hidden from the user. The Rleterm·mth class represents a run-length encoded vectorterm and provides features beyond those of ordinary vectors. For example, one can use rangesterm to extract values from an Rleterm·mth . This integrates range-based datasets with data in chromosome-length vectors. To demonstrate, we find the position of the maximum coverageterm on chr10, and, in order to display the coverageterm in context, we extract a 5000 nt region centered around that position: > maxPos <- which.max(ctcfCoverage10) > roi <- resize(IRangesterm(maxPos, width = 1), 5000, “center”) > roiCoverage <- ctcfCoverage$chr10[roi] The roiCoverage vector is plotted in Figure 5 and shows how the coverageterm relates to the gene context.

Visualization of the coverageterm of bases by GFP- and CTCF-bound fragments (top) in the context of part of the gene model for Rrp1, Entrez gene 18114 (bottom).

Next, we wish to find peaks in the coverage vectorterm by slicing it at a fixed threshold. We call the slice function and pass it a cutoff of 8: > ctcfPeaks <- slice(ctcfCoverage10, lower = 8) The resulting coverageterm slices are rangesterm and and we rely on our data structures for managing and manipulating them. In particular, the ctcfPeaks object is a Views object, which combines the peak rangesterm with the original Rleterm·mth coverage vectorterm (another example of integrating rangesterm with vectors). Views has several utilities for summarizing the vector values within each rangeterm. We use these to summarize the coverageterm values within each peak: > ctcfMaxs <- viewMaxs(ctcfPeaks) > ctcfSums <- viewSums(ctcfPeaks) Accessing Read Alignmentsterm Read alignmentsterm may be loaded from a BAM fileterm as a GappedAlignmentsterm·mth or GappedAlignmentPairs object, depending on whether the reads should be treated as paired. Both data structures store short read alignmentterm results in terms of the position, chromosome, strandterm·var, CIGAR string (a compact representation of the gaps) and other information. Both also support some of the range operationsterm and can be coerced to GRangesterm·mth and GRangesListterm·mth . The GRangesterm·mth representation holds the ungapped extents of the read alignmentsterm, whereas the GRangesListterm·mth represents the alignments as rangesterm with gaps, including the inter-read gap of a pair and the skipped regions in the reference (e.g., introns). The choice of data structure depends on, for example, whether one wants to count the overlapping pairs, reads, or aligned segments separated by gaps.

A frequent goal of RNA-seq experiments is to estimate the levels of gene expression. For this demonstration, we will simply count the number of read alignmentsterm overlapping the exonic regions of each transcript. We begin by loading a BAM fileterm of read alignmentsterm from an RNA-seq experiment in yeast [9] . There are four samples, two of which are wildtype and two of which are RLP mutants. The leeBamViews package provides the alignments on chromosome XIII from positions 800000 to 900000.

> bams <- getBamsFromLeeBamViews() > ga <- readGappedAlignments(bams [ 1 ] ) > reads <- grglist(ga) The readGappedAlignments function loads the BAM fileterm as a GappedAlignmentsterm·mth object, which is then coerced to a GRangesListterm·mth , where each read consists of one or more rangesterm, separated by intronic gaps.

In the next step, we obtain the transcript annotationsterm for yeast. Bioconductor provides a TranscriptDbterm·mth object for the UCSC sacCer2 assembly, and we extract from it a GRangesListterm·mth representing the transcripts, by calling exonsBy . In order to detect overlaps, the alignments and gene annotationsterm need to have the same chromosome namesterm·var; we correct for that with the calls to keepSeqlevels and renameSeqlevels .

> library(“TxDb.Scerevisiae.UCSC.sacCer2.sgdGene”) > tx <- exonsBy(TxDb.Scerevisiae.UCSC.sacCer2.sgdGene) > tx <- renameSeqlevels(keepSeqlevels(tx, “chrXIII”), + c(chrXIII = “Scchr13”)) Now that the data and annotationsterm have been loaded, we count the number of read alignmentsterm in each genomic feature: > counts <- countOverlapsterm(tx, reads, ignore.strandterm·var = TRUE) More complex counting algorithms are available via the summarizeOverlapsterm function, which counts over multiple samples and returns the results as a SummarizedExperimentterm·mth object. Unlike the call to countOverlapsterm above, reads that map to multiple features are discarded.

Summarized Experiments The typical workflow in a genomic data analysisterm·dom is to reduce a complex raw data set, such as a set of RNA-seq read alignmentsterm, to a set of summaries, such as the number of reads aligned over each transcript or exon. Analogously, an exome-seq experiment yields variant calls at particular genomic rangesterm. It is often appropriate and convenient to store these summaries as a matrix, where the rows correspond to genes or some other genomic feature and the columns to samples. The SummarizedExperimentterm·mth class is designed to hold such values, along with annotationsterm on the genomic regions, the samples and the experiment as a whole. Its design follows the same pattern as the ExpressionSetterm·mth in the Bioconductor microarray infrastructure; the primary difference is that SummarizedExperimentterm·mth is based on IRangesterm data structures. A SummarizedExperimentterm·mth may be constructed directly or generated by a function that executes a high-level workflow. For example, for a list of BAM filesterm, the summarizeOverlapsterm function counts the overlaps between the read alignmentsterm and a database of transcripts.

Results In this section we describe range-based integrative computations related to the genetics of protein-DNA binding, and conclude with a topically organized list of Bioconductor packages that make essential use of the rangesterm infrastructure.

Exploring Genetics of CTCF Binding In the murine ChIP-seq example discussed previously, the rangesterm infrastructure was used to compute and display variation in read coverageterm over the mouse genome. In this example, we use tools based on the rangesterm infrastructure to examine both coverageterm and content of reads from a larger ChIP-seq experiment on human cell lines. Our basic intent is to show how the infrastructure can be used to evaluate the roles of genotype and genetic diversity in the genomic sequences where CTCF is reported to bind, with an understanding that ultimate inferences on protein binding locations and on base-call distributions over heterozygous loci will need to directly incorporate risks of base calling and read mapping errors, and will need to be followed up with wet-lab validation.

For an investigation of the prevalence of allele-specific protein-DNA bindingterm [10] , BAM filesterm on 22 ChIP-seq experiments addressing CTCF binding to DNA from immortalized B-cells were collected from the ENCODE project portal. Exclusion of files with aberrant quality score distributions left 16 BAM filesterm corresponding to 12 distinct individuals; two technical replicates were available for each of four individuals. Furthermore, different base-call qualityterm score scales were used for two batches of samples; by subtracting 31 from the reported mean quality scores for one set of samples, approximately identical medians and interquartile rangesterm were established for mean quality scores for all retained samples. Base calls for reads bound at all genomic locations with positive coverageterm were tabulated using the VariantTools tallyVariants function, and reduced to locations exhibiting statistical evidence of allele-dependent CTCF binding using the callVariants function. Each of these variant assessment tools makes use of infrastructure derived from GSNAP [11] with key results materialized as GRangesterm·mth instances. Table 4 depicts an excerpt from a callVariants output.

Partial output of countVariants applied to a BAM fileterm from an ENCODE CTCF ChIP-seq experiment.

The genome-wide searches for allele-dependent CTCF binding events employed default settings for variant calling by VariantTools callVariants , which include criteria on minimum coverageterm, minimum diversity of read cycles at which base is found, and limitation of risk of strandterm·var bias. This process yielded a total of 19655 locations with evidence of allele-dependent CTCF binding, corresponding to 50750 events over the 12 individuals. We obtained GRangesterm·mth representations of dbSNP build 137 with the scanVcf function of the VariantAnnotation . This facilitated distributed computation for partitioning allele-dependent CTCF binding events into 12691 coincident with known polymorphisms and 6964 at locations where no SNP has been reported in dbSNP.

Allelic imbalanceterm·def in CTCF binding corresponds to departure of the alternate nucleotide proportionterm (ANPterm) at a CTCF binding site from 50%. The upper panels of Figure 6 show the distributions of ANPterm stratified by coincidence of allele-dependent CTCF binding locations with locations of known SNP. The lower panels show identically stratified associations between ANPterm and mean base-call qualities for pileups over the allele-dependent binding locations. While the off-SNP locations show a proponderance of ANPterm below 20%, there is also an indication that base-call qualityterm for such binding events is relatively low, implying that these findings would be unlikely to replicate. For example, among on-SNP allele-dependent binding calls with ANPterm below 20%, 5% had mean quality less than 5; the corresponding frequency for low-quality on-SNP allele-dependent binding locations calls was 41%.

Top panels: distributions of alternate nucleotide proportionsterm for on- and off-SNP allele-dependent CTCF binding events. Bottom panels: relationships between average call quality values and alternate nucleotide proportionsterm are depicted using a 2D density estimate (darker regions correspond to higher density.).

Figure 6 was constructed using the packages and features described above with very little programming effort needed to specialize the computations to this example. Most computational biologists and other interested investigators could easily carry out these steps. We can conclude that allelic imbalanceterm·def in CTCF binding events is frequently detectable but, for the data considered, the apparent imbalances observed are likely a mix of real biology and technical artifactsterm originating from, e.g., sequencing and read mapping errors. Careful analysis of metadataterm collected in the variant-calling process may help to disentangle the key factors contributing to allele-dependent CTCF binding.

Software Based on the Infrastructure There is a growing ecosystem of packagesterm based on this infrastructure. By current count, more than 80 packages depend directly on the packages presented here. This includes packages for input and output of rangesterm ( rtracklayer , Rsamtools ) [12] , [13] , quality assessment ( ShortRead ) [7] , sequence analysis ( Biostrings ) [14] , variant calling ( VariantTools ) [15] , and other tasks. To summarize the different use cases addressed by dependent packages, Table 5 tabulates the descriptive labels chosen from a controlled vocabulary by the package authors.

Selected packages based on the Rangesterm infrastructure.

Availability and Future Directions All of the packages described, including IRangesterm , GenomicRangesterm and GenomicFeaturesterm , form the core infrastructure for sequence analysisterm in Bioconductor and are available from the project website: http://bioconductor.org (see also Software S1 - S3 ). We aim to continue to support scientists in their drive to further science by asking increasingly complex and integrative questions about increasingly complex and heterogeneous data. For example, we are working towards better support for detecting alternative and novel splicing, measuring isoform-specific expression, annotating sequence variants, mapping between genome, transcript and protein coordinate spaces, and integrating transcript annotationsterm with gene-level metadataterm. There is also an unmet need in the visualization of genomic rangesterm. In particular, we need better visualizations for relating RNA-seq coverageterm and junction counts to transcript structuresterm, and for diagnosing read alignmentsterm in the context of variant calling. Finally, as datasets continue to expand in size, we continue to seek more efficient algorithms and data structures, and we are vigilant for opportunities to leverage parallel computingterm.

Supporting Information The IRangesterm package. The IRangesterm package provides efficient low-level and reusable S4 classes for storing and manipulating rangesterm of integers and compressed, genome-length vectors.

(GZ) Click here for additional data file.

The GenomicRangesterm package. The GenomicRangesterm package defines general purpose containers for storing genomic rangesterm as well as more specialized containers for storing alignments against a reference genome.

(GZ) Click here for additional data file.

The GenomicFeaturesterm package. The GenomicFeaturesterm package is a set of tools and methodsterm·mth for making and manipulating transcript-centric annotationsterm.

(GZ) Click here for additional data file.

Funding Statement This work was funded by the National Institutes of Health, National Human Genome Research Group through grants P41 HG004059 and U41 HG004059 and (for VJC) by National Heart, Lung and Blood Institute grants R01 HL086601, R01 HL093076 and R01 HL094635. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.

References Associated Data Supplementary Materials The IRangesterm package. The IRangesterm package provides efficient low-level and reusable S4 classes for storing and manipulating rangesterm of integers and compressed, genome-length vectors.

(GZ) Click here for additional data file.

The GenomicRangesterm package. The GenomicRangesterm package defines general purpose containers for storing genomic rangesterm as well as more specialized containers for storing alignments against a reference genome.

(GZ) Click here for additional data file.

The GenomicFeaturesterm package. The GenomicFeaturesterm package is a set of tools and methodsterm·mth for making and manipulating transcript-centric annotationsterm.

(GZ) Click here for additional data file.

Interpretive notes.
• Highlighted spans are tagged entities: persName (author), title (venue), placeName (place), date (year), and term (a key concept: domain / ai / method).
• Eponymous or retrospective terms (e.g. “Nash equilibrium”, “segregation”) do not appear in the original source and so are not highlighted — a deliberate choice (see Report 4).
• Some entries begin with a word in capitals. EVIDENCE CORRECTED means the finding still stands and it was our quotation that was wrong — it has been replaced. RETRACTED means the entry itself was wrong; it stays on the page, marked, with its reason, rather than being deleted. WITHDRAWN AND REPLACED means a corrected version of it appears in the entries below. Each mark carries its own reason, because the reasons differ from one entry to the next. An entry we have WITHDRAWN is removed from this page and kept in the record, with its reason. A line reading Audit and a date is a later re-reading of the entry against its whole sentence: DOUBTFUL means it was kept, and the reason says what is loose about it.
• Quotation marks inside the tagger's sentence. Where a tag is the tagger's own sentence, a phrase in quotation marks inside it is borrowed from the paper — the tagger's wording around it is not. The paper's own sentence is the evidence quote shown on the same row, so the borrowing can be checked against the thing borrowed from without leaving this page. Nothing inside quotation marks anywhere on this page is ours: if it is quoted, it is the paper's. Whose words a concept carries. A concept entry records a term the paper itself uses, so the term, the sense given for it, and its evidence are the paper's own words, quoted where the paper fixes them. This is the opposite of a sense entry in the tag table, which is the tagger's sentence about how the paper uses a term. Where a concept entry could not be grounded in the paper's words, the entry says so on its own row.
• Counts: 1 work · 1 date.
Meta-Tagging Project · record lawrence2013-genomic-ranges-software.
© 2026 Shir Sivroni