Struct Comparison 

pub struct Comparison {
    pub case: String,
    pub metric: String,
    pub measured: f64,
    pub reference: f64,
    pub source: String,
    pub tolerance: Tolerance,
    pub difference: f64,
    pub relative: Option<f64>,
    pub verdict: Verdict,
    pub note: Option<String>,
}

One metric of one case: what the oracle said, what hpr said, and whether that is close enough.

Fields

case: String

The case’s id.

metric: String

The metric’s name.

measured: f64

What hpr measured.

reference: f64

What the reference says.

source: String

Where the reference value came from.

tolerance: Tolerance

The tolerance it was held to, if it was held to one.

difference: f64

measured − reference.

relative: Option<f64>

That difference as a fraction of the reference, where the reference is not zero.

verdict: Verdict

Pass, fail, not scored, or within or outside a predicted-mode target.

note: Option<String>

Why it is not scored, for a Verdict::NotScored row.

Implementations

impl Comparison

pub fn new( case: &str, metric: &str, measured: f64, reference: f64, source: &str, tolerance: Tolerance, ) -> Self

Compares measured against reference under tolerance.

pub fn targeted( case: &str, metric: &str, measured: f64, reference: f64, source: &str, tolerance: Tolerance, ) -> Self

Compares measured against reference under tolerance as a target, not a gate: predicted mode’s rows, which are reported and never fail a run for being outside it.

A row with no bound, or a number that is not finite, is not a miss to explain but a broken comparison, so it fails the run, as a blank reason for not scoring does.

pub fn not_scored( case: &str, metric: &str, measured: f64, reference: f64, source: &str, reason: &str, ) -> Self

Records measured against reference without scoring it, for the written reason.

pub fn scored(&self) -> bool

Whether this row counts towards the suite’s verdict.

pub fn targeted_row(&self) -> bool

Whether this is a predicted-mode row, held to a target rather than a gate.

Trait Implementations

impl Clone for Comparison

fn clone(&self) -> Comparison

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Comparison

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Comparison

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Comparison

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Comparison