Type Alias SCIP_ROW 

pub type SCIP_ROW = SCIP_Row;

row of an LP

• \ref PublicRowMethods “List of all available methods”

Aliased Type

#[repr(C)]
pub struct SCIP_ROW {

    pub constant: f64,
    pub lhs: f64,
    pub rhs: f64,
    pub flushedlhs: f64,
    pub flushedrhs: f64,
    pub sqrnorm: f64,
    pub sumnorm: f64,
    pub objprod: f64,
    pub maxval: f64,
    pub minval: f64,
    pub dualsol: f64,
    pub activity: f64,
    pub dualfarkas: f64,
    pub pseudoactivity: f64,
    pub minactivity: f64,
    pub maxactivity: f64,
    pub validpsactivitydomchg: i64,
    pub validactivitybdsdomchg: i64,
    pub obsoletenode: i64,
    pub activeinlpcounter: i64,
    pub nlpsaftercreation: i64,
    pub storedsolvals: *mut SCIP_RowSolVals,
    pub origin: *mut c_void,
    pub name: *mut u8,
    pub cols: *mut *mut SCIP_Col,
    pub cols_index: *mut i32,
    pub vals: *mut f64,
    pub linkpos: *mut i32,
    pub eventfilter: *mut SCIP_EventFilter,
    pub rowexact: *mut SCIP_RowExact,
    pub validactivitylp: i64,
    pub index: i32,
    pub size: i32,
    pub len: i32,
    pub nlpcols: i32,
    pub nunlinked: i32,
    pub nuses: i32,
    pub lppos: i32,
    pub lpipos: i32,
    pub lpdepth: i32,
    pub minidx: i32,
    pub maxidx: i32,
    pub numintcols: i32,
    pub numimplintcols: i32,
    pub nummaxval: i32,
    pub numminval: i32,
    pub age: i32,
    pub rank: i32,
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4]>,
}

Fields

constant: f64

< constant shift c in row lhs <= ax + c <= rhs

lhs: f64

< left hand side of row

rhs: f64

< right hand side of row

flushedlhs: f64

< left hand side minus constant of row already flushed to the LP solver

flushedrhs: f64

< right hand side minus constant of row already flushed to the LP solver

sqrnorm: f64

< squared Euclidean norm of row vector

sumnorm: f64

< sum norm of row vector (sum of absolute values of coefficients)

objprod: f64

< scalar product of row vector with objective function

maxval: f64

< maximal absolute value of row vector, only valid if nummaxval > 0

minval: f64

< minimal absolute non-zero value of row vector, only valid if numminval > 0

dualsol: f64

< dual solution value in LP, is 0 if row is not in LP

activity: f64

< row activity value in LP, or SCIP_INVALID if not yet calculated

dualfarkas: f64

< multiplier value in dual Farkas infeasibility proof

pseudoactivity: f64

< row activity value in pseudo solution, or SCIP_INVALID if not yet calculated

minactivity: f64

< minimal activity value w.r.t. the column’s bounds, or SCIP_INVALID

maxactivity: f64

< maximal activity value w.r.t. the column’s bounds, or SCIP_INVALID

validpsactivitydomchg: i64

< domain change number for which pseudo activity value is valid

validactivitybdsdomchg: i64

< domain change number for which activity bound values are valid

obsoletenode: i64

< last node where this row was removed due to aging

activeinlpcounter: i64

< counter for the number of times this row was active in an optimal LP solution

nlpsaftercreation: i64

< counter for the number of LPs after the row has been created

storedsolvals: *mut SCIP_RowSolVals

< values stored before entering diving or probing mode

origin: *mut c_void

< pointer to constraint handler or separator who created the row (NULL if unknown)

name: *mut u8

< name of the row

cols: *mut *mut SCIP_Col

< columns of row entries, that may have a nonzero primal solution value

cols_index: *mut i32

< copy of cols[i]->index for avoiding expensive dereferencing

vals: *mut f64

< coefficients of row entries

linkpos: *mut i32

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

eventfilter: *mut SCIP_EventFilter

< event filter for events concerning this row

rowexact: *mut SCIP_RowExact

< pointer to exact row if it exists, or NULL in fp-scip

validactivitylp: i64

< LP number for which activity value is valid

index: i32

< consecutively numbered row identifier

size: i32

< size of the col- and val-arrays

len: i32

< number of nonzeros in row

nlpcols: i32

< number of linked columns in row, that belong to the current LP

nunlinked: i32

< number of row entries, where the columns don’t know about the row

nuses: i32

< number of times, this row is referenced

lppos: i32

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

lpipos: i32

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

lpdepth: i32

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

minidx: i32

< minimal column index of row entries

maxidx: i32

< maximal column index of row entries

numintcols: i32

< number of integral columns

numimplintcols: i32

< number of implied integral columns

nummaxval: i32

< number of coefs with absolute value equal to maxval, zero if maxval invalid

numminval: i32

< number of coefs with absolute value equal to minval, zero if minval invalid

age: i32

< number of successive times this row was in LP and was not sharp in solution

rank: i32

< rank of the row (upper bound, to be precise)

_bitfield_align_1: [u16; 0]

_bitfield_1: __BindgenBitfieldUnit<[u8; 4]>