Struct ProtMotif 

pub struct ProtMotif {
    pub scores: Array2<f32>,
    pub min_score: f32,
    pub max_score: f32,
}

Position-specific scoring matrix for protein sequences

Fields

scores: Array2<f32>

matrix holding weights at each position, indexed by [position, base]

min_score: f32

sum of “worst” base at each position

max_score: f32

sum of “best” base at each position

Implementations

impl ProtMotif

pub fn from_seqs(seqs: &[Vec<u8>], pseudos: Option<&[f32]>) -> Result<Self>

Returns a Motif representing the sequences provided.

Arguments

• seqs - sequences incorporated into motif
• pseudos - array slice with a pseudocount for each monomer; defaults to pssm::DEF_PSEUDO for all if None is supplied

FIXME: pseudos should be an array of size MONO_CT, but that is currently impossible - see https://github.com/rust-lang/rust/issues/42863

Trait Implementations

impl Clone for ProtMotif

fn clone(&self) -> ProtMotif

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProtMotif

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

Formats the value using the given formatter.

impl Default for ProtMotif

fn default() -> ProtMotif

Returns the “default value” for a type.

impl From<ArrayBase<OwnedRepr<f32>, Dim<[usize; 2]>>> for ProtMotif

Return a ProtMotif wrapping an Array2 representing amino acid weights at each position. The dimensions and contents of this array are unchecked, and it is incumbent on the user to ensure the correct dimensions are used (ie, SEQ_LEN x 20), and no zeros appear in the array.

fn from(scores: Array2<f32>) -> Self

Converts to this type from the input type.

impl Motif for ProtMotif

const LK: [u8; 127]

Lookup table mapping monomer -> index

const MONOS: &'static [u8] = b"ARNDCEQGHILKMFPSTWYV"

All monomers, in order corresponding to lookup table

const MONO_CT: usize = 20usize

Monomer count - equal to length of MONOS

fn rev_lk(idx: usize) -> u8

Returns the monomer associated with the given index; the reverse of lookup. Returns INVALID_MONO if the index isn’t associated with a monomer.

fn incr(mono: u8) -> Result<Array1<f32>>

Returns an array of length MONO_CT summing to 1. used to build a PSSM from sequences, potentially including ambiguous monomers (eg, M is either A or C)

fn len(&self) -> usize

Returns the length of motif

fn get_scores(&self) -> &Array2<f32>

Accessor - returns scores matrix

fn get_min_score(&self) -> f32

Return sum of “worst” base at each position

fn get_max_score(&self) -> f32

Return sum of “best” base at each position

fn get_bits() -> f32

Returns information content of a single position. Used info_content method. FIXME: this should be replaced with a CTFE … or maybe just a constant

fn degenerate_consensus(&self) -> Vec<u8>

Returns a representation of the motif using ambiguous codes. Primarily useful for DNA motifs, where ambiguous codes are common (eg, ‘M’ for ‘A or C’); less so for proteins, where we represent any position without a dominant amino acid as an ‘X’

fn seqs_to_weights( seqs: &[Vec<u8>], _pseudos: Option<&[f32]>, ) -> Result<Array2<f32>>

Returns a weight matrix representing the sequences provided. This code is shared by implementations of from_seqs

fn lookup(mono: u8) -> Result<usize>

Returns the index of given monomer in the scores matrix using the lookup table LK

fn is_empty(&self) -> bool

fn raw_score<C, T>(&self, seq_it: T) -> Result<(usize, f32, Vec<f32>)>

where C: Borrow<u8>, T: IntoIterator<Item = C>,

Returns the un-normalized sum of matching bases, useful for comparing matches from motifs of different lengths

fn score<C, T>(&self, seq_it: T) -> Result<ScoredPos>

where C: Borrow<u8>, T: IntoIterator<Item = C>,

Returns a ScoredPos struct representing the best match within the query sequence see: MATCHTM: a tool for searching transcription factor binding sites in DNA sequences Nucleic Acids Res. 2003 Jul 1; 31(13): 3576–3579 https://www.ncbi.nlm.nih.gov/pmc/articles/PMC169193/

fn info_content(&self) -> f32

Returns a float representing the information content of a motif; roughly the inverse of Shannon Entropy. Adapted from the information content described here: https://en.wikipedia.org/wiki/Sequence_logo#Logo_creation

impl PartialEq for ProtMotif

fn eq(&self, other: &ProtMotif) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for ProtMotif