Struct bio::alignment::pairwise::banded::Aligner

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

A banded implementation of Smith-Waterman aligner (SWA). Unlike the full SWA, this implementation computes the alignment between a pair of sequences only inside a ‘band’ withing the dynamic programming matrix. The band is constructed using the Sparse DP routine (see sparse::sdpkpp), which uses kmer matches to build the best common subsequence (including gap penalties) between the two strings. The band is constructed around this subsequence (using the window length ‘w’), filling in the gaps.

In the case where there are no k-mer matches, the aligner will fall back to a full alignment, by setting the band to contain the full matrix.

Banded aligner will proceed to compute the alignment only when the total number of cells in the band is less than MAX_CELLS (currently set to 10 million), otherwise it returns an empty alignment

Implementations

impl<F: MatchFunc> Aligner<F>

pub fn new( gap_open: i32, gap_extend: i32, match_fn: F, k: usize, w: usize ) -> 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 (also see bio::scores)
• k - kmer length used in constructing the band
• w - width of the band

pub fn with_capacity( m: usize, n: usize, gap_open: i32, gap_extend: i32, match_fn: F, k: usize, w: usize ) -> 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 (also see bio::scores)
• k - kmer length used in constructing the band
• w - width of the band

pub fn with_capacity_and_scoring( m: usize, n: usize, scoring: Scoring<F>, k: usize, w: usize ) -> 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
• k - kmer length used in constructing the band
• w - width of the band

pub fn with_scoring(scoring: Scoring<F>, k: usize, w: usize) -> 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
• k - kmer length used in constructing the band
• w - width of the band

pub fn get_mut_scoring(&mut self) -> &mut Scoring<F>

Return a mutable reference to scoring. Useful if you want to have a single aligner object but want to modify the scores within it for different cases

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

Compute the alignment with custom clip penalties

Arguments

• x - Textslice
• y - Textslice

pub fn custom_with_prehash( &mut self, x: TextSlice<'_>, y: TextSlice<'_>, y_kmer_hash: &HashMapFx<&[u8], Vec<u32>> ) -> Alignment

Compute the alignment with custom clip penalties with ‘y’ being pre-hashed (see sparse::hash_kmers)

Arguments

• x - Textslice
• y - Textslice

pub fn custom_with_matches( &mut self, x: TextSlice<'_>, y: TextSlice<'_>, matches: &[(u32, u32)] ) -> Alignment

Compute the alignment with custom clip penalties with the kmer matches between x and y being pre-computed as a Vector of pairs (xpos, ypos) and sorted.

Arguments

• x - Textslice
• y - Textslice
• matches - Vector of kmer matching pairs (xpos, ypos)

pub fn custom_with_expanded_matches( &mut self, x: TextSlice<'_>, y: TextSlice<'_>, matches: Vec<(u32, u32)>, allowed_mismatches: Option<usize>, use_lcskpp_union: bool ) -> Alignment

Compute the alignment with custom clip penalties with the kmer matches between x and y being pre-computed as a Vector of pairs (xpos, ypos) and sorted. The matches are expanded diagonally in both directions allowing upto a user specified number of mismatches. This is useful in constructing the band correctly, particularly when a higher frequency of mismatches are expected.

Arguments

• x - Textslice
• y - Textslice
• matches - Vector of kmer matching pairs (xpos, ypos)
• allowed_mismatches - Extend the matches diagonally allowing upto the specified number of mismatches (Option)
• use_lcskpp_union - Extend the results from sdpkpp using lcskpp

pub fn custom_with_match_path( &mut self, x: TextSlice<'_>, y: TextSlice<'_>, matches: &[(u32, u32)], path: &[usize] ) -> Alignment

Compute the alignment with custom clip penalties by constructing a band along the matches as defined by path. This is only for advanced uses, where one would want to control the kmer backbone that is used for creating the band.

Arguments

• x - Textslice
• y - Textslice
• matches - Vector of kmer matching pairs (xpos, ypos)
• path - Vector of indices pointing to matches vector which defines a path. The validity of the path is not checked.

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 semiglobal_with_prehash( &mut self, x: TextSlice<'_>, y: TextSlice<'_>, y_kmer_hash: &HashMapFx<&[u8], Vec<u32>> ) -> Alignment

Calculate semiglobal alignment of x against y (x is global, y is local). This function accepts the hash map of the kmers of y. This is useful in cases where we are interested in repeated alignment of different queries against the same reference. The user can precompute the HashMap using sparse::hash_kmers and invoke this function to speed up the alignment computation.

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

Calculate local alignment of x against y.

pub fn visualize(&self, alignment: &Alignment)

Trait Implementations

impl<F: Clone + MatchFunc> Clone for Aligner<F>

fn clone(&self) -> Aligner<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug + MatchFunc> Debug for Aligner<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Default + MatchFunc> Default for Aligner<F>

fn default() -> Aligner<F>

Returns the “default value” for a type.

impl<'de, F> Deserialize<'de> for Aligner<F>where F: Deserialize<'de> + MatchFunc,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: Hash + MatchFunc> Hash for Aligner<F>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: PartialEq + MatchFunc> PartialEq<Aligner<F>> for Aligner<F>

fn eq(&self, other: &Aligner<F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> Serialize for Aligner<F>where F: Serialize + MatchFunc,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Eq + MatchFunc> Eq for Aligner<F>

impl<F: MatchFunc> StructuralEq for Aligner<F>

impl<F: MatchFunc> StructuralPartialEq for Aligner<F>