Struct P3 

pub struct P3 {

    pub verdict: Verdict,
    pub why: String,
    pub checks: usize,
    pub deviations: usize,
    pub cold: bool,
    pub over: usize,
    pub budget: Option<f64>,
    pub pool: f64,
    pub refits: usize,
    pub sources: BTreeMap<String, usize>,
    pub policy: Spend,
    pub fixed: Spend,
    pub first: Vec<String>,
}

Fields

verdict: Verdict

why: String

Why it is not tested: no check, or no decision left the fixed rule, so the gate was never put to the test. Empty otherwise.

checks: usize

deviations: usize

cold: bool

The first check decided as the fixed rule with a budget of 0.

over: usize

Checks whose decision risked more than the gate’s budget there, or whose budget was negative.

budget: Option<f64>

The engineer’s budget for the collective (select.rs budget_of: pool tokens per session), by which the policy prices pool tokens; none by default. With one, the replayed pools must stay within it (pool); spend is reported either way.

pool: f64

The pool tokens the replayed policy’s pools spend per session, as select/policy.rs price measures what a budget bounds: each check at the pool budget pool_tokens chose for it, averaged over the sessions with a check.

refits: usize

The refits the replay made, one wherever a session had ended since the last (cold_start).

sources: BTreeMap<String, usize>

The replayed decisions per source (select/policy.rs Decision::source): how many the evidence rule, the question-count test (its control arm apart) and the gate’s refusals set.

policy: Spend

fixed: Spend

first: Vec<String>

Trait Implementations

impl Clone for P3

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 P3

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

Formats the value using the given formatter.

impl PartialEq for P3

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for P3

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 P3