API Reference

Alignment operation.

'M': non-specific match

'I': insertion into reference sequence

'D': deletion from reference sequence

'N': (typically long) deletion from the reference, e.g. due to RNA splicing

'S': sequence removed from the beginning or end of the query sequence but stored

'H': sequence removed from the beginning or end of the query sequence and not stored

'P': not currently supported, but present for SAM/BAM compatibility

'=': match operation with matching sequence positions

'X': match operation with mismatching sequence positions

'B': not currently supported, but present for SAM/BAM compatibility

'0': indicate the start of an alignment within the reference and query sequence

ismatchop(op::Operation)

Test if op is a match operation (i.e. op ∈ (OP_MATCH, OP_SEQ_MATCH, OP_SEQ_MISMATCH)).

isinsertop(op::Operation)

Test if op is a insertion operation (i.e. op ∈ (OP_INSERT, OP_SOFT_CLIP, OP_HARD_CLIP)).

isdeleteop(op::Operation)

Test if op is a deletion operation (i.e. op ∈ (OP_DELETE, OP_SKIP)).

Alignment operation with anchoring positions.

Alignment of two sequences.

Alignment(anchors::Vector{AlignmentAnchor}, check=true)

Create an alignment object from a sequence of alignment anchors.

Alignment(cigar::AbstractString, seqpos=1, refpos=1)

Make an alignment object from a CIGAR string.

seqpos and refpos specify the starting positions of two sequences.

seq2ref(aln::Alignment, i::Integer)::Tuple{Int,Operation}

Map a position i from sequence to reference.

ref2seq(aln::Alignment, i::Integer)::Tuple{Int,Operation}

Map a position i from reference to sequence.

cigar(aln::Alignment)

Make a CIGAR string encoding of aln.

This is not entirely lossless as it discards the alignments start positions.

Supertype of substitution matrix.

The required method:

• Base.getindex(submat, x, y): substitution score/cost from x to y

Substitution matrix.

Dichotomous substitution matrix.

EDNAFULL (or NUC4.4) substitution matrix

PAM30 substitution matrix

PAM70 substitution matrix

PAM250 substitution matrix

BLOSUM45 substitution matrix

BLOSUM50 substitution matrix

BLOSUM62 substitution matrix

BLOSUM80 substitution matrix

BLOSUM90 substitution matrix

Pairwise alignment

count(aln::PairwiseAlignment, target::Operation)

Count the number of positions where the target operation is applied.

count_matches(aln)

Count the number of matching positions.

count_mismatches(aln)

Count the number of mismatching positions.

count_insertions(aln)

Count the number of inserting positions.

count_deletions(aln)

Count the number of deleting positions.

count_aligned(aln)

Count the number of aligned positions.

Global-global alignment with end gap penalties.

Global-local alignment.

Global-global alignment without end gap penalties.

Local-local alignment.

Edit distance.

Hamming distance.

A special case of EditDistance with the costs of insertion and deletion are infinitely large.

Levenshtein distance.

A special case of EditDistance with the costs of mismatch, insertion, and deletion are 1.

Supertype of score model.

AffineGapScoreModel(submat, gap_open, gap_extend)
AffineGapScoreModel(submat, gap_open=, gap_extend=)
AffineGapScoreModel(match=, mismatch=, gap_open=, gap_extend=)

Affine gap scoring model.

This creates an affine gap scroing model object for alignment from a substitution matrix (submat), a gap opening score (gap_open), and a gap extending score (gap_extend). A consecutive gap of length k has a score of gap_open + gap_extend * k. Note that both of the gap scores should be non-positive. As a shorthand of creating a dichotomous substitution matrix, you can write as, for example, AffineGapScoreModel(match=5, mismatch=-3, gap_open=-2, gap_extend=-1).

Example

using BioSequences
using BioAlignments

# create an affine gap scoring model from a predefined substitution
# matrix and gap opening/extending scores.
affinegap = AffineGapScoreModel(BLOSUM62, gap_open=-10, gap_extend=-1)

# run global alignment between two amino acid sequenecs
pairalign(GlobalAlignment(), aa"IDGAAGQQL", aa"IDGATGQL", affinegap)

See also: SubstitutionMatrix, pairalign, CostModel

Supertype of cost model.

CostModel(submat, insertion, deletion)
CostModel(submat, insertion=, deletion=)
CostModel(match=, mismatch=, insertion=, deletion=)

Cost model.

This creates a cost model object for alignment from substitution matrix (submat), an insertion cost (insertion), and a deletion cost (deletion). Note that both of the insertion and deletion costs should be non-negative. As a shorthand of creating a dichotomous substitution matrix, you can write as, for example, CostModel(match=0, mismatch=1, insertion=2, deletion=2).

Example

using BioAlignments

# create a cost model from a substitution matrix and indel costs
cost = CostModel(ones(128, 128) - eye(128), insertion=.5, deletion=.5)

# run global alignment to minimize edit distance
pairalign(EditDistance(), "intension", "execution", cost)

See also: SubstitutionMatrix, pairalign, AffineGapScoreModel

Result of pairwise alignment

pairalign(type, seq, ref, model, [options...])

Run pairwise alignment between two sequences: seq and ref.

Available types are:

• GlobalAlignment()
• LocalAlignment()
• SemiGlobalAlignment()
• OverlapAlignment()
• EditDistance()
• LevenshteinDistance()
• HammingDistance()

GlobalAlignment, LocalAlignment, SemiGlobalAlignment, and OverlapAlignment are problem that maximizes alignment score between two sequences. Therefore, model should be an instance of AbstractScoreModel (e.g. AffineGapScoreModel).

EditDistance, LevenshteinDistance, and HammingDistance are problem that minimizes alignment cost between two sequences. As for EditDistance, model should be an instance of AbstractCostModel (e.g. CostModel). LevenshteinDistance and HammingDistance have predefined a cost model, so users cannot specify a cost model for these alignment types.

When you pass the score_only=true or distance_only=true option to pairalign, the result of pairwise alignment holds alignment score/distance only. This may enable some algorithms to run faster than calculating full alignment result. Other available options are documented for each alignemnt type.

Example

using BioSequences
using BioAlignments

# create affine gap scoring model
affinegap = AffineGapScoreModel(
    match=5,
    mismatch=-4,
    gap_open=-5,
    gap_extend=-3
)

# run global alignment between two DNA sequences
pairalign(GlobalAlignment(), dna"AGGTAG", dna"ATTG", affinegap)

# run local alignment between two DNA sequences
pairalign(LocalAlignment(), dna"AGGTAG", dna"ATTG", affinegap)

# you cannot specify a cost model in LevenshteinDistance
pairalign(LevenshteinDistance(), dna"AGGTAG", dna"ATTG")

See also: AffineGapScoreModel, CostModel

score(alignment_result)

Return score of alignment.

distance(alignment_result)

Retrun distance of alignment.

alignment(alignment_result)

Return alignment if any.

See also: hasalignment

hasalignment(alignment_result)

Check if alignment is stored or not.

seq2ref(aln::PairwiseAlignment, i::Integer)::Tuple{Int,Operation}

Map a position i from the first sequence to the second.

ref2seq(aln::PairwiseAlignment, i::Integer)::Tuple{Int,Operation}

Map a position i from the second sequence to the first.