Enum BoolParam

pub enum BoolParam {
    Lifting = 0,
    EqTrans = 1,
    TestDualInf = 2,
    RatFac = 3,
    UseDecompDualSimplex = 4,
    ComputeDegen = 5,
    UseCompDual = 6,
    ExplicitViol = 7,
    AcceptCycling = 8,
    RatRec = 9,
    PowerScaling = 10,
    RatFacJump = 11,
    RowBoundFlips = 12,
    PersistentScaling = 13,
    FullPerturbation = 14,
    EnsureRay = 15,
    ForceBasic = 16,
    SimplifierSingletonCols = 17,
    SimplifierConstraintPropagation = 18,
    SimplifierParallelRowDetection = 19,
    SimplifierParallelColDetection = 20,
    SimplifierSingletonStuffing = 21,
    SimplifierDualFix = 22,
    SimplifierFixContinuous = 23,
    SimplifierDominatedCols = 24,
}

Represents the boolean parameters for some LP solver.

Variants

Lifting = 0

Should lifting be used to reduce range of nonzero matrix coefficients?

EqTrans = 1

Should LP be transformed to equality form before a rational solve?

TestDualInf = 2

Should dual infeasibility be tested in order to try to return a dual solution even if primal infeasible?

RatFac = 3

Should a rational factorization be performed after iterative refinement?

UseDecompDualSimplex = 4

Should the decomposition based dual simplex be used to solve the LP? Setting this to true forces the solve mode to SOLVEMODE_REAL and the basis representation to REPRESENTATION_ROW

ComputeDegen = 5

Should the degeneracy be computed for each basis?

UseCompDual = 6

Should the dual of the complementary problem be used in the decomposition simplex?

ExplicitViol = 7

Should row and bound violations be computed explicitly in the update of reduced problem in the decomposition simplex

AcceptCycling = 8

Should cycling solutions be accepted during iterative refinement?

RatRec = 9

Apply rational reconstruction after each iterative refinement?

PowerScaling = 10

Round scaling factors for iterative refinement to powers of two?

RatFacJump = 11

Continue iterative refinement with exact basic solution if not optimal?

RowBoundFlips = 12

Use bound flipping also for row representation?

PersistentScaling = 13

Use persistent scaling?

FullPerturbation = 14

Perturb the entire problem or only the relevant bounds of a single pivot?

EnsureRay = 15

Re-optimize the original problem to get a proof (ray) of infeasibility/unboundedness?

ForceBasic = 16

Try to enforce that the optimal solution is a basic solution

SimplifierSingletonCols = 17

Enable presolver SingletonCols in PaPILO?

SimplifierConstraintPropagation = 18

Enable presolver ConstraintPropagation in PaPILO?

SimplifierParallelRowDetection = 19

Enable presolver ParallelRowDetection in PaPILO?

SimplifierParallelColDetection = 20

Enable presolver ParallelColDetection in PaPILO?

SimplifierSingletonStuffing = 21

Enable presolver SingletonStuffing in PaPILO?

SimplifierDualFix = 22

Enable presolver DualFix in PaPILO?

SimplifierFixContinuous = 23

Enable presolver FixContinuous in PaPILO?

SimplifierDominatedCols = 24

Enable presolver DominatedCols in PaPILO?

Trait Implementations

impl Clone for BoolParam

fn clone(&self) -> BoolParam

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoolParam

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

Formats the value using the given formatter.

impl From<BoolParam> for i32

fn from(param: BoolParam) -> i32

Converts to this type from the input type.

impl PartialEq for BoolParam

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

impl Eq for BoolParam

impl StructuralPartialEq for BoolParam