Type Alias SCIP_COL 

pub type SCIP_COL = SCIP_Col;

column of an LP

• \ref PublicColumnMethods “List of all available methods”

Aliased Type

#[repr(C)]
pub struct SCIP_COL {

    pub obj: f64,
    pub lb: f64,
    pub ub: f64,
    pub unchangedobj: f64,
    pub lazylb: f64,
    pub lazyub: f64,
    pub flushedobj: f64,
    pub flushedlb: f64,
    pub flushedub: f64,
    pub primsol: f64,
    pub redcost: f64,
    pub farkascoef: f64,
    pub minprimsol: f64,
    pub maxprimsol: f64,
    pub sbdown: f64,
    pub sbup: f64,
    pub sbsolval: f64,
    pub sblpobjval: f64,
    pub sbnode: i64,
    pub obsoletenode: i64,
    pub storedsolvals: *mut SCIP_ColSolVals,
    pub var: *mut SCIP_Var,
    pub rows: *mut *mut SCIP_Row,
    pub vals: *mut f64,
    pub validredcostlp: i64,
    pub validfarkaslp: i64,
    pub validsblp: i64,
    pub linkpos: *mut i32,
    pub index: i32,
    pub size: i32,
    pub len: i32,
    pub nlprows: i32,
    pub nunlinked: i32,
    pub lppos: i32,
    pub lpipos: i32,
    pub lpdepth: i32,
    pub sbitlim: i32,
    pub nsbcalls: i32,
    pub age: i32,
    pub var_probindex: i32,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2]>,
    pub __bindgen_padding_0: [u16; 3],
}

Fields

obj: f64

< current objective value of column in LP (might be changed in diving or probing)

lb: f64

< current lower bound of column in LP

ub: f64

< current upper bound of column in LP

unchangedobj: f64

< unchanged objective value of column (ignoring diving or probing changes)

lazylb: f64

< lazy lower bound of the column; if the current lower bound is not greater than the lazy lower bound, then the lower bound has not to be added to the LP

lazyub: f64

< lazy upper bound of the column; if the current upper bound is not smaller than the lazy upper bound, then the upper bound has not to be added to the LP

flushedobj: f64

< objective value of column already flushed to the LP solver

flushedlb: f64

< lower bound of column already flushed to the LP solver

flushedub: f64

< upper bound of column already flushed to the LP solver

primsol: f64

< primal solution value in LP, is 0 if col is not in LP

redcost: f64

< reduced cost value in LP, or SCIP_INVALID if not yet calculated

farkascoef: f64

< coefficient in dual Farkas infeasibility proof (== dualfarkas^T A_c)

minprimsol: f64

< minimal LP solution value, this column ever assumed

maxprimsol: f64

< maximal LP solution value, this column ever assumed

sbdown: f64

< strong branching information for downwards branching

sbup: f64

< strong branching information for upwards branching

sbsolval: f64

< LP solution value of column at last strong branching call

sblpobjval: f64

< LP objective value at last strong branching call on the column

sbnode: i64

< node number of the last strong branching call on this column

obsoletenode: i64

< last node where this column was removed due to aging

storedsolvals: *mut SCIP_ColSolVals

< values stored before entering diving or probing mode

var: *mut SCIP_Var

< variable, this column represents; there cannot be a column without variable

rows: *mut *mut SCIP_Row

< rows of column entries, that may have a nonzero dual solution value

vals: *mut f64

< coefficients of column entries

validredcostlp: i64

< LP number for which reduced cost value is valid

validfarkaslp: i64

< LP number for which Farkas coefficient is valid

validsblp: i64

< LP number for which strong branching values are valid

linkpos: *mut i32

< position of col in col vector of the row, or -1 if not yet linked

index: i32

< consecutively numbered column identifier

size: i32

< size of the row- and val-arrays

len: i32

< number of nonzeros in column

nlprows: i32

< number of linked rows in column, that belong to the current LP

nunlinked: i32

< number of column entries, where the rows don’t know about the column

lppos: i32

< column position number in current LP, or -1 if not in current LP

lpipos: i32

< column position number in LP solver, or -1 if not in LP solver

lpdepth: i32

< depth level at which column entered the LP, or -1 if not in current LP

sbitlim: i32

< strong branching iteration limit used to get strong branching values, or -1

nsbcalls: i32

< number of times, strong branching was applied on the column

age: i32

< number of successive times this variable was in LP and was 0.0 in solution

var_probindex: i32

< copy of var->probindex for avoiding expensive dereferencing

_bitfield_align_1: [u8; 0]

_bitfield_1: __BindgenBitfieldUnit<[u8; 2]>

__bindgen_padding_0: [u16; 3]