Struct bio::alignment::pairwise::Aligner

pub struct Aligner<F: MatchFunc> { /* private fields */ }

A generalized Smith-Waterman aligner.

M(i,j) is the best score such that x[i] and y[j] ends in a match (or substitution)

             .... A   G  x_i
             .... C   G  y_j

I(i,j) is the best score such that x[i] is aligned with a gap

             .... A   G  x_i
             .... G  y_j  -

This is interpreted as an insertion into x w.r.t reference y

D(i,j) is the best score such that y[j] is aligned with a gap

             .... A  x_i  -
             .... G   G  y_j

This is interpreted as a deletion from x w.r.t reference y

S(i,j) is the best score for prefixes x[0..i], y[0..j]

To save space, only two columns of these matrices are stored at any point - the current column and the previous one. Moreover M(i,j) is not explicitly stored

Lx is the optimal x suffix clipping lengths from each position of the sequence y

Ly is the optimal y suffix clipping lengths from each position of the sequence x

Sn is the last column of the matrix. This is needed to keep track of suffix clipping scores

traceback - see bio::alignment::pairwise::TracebackCell

scoring - see bio::alignment::pairwise::Scoring

Implementations

impl<F: MatchFunc> Aligner<F>

pub fn new(gap_open: i32, gap_extend: i32, match_fn: F) -> Self

Create new aligner instance with given gap open and gap extend penalties and the score function.

Arguments

• gap_open - the score for opening a gap (should be negative)
• gap_extend - the score for extending a gap (should be negative)
• match_fn - function that returns the score for substitutions (see also bio::alignment::pairwise::Scoring)

pub fn with_capacity(
    m: usize,
    n: usize,
    gap_open: i32,
    gap_extend: i32,
    match_fn: F
) -> Self

Create new aligner instance. The size hints help to avoid unnecessary memory allocations.

Arguments

• m - the expected size of x
• n - the expected size of y
• gap_open - the score for opening a gap (should be negative)
• gap_extend - the score for extending a gap (should be negative)
• match_fn - function that returns the score for substitutions (see also bio::alignment::pairwise::Scoring)

pub fn with_scoring(scoring: Scoring<F>) -> Self

Create new aligner instance with given the scoring struct

Arguments

• scoring - the scoring struct (see bio::alignment::pairwise::Scoring)

pub fn with_capacity_and_scoring(
    m: usize,
    n: usize,
    scoring: Scoring<F>
) -> Self

Create new aligner instance with scoring and size hint. The size hints help to avoid unnecessary memory allocations.

Arguments

• m - the expected size of x
• n - the expected size of y
• scoring - the scoring struct

pub fn custom(&mut self, x: TextSlice<'_>, y: TextSlice<'_>) -> Alignment

The core function to compute the alignment

Arguments

• x - Textslice
• y - Textslice

pub fn global(&mut self, x: TextSlice<'_>, y: TextSlice<'_>) -> Alignment

Calculate global alignment of x against y.

pub fn semiglobal(&mut self, x: TextSlice<'_>, y: TextSlice<'_>) -> Alignment

Calculate semiglobal alignment of x against y (x is global, y is local).

pub fn local(&mut self, x: TextSlice<'_>, y: TextSlice<'_>) -> Alignment

Calculate local alignment of x against y.