Struct Outcome 

pub struct Outcome {
    pub choices: Vec<String>,
    pub agents: Vec<AgentLimit>,
    pub settling: Settling,
    pub consensus: Option<Vec<f64>>,
    pub factions: Vec<Vec<String>>,
    pub rounds: usize,
    pub budget_reached: bool,
    pub trust: TrustSource,
    pub susceptibility: f64,
    pub spread: f64,
}

The result of running DeGroot over one issue’s ballots.

Fields

choices: Vec<String>

Distinct choices, sorted, indexing every limit vector.

agents: Vec<AgentLimit>

One row per voting agent, sorted by identity.

settling: Settling

Whether the iteration settled, and on what.

consensus: Option<Vec<f64>>

The shared limit when the group agreed, aligned with choices.

factions: Vec<Vec<String>>

Agents grouped by the opinion they settled on, when they did not agree.

rounds: usize

Rounds the iteration took.

budget_reached: bool

Whether the iteration stopped because it ran out of rounds rather than because it settled. The shares are then an estimate, not the limit.

trust: TrustSource

Whether any voting agent had a configured trust row.

susceptibility: f64

The susceptibility an agent gets when nothing names it. One is DeGroot; below one is Friedkin and Johnsen. A named agent carries its own on AgentLimit::susceptibility.

spread: f64

The largest gap left between any two agents on any one choice.

Zero within tolerance when they agreed. Under an anchor it is the disagreement the group keeps, which is the quantity worth reading.

Implementations

impl Outcome

pub fn leader(&self) -> Option<(&str, f64)>

The winning choice and its share, when the group agreed and one choice leads.

None on a split, on an oscillation, and on an exact tie inside a consensus, because reporting the first of two equal options as the group’s position is how a coin toss gets recorded as agreement.

impl Outcome

pub fn settled(&self) -> bool

Whether a gate over this issue should pass.

True only when the group agreed and one choice leads. A plurality, a tie, a split and an oscillation are all cases where acting on the number would be acting on agreement that is not there, which is what the verb exists to make visible.

Trait Implementations

impl Clone for Outcome

fn clone(&self) -> Outcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Outcome

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Outcome

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Outcome

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Outcome

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 Outcome