Struct bio::alignment::pairwise::Scoring

source ·

pub struct Scoring<F: MatchFunc> {
    pub gap_open: i32,
    pub gap_extend: i32,
    pub match_fn: F,
    pub match_scores: Option<(i32, i32)>,
    pub xclip_prefix: i32,
    pub xclip_suffix: i32,
    pub yclip_prefix: i32,
    pub yclip_suffix: i32,
}

Expand description

Details of scoring are encapsulated in this structure.

An affine gap score model is used so that the gap score for a length k is: GapScore(k) = gap_open + gap_extend * k

Fields§

§gap_open: i32§gap_extend: i32§match_fn: F§match_scores: Option<(i32, i32)>§xclip_prefix: i32§xclip_suffix: i32§yclip_prefix: i32§yclip_suffix: i32

Implementations§

source §

impl Scoring<MatchParams>

source

pub fn from_scores( gap_open: i32, gap_extend: i32, match_score: i32, mismatch_score: i32 ) -> Self

Create new Scoring instance with given gap open, gap extend penalties match and mismatch scores. The clip penalties are set to MIN_SCORE by default

Arguments

gap_open - the score for opening a gap (should not be positive)
gap_extend - the score for extending a gap (should not be positive)
match_score - the score for a match
mismatch_score - the score for a mismatch

source §

impl<F: MatchFunc> Scoring<F>

source

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

Create new Scoring instance with given gap open, gap extend penalties and the score function. The clip penalties are set to MIN_SCORE by default

Arguments

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

source

pub fn xclip(self, penalty: i32) -> Self

Sets the prefix and suffix clipping penalties for x to the input value

Arguments

penalty - Clipping penalty for x (both prefix and suffix, should not be positive)

use bio::alignment::pairwise::{Scoring, MIN_SCORE};
let scoring = Scoring::from_scores(0, -2, 1, -2).xclip(-5);
assert!(scoring.xclip_prefix == -5);
assert!(scoring.yclip_prefix == MIN_SCORE);
assert!(scoring.xclip_suffix == -5);
assert!(scoring.yclip_suffix == MIN_SCORE);

source

pub fn xclip_prefix(self, penalty: i32) -> Self

Sets the prefix clipping penalty for x to the input value

Arguments

penalty - Prefix clipping penalty for x (should not be positive)

Example

use bio::alignment::pairwise::{Scoring, MIN_SCORE};
let scoring = Scoring::from_scores(0, -2, 1, -2).xclip_prefix(-5);
assert!(scoring.xclip_prefix == -5);
assert!(scoring.yclip_prefix == MIN_SCORE);
assert!(scoring.xclip_suffix == MIN_SCORE);
assert!(scoring.yclip_suffix == MIN_SCORE);

source

pub fn xclip_suffix(self, penalty: i32) -> Self

Sets the suffix clipping penalty for x to the input value

Arguments

penalty - Suffix clipping penalty for x (should not be positive)

use bio::alignment::pairwise::{Scoring, MIN_SCORE};
let scoring = Scoring::from_scores(0, -2, 1, -2).xclip_suffix(-5);
assert!(scoring.xclip_prefix == MIN_SCORE);
assert!(scoring.yclip_prefix == MIN_SCORE);
assert!(scoring.xclip_suffix == -5);
assert!(scoring.yclip_suffix == MIN_SCORE);

source

pub fn yclip(self, penalty: i32) -> Self

Sets the prefix and suffix clipping penalties for y to the input value

Arguments

penalty - Clipping penalty for y (both prefix and suffix, should not be positive)

use bio::alignment::pairwise::{Scoring, MIN_SCORE};
let scoring = Scoring::from_scores(0, -2, 1, -2).yclip(-5);
assert!(scoring.xclip_prefix == MIN_SCORE);
assert!(scoring.yclip_prefix == -5);
assert!(scoring.xclip_suffix == MIN_SCORE);
assert!(scoring.yclip_suffix == -5);

source

pub fn yclip_prefix(self, penalty: i32) -> Self

Sets the prefix clipping penalty for y to the input value

Arguments

penalty - Prefix clipping penalty for y (should not be positive)

use bio::alignment::pairwise::{Scoring, MIN_SCORE};
let scoring = Scoring::from_scores(0, -2, 1, -2).yclip_prefix(-5);
assert!(scoring.xclip_prefix == MIN_SCORE);
assert!(scoring.yclip_prefix == -5);
assert!(scoring.xclip_suffix == MIN_SCORE);
assert!(scoring.yclip_suffix == MIN_SCORE);

source

pub fn yclip_suffix(self, penalty: i32) -> Self

Sets the suffix clipping penalty for y to the input value

Arguments

penalty - Suffix clipping penalty for y (should not be positive)

use bio::alignment::pairwise::{Scoring, MIN_SCORE};
let scoring = Scoring::from_scores(0, -2, 1, -2).yclip_suffix(-5);
assert!(scoring.xclip_prefix == MIN_SCORE);
assert!(scoring.yclip_prefix == MIN_SCORE);
assert!(scoring.xclip_suffix == MIN_SCORE);
assert!(scoring.yclip_suffix == -5);