Type Alias SCIP_LP 

pub type SCIP_LP = SCIP_Lp;

LP structure

• \ref PublicLPMethods “List of all available methods”

Aliased Type

#[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 u32,
    pub divechgrows: *mut *mut SCIP_Row,
    pub storedsolvals: *mut SCIP_LpSolVals,
    pub validsoldirsol: *mut SCIP_Sol,
    pub validsollp: i64,
    pub validfarkaslp: i64,
    pub validsoldirlp: i64,
    pub validdegeneracylp: i64,
    pub divenolddomchgs: i64,
    pub lpicolssize: i32,
    pub nlpicols: i32,
    pub lpifirstchgcol: i32,
    pub lpirowssize: i32,
    pub nlpirows: i32,
    pub lpifirstchgrow: i32,
    pub chgcolssize: i32,
    pub nchgcols: i32,
    pub chgrowssize: i32,
    pub nchgrows: i32,
    pub colssize: i32,
    pub soldirectionsize: i32,
    pub ncols: i32,
    pub lazycolssize: i32,
    pub nlazycols: i32,
    pub nremovablecols: i32,
    pub firstnewcol: i32,
    pub rowssize: i32,
    pub nrows: i32,
    pub nremovablerows: i32,
    pub firstnewrow: i32,
    pub looseobjvalinf: i32,
    pub nloosevars: i32,
    pub glbpseudoobjvalinf: i32,
    pub pseudoobjvalinf: i32,
    pub ndivingrows: i32,
    pub ndivechgsides: i32,
    pub divechgsidessize: i32,
    pub divinglpiitlim: i32,
    pub lpiitlim: i32,
    pub lpifastmip: i32,
    pub lpithreads: i32,
    pub lpitiming: i32,
    pub lpirandomseed: i32,
    pub lpiscaling: i32,
    pub lpirefactorinterval: i32,
    pub lpipricing: u32,
    pub lpsolstat: u32,
    pub lastlpalgo: u32,
    pub objsqrnormunreliable: u32,
    pub lpisolutionpolishing: u32,
    pub looseobjvalid: u32,
    pub glbpseudoobjvalid: u32,
    pub pseudoobjvalid: u32,
    pub flushdeletedcols: u32,
    pub flushaddedcols: u32,
    pub flushdeletedrows: u32,
    pub flushaddedrows: u32,
    pub updateintegrality: u32,
    pub flushed: u32,
    pub solved: u32,
    pub primalfeasible: u32,
    pub primalchecked: u32,
    pub dualfeasible: u32,
    pub dualchecked: u32,
    pub solisbasic: u32,
    pub rootlpisrelax: u32,
    pub isrelax: u32,
    pub installing: u32,
    pub strongbranching: u32,
    pub probing: u32,
    pub strongbranchprobing: u32,
    pub diving: u32,
    pub divingobjchg: u32,
    pub divinglazyapplied: u32,
    pub resolvelperror: u32,
    pub adjustlpval: u32,
    pub lpifromscratch: u32,
    pub lpipresolving: u32,
    pub lpilpinfo: u32,
    pub lpihasfeastol: u32,
    pub lpihasdualfeastol: u32,
    pub lpihasbarrierconvtol: u32,
    pub lpihasfastmip: u32,
    pub lpihasscaling: u32,
    pub lpihaspresolving: u32,
    pub lpihasrowrep: u32,
    pub lpihaspolishing: u32,
    pub lpihasrefactor: u32,
    pub lpirowrepswitch: f64,
    pub divelpwasprimfeas: u32,
    pub divelpwasprimchecked: u32,
    pub divelpwasdualfeas: u32,
    pub divelpwasdualchecked: u32,
    pub hasprovedbound: u32,
}

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 u32

< 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: i64

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

validfarkaslp: i64

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

validsoldirlp: i64

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

validdegeneracylp: i64

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

divenolddomchgs: i64

< number of domain changes before diving has started

lpicolssize: i32

< available slots in lpicols vector

nlpicols: i32

< number of columns in the LP solver

lpifirstchgcol: i32

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

lpirowssize: i32

< available slots in lpirows vector

nlpirows: i32

< number of rows in the LP solver

lpifirstchgrow: i32

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

chgcolssize: i32

< available slots in chgcols vector

nchgcols: i32

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

chgrowssize: i32

< available slots in chgrows vector

nchgrows: i32

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

colssize: i32

< available slots in cols vector

soldirectionsize: i32

< available slots in soldirection vector

ncols: i32

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

lazycolssize: i32

< available slots in lazycols vector

nlazycols: i32

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

nremovablecols: i32

< number of removable columns in the LP

firstnewcol: i32

< first column added at the current node

rowssize: i32

< available slots in rows vector

nrows: i32

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

nremovablerows: i32

< number of removable rows in the LP

firstnewrow: i32

< first row added at the current node

looseobjvalinf: i32

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

nloosevars: i32

< number of loose variables in LP

glbpseudoobjvalinf: i32

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

pseudoobjvalinf: i32

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

ndivingrows: i32

< number of rows when entering diving mode

ndivechgsides: i32

< number of side changes in current diving

divechgsidessize: i32

< size of the arrays

divinglpiitlim: i32

< LPI iteration limit when entering diving mode

lpiitlim: i32

< current iteration limit setting in LPI

lpifastmip: i32

< current FASTMIP setting in LPI

lpithreads: i32

< current THREADS setting in LPI

lpitiming: i32

< current timing type in LPI

lpirandomseed: i32

< current initial random seed in LPI

lpiscaling: i32

< current SCALING setting in LPI

lpirefactorinterval: i32

< current refactorization interval

lpipricing: u32

< current pricing setting in LPI

lpsolstat: u32

< solution status of last LP solution

lastlpalgo: u32

< algorithm used for last LP solve

objsqrnormunreliable: u32

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

lpisolutionpolishing: u32

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

looseobjvalid: u32

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

glbpseudoobjvalid: u32

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

pseudoobjvalid: u32

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

flushdeletedcols: u32

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

flushaddedcols: u32

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

flushdeletedrows: u32

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

flushaddedrows: u32

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

updateintegrality: u32

< does integrality information need to be updated?

flushed: u32

< are all cached changes applied to the LP solver?

solved: u32

< is current LP solved?

primalfeasible: u32

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

primalchecked: u32

< was current LP solution checked for primal feasibility??

dualfeasible: u32

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

dualchecked: u32

< was current LP solution checked for primal feasibility??

solisbasic: u32

< is current LP solution a basic solution?

rootlpisrelax: u32

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

isrelax: u32

< 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: u32

< whether the solution process is in stalling

strongbranching: u32

< whether the lp is used for strong branching

probing: u32

< are we currently in probing mode?

strongbranchprobing: u32

< are we currently in probing mode for strong branching?

diving: u32

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

divingobjchg: u32

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

divinglazyapplied: u32

< lazy bounds were applied to the LP during diving

resolvelperror: u32

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

adjustlpval: u32

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

lpifromscratch: u32

< current FROMSCRATCH setting in LPI

lpipresolving: u32

< current PRESOLVING setting in LPI

lpilpinfo: u32

< current LPINFO setting in LPI

lpihasfeastol: u32

< does the LPI support the FEASTOL parameter?

lpihasdualfeastol: u32

< does the LPI support the DUALFEASTOL parameter?

lpihasbarrierconvtol: u32

< does the LPI support the BARRIERCONVTOL parameter?

lpihasfastmip: u32

< does the LPI support the FASTMIP parameter?

lpihasscaling: u32

< does the LPI support the SCALING parameter?

lpihaspresolving: u32

< does the LPI support the PRESOLVING parameter?

lpihasrowrep: u32

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

lpihaspolishing: u32

< does the LPI support solution polishing?

lpihasrefactor: u32

< 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: u32

< primal feasibility when diving started

divelpwasprimchecked: u32

< primal feasibility was checked when diving started

divelpwasdualfeas: u32

< dual feasibility when diving started

divelpwasdualchecked: u32

< dual feasibility was checked when diving started

hasprovedbound: u32

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