API Reference

Both strand ('.')

Unknown strand ('?')

Negative strand ('-')

Positive strand ('+')

GenomicInterval{T} <: AbstractGenomicInterval{T}

A genomic interval specifies interval with some associated metadata. The first three fields (groupname, first, and last) are mandatory arguments when constructing the Interval object.

Fields

• groupname::String: the group name associated with the interval.
• first::Int64: the leftmost position.
• last::Int64: the rightmost position.
• strand::Strand: the strand.
• metadata::T

GenomicInterval{T}(data)

The returned data is converted to GenomicInterval{T} if there is an implemented Base.convert function for the type of data. This method provides a useful hook for converting custom types to GenomicInterval{T}.

GenomicIntervalCollection(data, sort::Bool=false)

Constructor that guesses metadatatype, and offers conversion through collection.

A GenomicIntervalCollection is an efficiently stored and indexed set of annotated genomic intervals.

GenomicIntervalCollection(intervals::AbstractVector{I}, sort::Bool=false) where {I<:Interval}

Shorthand constructor.

GenomicIntervalCollection{I}(data, sort::Bool=false) where {I<:Interval}

Constructor that offers conversion through collection.

GenomicIntervalCollection{T}(data, sort::Bool=true) where {T}

Shorthand for metadata type bulk insertion.

A genomic position is distinguished from an interval and only specifies a position with some associated metadata.

Outer constructors

• Strand(strand::Char)
• Strand(strand::UInt8)

Strand can take four kinds of values listed in the next table:

Strand(strand::Char)

Strand(strand::UInt8)

Return true if interval a overlaps interval b, with no consideration to strand

leftposition(i::AbstractGenomicInterval)

Return the leftmost position of i.

rightposition(i::AbstractGenomicInterval)

Return the rightmost position of i.

coverage(intervals)

Compute the coverage of a collection of intervals and return an GenomicIntervalCollection that contains run-length encoded coverage data.

For example, given intervals like:

[------]     [------------]
   [---------------]

This function would return a new set of disjoint intervals with annotated coverage like:

[1][-2-][-1-][--2--][--1--]

Example

julia> intervals = [
           GenomicInterval("chr1", 1, 8),
           GenomicInterval("chr1", 4, 20),
           GenomicInterval("chr1", 14, 27)];

julia> coverage(intervals)
GenomicIntervalCollection{GenomicInterval{UInt32}} with 5 intervals:
  chr1:1-3  .  1
  chr1:4-8  .  2
  chr1:9-13  .  1
  chr1:14-20  .  2
  chr1:21-27  .  1

eachoverlap(intervals_a, intervals_b, [groupname_isless=Base.isless])

Create an iterator of overlapping intervals between intervals_a and intervals_b.

This function assumes elements of intervals_a and intervals_b are sorted by its group name and left position. If the element type is not a subtype of GenomicFeatures.AbstractGenomicInterval, elements are converted to GenomicInterval objects.

The third optional argument is a function that defines the order of the group names. The default function is Base.isless, which is the lexicographical order.

hasintersection(interval::AbstractGenomicInterval, col::GenomicIntervalCollection)::Bool

Query whether an interval has an intersection with col.

span(interval::AbstractGenomicInterval)::Int

Get the span of interval.

Find a the first interval with matching start and end points.

Returns that interval, or 'nothing' if no interval was found.

position(p::AbstractGenomicPosition)

Return the position of p.

Get the interval type without metadata. This query is useful when converting an interval's metadata or when implementing promotion rules.

Get the interval type. Overwrite to suggest stream element conversions during iteration.

Check if two intervals are well ordered.

AbstractGenomicInterval are considered well ordered if groupname(a) <= groupname(b) and leftposition(a) <= leftposition(b).

Get the interval's metadata type.

Return true if interval a entirely precedes b.

volume(interval::AbstractGenomicInterval)

Get the product of the interval's span and metadata.