Struct SCIP_Lp 

#[repr(C)]
pub struct SCIP_Lp {

    pub lpobjval: f64,
    pub looseobjval: f64,
    pub rellooseobjval: f64,
    pub glbpseudoobjval: f64,
    pub relglbpseudoobjval: f64,
    pub pseudoobjval: f64,
    pub relpseudoobjval: f64,
    pub rootlpobjval: f64,
    pub rootlooseobjval: f64,
    pub cutoffbound: f64,
    pub feastol: f64,
    pub lpiobjlim: f64,
    pub lpifeastol: f64,
    pub lpidualfeastol: f64,
    pub lpibarrierconvtol: f64,
    pub lpiconditionlimit: f64,
    pub lpimarkowitz: f64,
    pub objsqrnorm: f64,
    pub objsumnorm: f64,
    pub degeneracy: f64,
    pub varconsratio: f64,
    pub lpi: *mut SCIP_LPI,
    pub lpicols: *mut *mut SCIP_COL,
    pub lpirows: *mut *mut SCIP_ROW,
    pub chgcols: *mut *mut SCIP_COL,
    pub chgrows: *mut *mut SCIP_ROW,
    pub cols: *mut *mut SCIP_COL,
    pub lazycols: *mut *mut SCIP_COL,
    pub rows: *mut *mut SCIP_ROW,
    pub lpexact: *mut SCIP_LPEXACT,
    pub soldirection: *mut f64,
    pub divelpistate: *mut SCIP_LPISTATE,
    pub divechgsides: *mut f64,
    pub divechgsidetypes: *mut SCIP_SIDETYPE,
    pub divechgrows: *mut *mut SCIP_ROW,
    pub storedsolvals: *mut SCIP_LPSOLVALS,
    pub validsoldirsol: *mut SCIP_SOL,
    pub validsollp: c_longlong,
    pub validfarkaslp: c_longlong,
    pub validsoldirlp: c_longlong,
    pub validdegeneracylp: c_longlong,
    pub divenolddomchgs: c_longlong,
    pub lpicolssize: c_int,
    pub nlpicols: c_int,
    pub lpifirstchgcol: c_int,
    pub lpirowssize: c_int,
    pub nlpirows: c_int,
    pub lpifirstchgrow: c_int,
    pub chgcolssize: c_int,
    pub nchgcols: c_int,
    pub chgrowssize: c_int,
    pub nchgrows: c_int,
    pub colssize: c_int,
    pub soldirectionsize: c_int,
    pub ncols: c_int,
    pub lazycolssize: c_int,
    pub nlazycols: c_int,
    pub nremovablecols: c_int,
    pub firstnewcol: c_int,
    pub rowssize: c_int,
    pub nrows: c_int,
    pub nremovablerows: c_int,
    pub firstnewrow: c_int,
    pub looseobjvalinf: c_int,
    pub nloosevars: c_int,
    pub glbpseudoobjvalinf: c_int,
    pub pseudoobjvalinf: c_int,
    pub ndivingrows: c_int,
    pub ndivechgsides: c_int,
    pub divechgsidessize: c_int,
    pub divinglpiitlim: c_int,
    pub lpiitlim: c_int,
    pub lpifastmip: c_int,
    pub lpithreads: c_int,
    pub lpitiming: c_int,
    pub lpirandomseed: c_int,
    pub lpiscaling: c_int,
    pub lpirefactorinterval: c_int,
    pub lpipricing: SCIP_PRICING,
    pub lpsolstat: SCIP_LPSOLSTAT,
    pub lastlpalgo: SCIP_LPALGO,
    pub objsqrnormunreliable: c_uint,
    pub lpisolutionpolishing: c_uint,
    pub looseobjvalid: c_uint,
    pub glbpseudoobjvalid: c_uint,
    pub pseudoobjvalid: c_uint,
    pub flushdeletedcols: c_uint,
    pub flushaddedcols: c_uint,
    pub flushdeletedrows: c_uint,
    pub flushaddedrows: c_uint,
    pub updateintegrality: c_uint,
    pub flushed: c_uint,
    pub solved: c_uint,
    pub primalfeasible: c_uint,
    pub primalchecked: c_uint,
    pub dualfeasible: c_uint,
    pub dualchecked: c_uint,
    pub solisbasic: c_uint,
    pub rootlpisrelax: c_uint,
    pub isrelax: c_uint,
    pub installing: c_uint,
    pub strongbranching: c_uint,
    pub probing: c_uint,
    pub strongbranchprobing: c_uint,
    pub diving: c_uint,
    pub divingobjchg: c_uint,
    pub divinglazyapplied: c_uint,
    pub resolvelperror: c_uint,
    pub adjustlpval: c_uint,
    pub lpifromscratch: c_uint,
    pub lpipresolving: c_uint,
    pub lpilpinfo: c_uint,
    pub lpihasfeastol: c_uint,
    pub lpihasdualfeastol: c_uint,
    pub lpihasbarrierconvtol: c_uint,
    pub lpihasfastmip: c_uint,
    pub lpihasscaling: c_uint,
    pub lpihaspresolving: c_uint,
    pub lpihasrowrep: c_uint,
    pub lpihaspolishing: c_uint,
    pub lpihasrefactor: c_uint,
    pub lpirowrepswitch: f64,
    pub divelpwasprimfeas: c_uint,
    pub divelpwasprimchecked: c_uint,
    pub divelpwasdualfeas: c_uint,
    pub divelpwasdualchecked: c_uint,
    pub hasprovedbound: c_uint,
}

current LP data

Fields

lpobjval: f64

< objective value of LP without loose variables, or SCIP_INVALID

looseobjval: f64

< current solution value of all loose variables set to their best bounds, ignoring variables, with infinite best bound

rellooseobjval: f64

< last reliable solution value of all loose variables set to their best bounds, ignoring variables, with infinite best bound

glbpseudoobjval: f64

< global pseudo solution value with all variables set to their best global bounds, ignoring variables, with infinite best bound

relglbpseudoobjval: f64

< last reliable global pseudo solution value

pseudoobjval: f64

< current pseudo solution value with all variables set to their best bounds, ignoring variables, with infinite best bound

relpseudoobjval: f64

< last reliable pseudo solution value

rootlpobjval: f64

< objective value of root LP without loose variables, or SCIP_INVALID

rootlooseobjval: f64

< objective value of loose variables in root node, or SCIP_INVALID

cutoffbound: f64

< upper objective limit of LP (copy of primal->cutoffbound)

feastol: f64

< current feasibility tolerance

lpiobjlim: f64

< current objective limit in LPI

lpifeastol: f64

< current feasibility tolerance in LPI

lpidualfeastol: f64

< current reduced costs feasibility tolerance in LPI

lpibarrierconvtol: f64

< current convergence tolerance used in barrier algorithm in LPI

lpiconditionlimit: f64

< current condition number limit in LPI

lpimarkowitz: f64

< current markowitz threshold

objsqrnorm: f64

< squared Euclidean norm of objective function vector of problem variables

objsumnorm: f64

< sum norm of objective function vector of problem variables

degeneracy: f64

< share of degenerate non-basic variables in the current LP

varconsratio: f64

< variable-constraint ratio of the optimal face

lpi: *mut SCIP_LPI

< LP solver interface

lpicols: *mut *mut SCIP_COL

< array with columns currently stored in the LP solver

lpirows: *mut *mut SCIP_ROW

< array with rows currently stored in the LP solver

chgcols: *mut *mut SCIP_COL

< array of changed columns not yet applied to the LP solver

chgrows: *mut *mut SCIP_ROW

< array of changed rows not yet applied to the LP solver

cols: *mut *mut SCIP_COL

< array with current LP columns in correct order

lazycols: *mut *mut SCIP_COL

< array with current LP lazy columns

rows: *mut *mut SCIP_ROW

< array with current LP rows in correct order

lpexact: *mut SCIP_LPEXACT

< pointer to exact rational lp, or null if in normal fp soliving mode

soldirection: *mut f64

< normalized vector in direction of primal solution from current LP solution

divelpistate: *mut SCIP_LPISTATE

< stores LPI state (basis information) before diving starts

divechgsides: *mut f64

< stores the lhs/rhs changed in the current diving

divechgsidetypes: *mut SCIP_SIDETYPE

< stores the side type of the changes done in the current diving

divechgrows: *mut *mut SCIP_ROW

< stores the rows changed in the current diving

storedsolvals: *mut SCIP_LPSOLVALS

< collected values of the LP data which depend on the LP solution

validsoldirsol: *mut SCIP_SOL

< primal solution for which the currently stored solution direction vector is valid

validsollp: c_longlong

< LP number for which the currently stored solution values are valid

validfarkaslp: c_longlong

< LP number for which the currently stored Farkas row multipliers are valid

validsoldirlp: c_longlong

< LP number for which the currently stored solution direction vector is valid

validdegeneracylp: c_longlong

< LP number for which the currently stored degeneracy information is valid

divenolddomchgs: c_longlong

< number of domain changes before diving has started

lpicolssize: c_int

< available slots in lpicols vector

nlpicols: c_int

< number of columns in the LP solver

lpifirstchgcol: c_int

< first column of the LP which differs from the column in the LP solver

lpirowssize: c_int

< available slots in lpirows vector

nlpirows: c_int

< number of rows in the LP solver

lpifirstchgrow: c_int

< first row of the LP which differs from the row in the LP solver

chgcolssize: c_int

< available slots in chgcols vector

nchgcols: c_int

< current number of chgcols (number of used slots in chgcols vector)

chgrowssize: c_int

< available slots in chgrows vector

nchgrows: c_int

< current number of chgrows (number of used slots in chgrows vector)

colssize: c_int

< available slots in cols vector

soldirectionsize: c_int

< available slots in soldirection vector

ncols: c_int

< current number of LP columns (number of used slots in cols vector)

lazycolssize: c_int

< available slots in lazycols vector

nlazycols: c_int

< current number of LP lazy columns (number of used slots in lazycols vector)

nremovablecols: c_int

< number of removable columns in the LP

firstnewcol: c_int

< first column added at the current node

rowssize: c_int

< available slots in rows vector

nrows: c_int

< current number of LP rows (number of used slots in rows vector)

nremovablerows: c_int

< number of removable rows in the LP

firstnewrow: c_int

< first row added at the current node

looseobjvalinf: c_int

< number of loose variables with infinite best bound in current solution

nloosevars: c_int

< number of loose variables in LP

glbpseudoobjvalinf: c_int

< number of variables with infinite best bound in global pseudo solution

pseudoobjvalinf: c_int

< number of variables with infinite best bound in current pseudo solution

ndivingrows: c_int

< number of rows when entering diving mode

ndivechgsides: c_int

< number of side changes in current diving

divechgsidessize: c_int

< size of the arrays

divinglpiitlim: c_int

< LPI iteration limit when entering diving mode

lpiitlim: c_int

< current iteration limit setting in LPI

lpifastmip: c_int

< current FASTMIP setting in LPI

lpithreads: c_int

< current THREADS setting in LPI

lpitiming: c_int

< current timing type in LPI

lpirandomseed: c_int

< current initial random seed in LPI

lpiscaling: c_int

< current SCALING setting in LPI

lpirefactorinterval: c_int

< current refactorization interval

lpipricing: SCIP_PRICING

< current pricing setting in LPI

lpsolstat: SCIP_LPSOLSTAT

< solution status of last LP solution

lastlpalgo: SCIP_LPALGO

< algorithm used for last LP solve

objsqrnormunreliable: c_uint

< is squared Euclidean norm of objective function vector of problem variables unreliable and need recalculation?

lpisolutionpolishing: c_uint

< LP solution polishing method (0: disabled, 1: enabled)

looseobjvalid: c_uint

< is the loose objective value valid or should it be recomputed from scratch?

glbpseudoobjvalid: c_uint

< is the global pseudo solution value valid or should it be recomputed from scratch?

pseudoobjvalid: c_uint

< is the pseudo solution value valid or should it be recomputed from scratch?

flushdeletedcols: c_uint

< have LPI-columns been deleted in the last lpFlush() call?

flushaddedcols: c_uint

< have LPI-columns been added in the last lpFlush() call?

flushdeletedrows: c_uint

< have LPI-rows been deleted in the last lpFlush() call?

flushaddedrows: c_uint

< have LPI-rows been added in the last lpFlush() call?

updateintegrality: c_uint

< does integrality information need to be updated?

flushed: c_uint

< are all cached changes applied to the LP solver?

solved: c_uint

< is current LP solved?

primalfeasible: c_uint

< is current LP solution (rather LPI state) primal feasible?

primalchecked: c_uint

< was current LP solution checked for primal feasibility??

dualfeasible: c_uint

< is current LP solution (rather LPI state) dual feasible?

dualchecked: c_uint

< was current LP solution checked for primal feasibility??

solisbasic: c_uint

< is current LP solution a basic solution?

rootlpisrelax: c_uint

< is root LP a relaxation of the problem and its solution value a valid global lower bound?

isrelax: c_uint

< is the current LP a relaxation of the problem for which it has been solved and its solution value a valid local lower bound?

installing: c_uint

< whether the solution process is in stalling

strongbranching: c_uint

< whether the lp is used for strong branching

probing: c_uint

< are we currently in probing mode?

strongbranchprobing: c_uint

< are we currently in probing mode for strong branching?

diving: c_uint

< LP is used for diving: col bounds and obj don’t correspond to variables

divingobjchg: c_uint

< objective values were changed in diving or probing: LP objective is invalid

divinglazyapplied: c_uint

< lazy bounds were applied to the LP during diving

resolvelperror: c_uint

< an error occurred during resolving the LP after diving or probing

adjustlpval: c_uint

< does an infinite LP objective value has been adjusted so far?

lpifromscratch: c_uint

< current FROMSCRATCH setting in LPI

lpipresolving: c_uint

< current PRESOLVING setting in LPI

lpilpinfo: c_uint

< current LPINFO setting in LPI

lpihasfeastol: c_uint

< does the LPI support the FEASTOL parameter?

lpihasdualfeastol: c_uint

< does the LPI support the DUALFEASTOL parameter?

lpihasbarrierconvtol: c_uint

< does the LPI support the BARRIERCONVTOL parameter?

lpihasfastmip: c_uint

< does the LPI support the FASTMIP parameter?

lpihasscaling: c_uint

< does the LPI support the SCALING parameter?

lpihaspresolving: c_uint

< does the LPI support the PRESOLVING parameter?

lpihasrowrep: c_uint

< does the LPI support row representation of a simplex basis?

lpihaspolishing: c_uint

< does the LPI support solution polishing?

lpihasrefactor: c_uint

< does the LPI support changing the refactorization interval?

lpirowrepswitch: f64

< simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value

divelpwasprimfeas: c_uint

< primal feasibility when diving started

divelpwasprimchecked: c_uint

< primal feasibility was checked when diving started

divelpwasdualfeas: c_uint

< dual feasibility when diving started

divelpwasdualchecked: c_uint

< dual feasibility was checked when diving started

hasprovedbound: c_uint

< is the bound of the lp proved to be exactly dual feasible

Trait Implementations

impl Clone for SCIP_Lp

fn clone(&self) -> SCIP_Lp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SCIP_Lp

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

Formats the value using the given formatter.

impl Copy for SCIP_Lp