Enum ThresholdState 

#[non_exhaustive]
pub enum ThresholdState {
    GtEq(u8),
    InvertGtEqLtEq(OrdPair<u8>),
    Both((u8, OrdPair<u8>)),
}

Types of thresholds on modification level that can be applied to modification data. Two possible use cases: (1) to specify that reading mod data should be restricted to bases at least this level of modified, or (2) to specify that only bases in this range should be regarded as modified. Values are 0 to 255 below as that’s how they are stored in a modBAM file and this struct is expected to be used in contexts dealing directly with this data.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

GtEq(u8)

modification probability >= this value, values are 0 to 255

InvertGtEqLtEq(OrdPair<u8>)

modification probability not within this range. We expect this to be used to filter out modification calls around 0.5 i.e. ones with the most uncertainty, although users of this crate are free to set this to an interval not including 0.5

Both((u8, OrdPair<u8>))

modification probability >= first value, and mod prob not within the second range i.e. the ‘and’ combination of the two possibilities above

Implementations

impl ThresholdState

pub fn from_str_ordpair_fraction(value: &str) -> Result<ThresholdState, Error>

Converts a pair of fractions e.g. “0.4,0.6” into a ThresholdState::InvertGtEqLtEq, and an empty string to the all-permitted ThresholdState::GtEq(0).

Used to set up a filter to reject mod calls whose probabilities lie in a band. This can be used to reject low-quality calls for example which lie around 0.5.

We’ve elected to not write a std::str::FromStr implementation for ThresholdState as the enum is quite complex, generating it from a string is not very user friendly.

Errors

String not empty and not in the format of low,high where low and high are numbers from 0 to 1, both included

Examples

Simple example

use nanalogue_core::ThresholdState;
let a = ThresholdState::from_str_ordpair_fraction("0.4,0.6")?;
assert_eq!(a, ThresholdState::InvertGtEqLtEq((102u8, 153u8).try_into()?));

Empty string should generate no filter

use nanalogue_core::ThresholdState;
let a = ThresholdState::from_str_ordpair_fraction("")?;
assert_eq!(a, ThresholdState::GtEq(0));

Trait Implementations

impl Clone for ThresholdState

fn clone(&self) -> ThresholdState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Contains<u8> for ThresholdState

Check if a given u8 is within the interval covered

Example 1:

use nanalogue_core::{Error, OrdPair, ThresholdState, Contains};
let b = ThresholdState::GtEq(100);
assert!(b.contains(&101));
assert!(b.contains(&100));
assert!(!b.contains(&99));
assert!(!b.contains(&0));

Example 2:

let b = ThresholdState::InvertGtEqLtEq(OrdPair::new(200, 220).expect("no error"));
assert!(b.contains(&0));
assert!(b.contains(&100));
assert!(!b.contains(&200));
assert!(!b.contains(&210));
assert!(!b.contains(&220));
assert!(b.contains(&250));

Example 3:

let b = ThresholdState::Both((100, OrdPair::new(200, 220).expect("no error")));
assert!(!b.contains(&0));
assert!(!b.contains(&99));
assert!(b.contains(&100));
assert!(b.contains(&101));
assert!(!b.contains(&200));
assert!(!b.contains(&210));
assert!(!b.contains(&220));
assert!(b.contains(&250));

fn contains(&self, val: &u8) -> bool

see if value is contained within the interval specified by the threshold state

impl Debug for ThresholdState

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

Formats the value using the given formatter.

impl Default for ThresholdState

default threshold is >= 0 i.e. all mods are allowed

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ThresholdState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ThresholdState

Displays thresholds but using floating point numbers between 0 and 1

Example 1:

use nanalogue_core::{ThresholdState, OrdPair};
let b = ThresholdState::GtEq(100);
assert_eq!("probabilities >= 0.3922", format!("{}", b));

Example 2:

let b = ThresholdState::InvertGtEqLtEq(OrdPair::new(200, 220).expect("no error"));
assert_eq!("probabilities < 0.7843 or > 0.8627", format!("{}", b));

Example 3:

let b = ThresholdState::Both((100, OrdPair::new(200, 220).expect("no error")));
assert_eq!("probabilities >= 0.3922 and (probabilities < 0.7843 or > 0.8627)", format!("{}", b));

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

display the u8 thresholds as a floating point number between 0 and 1

impl From<OrdPair<F32Bw0and1>> for ThresholdState

Converts from OrdPair<F32Bw0and1> to ThresholdState::InvertGtEqLtEq

Example

use nanalogue_core::{F32Bw0and1, OrdPair, ThresholdState};
use std::str::FromStr;
let b: ThresholdState = OrdPair::<F32Bw0and1>::from_str("0.4,0.6")?.into();
assert_eq!(b, ThresholdState::InvertGtEqLtEq(OrdPair::<u8>::new(102u8, 153u8)?));

fn from(value: OrdPair<F32Bw0and1>) -> Self

Converts to this type from the input type.

impl PartialEq for ThresholdState

fn eq(&self, other: &ThresholdState) -> 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 Serialize for ThresholdState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ThresholdState

impl StructuralPartialEq for ThresholdState