Enum Step 

#[non_exhaustive]
pub enum Step {
    #[non_exhaustive]
    Tableau {
        phase: Phase,
        iteration: usize,
        snapshot: Snapshot,
    },
    #[non_exhaustive]
    Pivot {
        phase: Phase,
        iteration: usize,
        entering: usize,
        entering_name: String,
        leaving_row: usize,
        leaving: usize,
        leaving_name: String,
        pivot_value: Rational,
        ratios: Vec<RatioTest>,
    },
    #[non_exhaustive]
    PhaseOneFinished {
        artificial_sum: Rational,
        feasible: bool,
    },
    #[non_exhaustive]
    ArtificialPivotedOut {
        row: usize,
        entering: usize,
        entering_name: String,
    },
    #[non_exhaustive]
    RedundantRowRemoved {
        row: usize,
    },
    #[non_exhaustive]
    ArtificialRemainsPositive {
        artificials: Vec<NamedValue>,
        unbounded_direction: bool,
    },
    #[non_exhaustive]
    DualPivot {
        phase: Phase,
        iteration: usize,
        leaving_row: usize,
        leaving: usize,
        leaving_name: String,
        entering: usize,
        entering_name: String,
        pivot_value: Rational,
        ratios: Vec<DualRatioTest>,
    },
    #[non_exhaustive]
    InfeasibleRow {
        row: usize,
        basic: NamedValue,
    },
    #[non_exhaustive]
    ConstraintAdded {
        constraint: usize,
        row: usize,
        satisfied: bool,
    },
    #[non_exhaustive]
    Finished {
        termination: Termination,
    },
}

One recorded event.

New kinds of steps (for example from future methods) may be added in minor releases, so matches on Step need a wildcard arm. With the serde feature, a step is a JSON object whose "type" field is the variant name in snake_case ("tableau", "pivot", …).

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.

#[non_exhaustive]

Tableau

The tableau at the start of an iteration (iteration starts at 0).

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

phase: Phase

iteration: usize

snapshot: Snapshot

#[non_exhaustive]

Pivot

A pivot: which column enters, which row leaves, and the ratio test behind the choice.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

phase: Phase

iteration: usize

entering: usize

entering_name: String

leaving_row: usize

leaving: usize

leaving_name: String

pivot_value: Rational

ratios: Vec<RatioTest>

#[non_exhaustive]

PhaseOneFinished

Phase 1 of the two-phase method finished.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

artificial_sum: Rational

feasible: bool

#[non_exhaustive]

ArtificialPivotedOut

A zero-valued artificial variable was swapped out of the basis.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

row: usize

entering: usize

entering_name: String

#[non_exhaustive]

RedundantRowRemoved

A row whose basic variable was artificial and had no usable column: it was redundant.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

row: usize

#[non_exhaustive]

ArtificialRemainsPositive

Big-M: the penalty row (M part) can no longer improve, yet some artificial variables are still positive, so the problem is infeasible. unbounded_direction is true when the run stopped at an unbounded direction rather than at an optimal tableau.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

artificials: Vec<NamedValue>

Each positive artificial variable and its value.

unbounded_direction: bool

#[non_exhaustive]

DualPivot

A dual simplex pivot: which row leaves (it has a negative right-hand side), which column enters, and the ratio test over the columns behind the choice.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

phase: Phase

iteration: usize

leaving_row: usize

leaving: usize

leaving_name: String

entering: usize

entering_name: String

pivot_value: Rational

ratios: Vec<DualRatioTest>

#[non_exhaustive]

InfeasibleRow

Dual simplex: the leaving row has a negative right-hand side but no negative entry, so its equation (non-negative terms adding up to a negative number) cannot hold: the problem is infeasible.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

row: usize

basic: NamedValue

The basic variable of that row and its (negative) value.

#[non_exhaustive]

ConstraintAdded

reoptimize: constraint constraint of the extended problem was appended to the final tableau as row row, expressed in the current basis with its own slack basic. satisfied tells whether the previous optimum already meets it.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

constraint: usize

row: usize

satisfied: bool

#[non_exhaustive]

Finished

Final outcome.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

termination: Termination

Trait Implementations

impl Clone for Step

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 Step

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Step

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Step

impl PartialEq for Step

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Step

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 Step