Enum Stop 

pub enum Stop {
    MaxTrials(u64),
    MinTrials(u64),
    MinErrors {
        metric: String,
        errors: u64,
    },
    Precision {
        metric: String,
        relative: f64,
        confidence: f64,
    },
    MaxTime(Duration),
    Any(Vec<Stop>),
    All(Vec<Stop>),
}

A stopping rule.

Variants

MaxTrials(u64)

At most this many trials: met once they have run (a cap, printed max_trials(n)).

MinTrials(u64)

Never before this many trials (use with Stop::and; met once they have run, as Stop::MaxTrials, but printed min_trials(n)).

MinErrors

At least errors errors of the error rate metric (never met by a mean).

Fields

metric: String

The error-rate metric.

errors: u64

The number of errors.

Precision

Relative half-width of the confidence interval of metric at most relative.

Fields

metric: String

The metric.

relative: f64

The relative half-width.

confidence: f64

The confidence level of the interval.

MaxTime(Duration)

At least this much wall time on the condition.

Any(Vec<Stop>)

Any of the rules.

All(Vec<Stop>)

All of the rules.

Implementations

impl Stop

pub fn max_trials(n: u64) -> Stop

Stop after n trials.

pub fn min_trials(n: u64) -> Stop

Never stop before n trials.

pub fn min_errors(metric: &str, errors: u64) -> Stop

Stop after errors errors of the error rate metric.

pub fn precision(metric: &str, relative: f64) -> Stop

Stop when the 95 % interval of metric is within ±relative of its value.

pub fn precision_at(metric: &str, relative: f64, confidence: f64) -> Stop

Stop when the interval of level confidence of metric is within ±relative of its value (the runner refuses a level outside $(0, 1)$, see check_confidence).

Examples

use comnum_sim::stopping::Stop;
assert_eq!(Stop::precision_at("snr_db", 0.01, 0.99).to_string(), "precision(snr_db) ≤ 0.01 at 0.99");

pub fn max_time(d: Duration) -> Stop

Stop after d of wall time on the condition.

pub fn or(self, other: Stop) -> Stop

Either rule.

pub fn and(self, other: Stop) -> Stop

Both rules.

pub fn is_met(&self, p: &Progress<'_>) -> bool

Whether the rule is met.

pub fn is_bounded(&self) -> bool

Whether the rule can stop at all (a rule made only of lower bounds would run forever).

pub fn trial_limit(&self) -> Option<u64>

The number of trials at which the rule is met whatever the metrics and the time, if there is one: n for Stop::max_trials and Stop::min_trials, the smallest bound of an Stop::or, the largest of an Stop::and whose rules all have one. The runner ends its last batch there.

Examples

use comnum_sim::stopping::Stop;
assert_eq!(Stop::min_errors("ber", 100).or(Stop::max_trials(1000)).trial_limit(), Some(1000));
assert_eq!(Stop::max_trials(1000).and(Stop::min_trials(10)).trial_limit(), Some(1000));
assert_eq!(Stop::min_errors("ber", 100).and(Stop::max_trials(1000)).trial_limit(), None);

pub fn check_confidences(&self) -> Result<()>

Check the confidence levels of the precision targets of the rule (check_confidence).

Errors

Error::Config for a level outside $(0, 1)$.

pub fn check_metrics(&self, record: &Record) -> Result<()>

Check that every target of the rule can be met by the metrics of record (the record of a first batch of trials).

Errors

Error::Config for a target on a metric that record does not hold (the message names the recorded ones), or Stop::min_errors on a mean.

Examples

use comnum_sim::stopping::Stop;
use comnum_sim::scenario::Record;
let mut rec = Record::new();
rec.errors("ber", 3, 1000);
rec.value("snr_db", 9.5);
assert!(Stop::min_errors("ber", 100).or(Stop::max_trials(10)).check_metrics(&rec).is_ok());
let e = Stop::min_errors("bler", 100).or(Stop::max_trials(10)).check_metrics(&rec).unwrap_err();
assert!(e.to_string().contains("bler") && e.to_string().contains("ber, snr_db"));
assert!(Stop::min_errors("snr_db", 100).or(Stop::max_trials(10)).check_metrics(&rec).is_err());

Trait Implementations

impl Clone for Stop

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stop

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

Formats the value using the given formatter.

impl Display for Stop

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

Formats the value using the given formatter.

impl PartialEq for Stop

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Stop