Struct SCIP_Col 

#[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: c_longlong,
    pub obsoletenode: c_longlong,
    pub storedsolvals: *mut SCIP_COLSOLVALS,
    pub var: *mut SCIP_VAR,
    pub rows: *mut *mut SCIP_ROW,
    pub vals: *mut f64,
    pub validredcostlp: c_longlong,
    pub validfarkaslp: c_longlong,
    pub validsblp: c_longlong,
    pub linkpos: *mut c_int,
    pub index: c_int,
    pub size: c_int,
    pub len: c_int,
    pub nlprows: c_int,
    pub nunlinked: c_int,
    pub lppos: c_int,
    pub lpipos: c_int,
    pub lpdepth: c_int,
    pub sbitlim: c_int,
    pub nsbcalls: c_int,
    pub age: c_int,
    pub var_probindex: c_int,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2]>,
    pub __bindgen_padding_0: [u16; 3],
}

LP column; The row vector of the LP column is partitioned into two parts: The first col->nlprows rows in the rows array are the ones that belong to the current LP (col->rows[j]->lppos >= 0) and that are linked to the column (col->linkpos[j] >= 0). The remaining col->len - col->nlprows rows in the rows array are the ones that don’t belong to the current LP (col->rows[j]->lppos == -1) or that are not linked to the column (col->linkpos[j] == -1).

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

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

obsoletenode: c_longlong

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

< LP number for which reduced cost value is valid

validfarkaslp: c_longlong

< LP number for which Farkas coefficient is valid

validsblp: c_longlong

< LP number for which strong branching values are valid

linkpos: *mut c_int

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

index: c_int

< consecutively numbered column identifier

size: c_int

< size of the row- and val-arrays

len: c_int

< number of nonzeros in column

nlprows: c_int

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

nunlinked: c_int

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

lppos: c_int

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

lpipos: c_int

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

lpdepth: c_int

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

sbitlim: c_int

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

nsbcalls: c_int

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

age: c_int

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

var_probindex: c_int

< copy of var->probindex for avoiding expensive dereferencing

_bitfield_align_1: [u8; 0]

_bitfield_1: __BindgenBitfieldUnit<[u8; 2]>

__bindgen_padding_0: [u16; 3]

Implementations

impl SCIP_Col

pub fn basisstatus(&self) -> c_uint

pub fn set_basisstatus(&mut self, val: c_uint)

pub unsafe fn basisstatus_raw(this: *const Self) -> c_uint

pub unsafe fn set_basisstatus_raw(this: *mut Self, val: c_uint)

pub fn lprowssorted(&self) -> c_uint

pub fn set_lprowssorted(&mut self, val: c_uint)

pub unsafe fn lprowssorted_raw(this: *const Self) -> c_uint

pub unsafe fn set_lprowssorted_raw(this: *mut Self, val: c_uint)

pub fn nonlprowssorted(&self) -> c_uint

pub fn set_nonlprowssorted(&mut self, val: c_uint)

pub unsafe fn nonlprowssorted_raw(this: *const Self) -> c_uint

pub unsafe fn set_nonlprowssorted_raw(this: *mut Self, val: c_uint)

pub fn objchanged(&self) -> c_uint

pub fn set_objchanged(&mut self, val: c_uint)

pub unsafe fn objchanged_raw(this: *const Self) -> c_uint

pub unsafe fn set_objchanged_raw(this: *mut Self, val: c_uint)

pub fn lbchanged(&self) -> c_uint

pub fn set_lbchanged(&mut self, val: c_uint)

pub unsafe fn lbchanged_raw(this: *const Self) -> c_uint

pub unsafe fn set_lbchanged_raw(this: *mut Self, val: c_uint)

pub fn ubchanged(&self) -> c_uint

pub fn set_ubchanged(&mut self, val: c_uint)

pub unsafe fn ubchanged_raw(this: *const Self) -> c_uint

pub unsafe fn set_ubchanged_raw(this: *mut Self, val: c_uint)

pub fn coefchanged(&self) -> c_uint

pub fn set_coefchanged(&mut self, val: c_uint)

pub unsafe fn coefchanged_raw(this: *const Self) -> c_uint

pub unsafe fn set_coefchanged_raw(this: *mut Self, val: c_uint)

pub fn integral(&self) -> c_uint

pub fn set_integral(&mut self, val: c_uint)

pub unsafe fn integral_raw(this: *const Self) -> c_uint

pub unsafe fn set_integral_raw(this: *mut Self, val: c_uint)

pub fn impliedintegral(&self) -> c_uint

pub fn set_impliedintegral(&mut self, val: c_uint)

pub unsafe fn impliedintegral_raw(this: *const Self) -> c_uint

pub unsafe fn set_impliedintegral_raw(this: *mut Self, val: c_uint)

pub fn removable(&self) -> c_uint

pub fn set_removable(&mut self, val: c_uint)

pub unsafe fn removable_raw(this: *const Self) -> c_uint

pub unsafe fn set_removable_raw(this: *mut Self, val: c_uint)

pub fn sbdownvalid(&self) -> c_uint

pub fn set_sbdownvalid(&mut self, val: c_uint)

pub unsafe fn sbdownvalid_raw(this: *const Self) -> c_uint

pub unsafe fn set_sbdownvalid_raw(this: *mut Self, val: c_uint)

pub fn sbupvalid(&self) -> c_uint

pub fn set_sbupvalid(&mut self, val: c_uint)

pub unsafe fn sbupvalid_raw(this: *const Self) -> c_uint

pub unsafe fn set_sbupvalid_raw(this: *mut Self, val: c_uint)

pub fn new_bitfield_1( basisstatus: c_uint, lprowssorted: c_uint, nonlprowssorted: c_uint, objchanged: c_uint, lbchanged: c_uint, ubchanged: c_uint, coefchanged: c_uint, integral: c_uint, impliedintegral: c_uint, removable: c_uint, sbdownvalid: c_uint, sbupvalid: c_uint, ) -> __BindgenBitfieldUnit<[u8; 2]>

Trait Implementations

impl Clone for SCIP_Col

fn clone(&self) -> SCIP_Col

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SCIP_Col

impl Debug for SCIP_Col

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

Formats the value using the given formatter.