Struct SCIP_Row 

#[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: c_longlong,
    pub validactivitybdsdomchg: c_longlong,
    pub obsoletenode: c_longlong,
    pub activeinlpcounter: c_longlong,
    pub nlpsaftercreation: c_longlong,
    pub storedsolvals: *mut SCIP_ROWSOLVALS,
    pub origin: *mut c_void,
    pub name: *mut c_char,
    pub cols: *mut *mut SCIP_COL,
    pub cols_index: *mut c_int,
    pub vals: *mut f64,
    pub linkpos: *mut c_int,
    pub eventfilter: *mut SCIP_EVENTFILTER,
    pub rowexact: *mut SCIP_ROWEXACT,
    pub validactivitylp: c_longlong,
    pub index: c_int,
    pub size: c_int,
    pub len: c_int,
    pub nlpcols: c_int,
    pub nunlinked: c_int,
    pub nuses: c_int,
    pub lppos: c_int,
    pub lpipos: c_int,
    pub lpdepth: c_int,
    pub minidx: c_int,
    pub maxidx: c_int,
    pub numintcols: c_int,
    pub numimplintcols: c_int,
    pub nummaxval: c_int,
    pub numminval: c_int,
    pub age: c_int,
    pub rank: c_int,
    pub _bitfield_align_1: [u16; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4]>,
}

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

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

< domain change number for which pseudo activity value is valid

validactivitybdsdomchg: c_longlong

< domain change number for which activity bound values are valid

obsoletenode: c_longlong

< last node where this row was removed due to aging

activeinlpcounter: c_longlong

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

nlpsaftercreation: c_longlong

< 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 c_char

< name of the row

cols: *mut *mut SCIP_COL

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

cols_index: *mut c_int

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

vals: *mut f64

< coefficients of row entries

linkpos: *mut c_int

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

< LP number for which activity value is valid

index: c_int

< consecutively numbered row identifier

size: c_int

< size of the col- and val-arrays

len: c_int

< number of nonzeros in row

nlpcols: c_int

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

nunlinked: c_int

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

nuses: c_int

< number of times, this row is referenced

lppos: c_int

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

lpipos: c_int

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

lpdepth: c_int

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

minidx: c_int

< minimal column index of row entries

maxidx: c_int

< maximal column index of row entries

numintcols: c_int

< number of integral columns

numimplintcols: c_int

< number of implied integral columns

nummaxval: c_int

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

numminval: c_int

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

age: c_int

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

rank: c_int

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

_bitfield_align_1: [u16; 0]

_bitfield_1: __BindgenBitfieldUnit<[u8; 4]>

Implementations

impl SCIP_Row

pub fn fromcutpool(&self) -> c_uint

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

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

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

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 lpcolssorted(&self) -> c_uint

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

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

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

pub fn nonlpcolssorted(&self) -> c_uint

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

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

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

pub fn delaysort(&self) -> c_uint

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

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

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

pub fn validminmaxidx(&self) -> c_uint

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

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

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

pub fn lhschanged(&self) -> c_uint

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

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

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

pub fn rhschanged(&self) -> c_uint

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

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

pub unsafe fn set_rhschanged_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 local(&self) -> c_uint

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

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

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

pub fn modifiable(&self) -> c_uint

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

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

pub unsafe fn set_modifiable_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 inglobalcutpool(&self) -> c_uint

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

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

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

pub fn normunreliable(&self) -> c_uint

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

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

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

pub fn nlocks(&self) -> c_uint

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

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

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

pub fn origintype(&self) -> c_uint

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

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

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

pub fn new_bitfield_1( fromcutpool: c_uint, basisstatus: c_uint, lpcolssorted: c_uint, nonlpcolssorted: c_uint, delaysort: c_uint, validminmaxidx: c_uint, lhschanged: c_uint, rhschanged: c_uint, coefchanged: c_uint, integral: c_uint, local: c_uint, modifiable: c_uint, removable: c_uint, inglobalcutpool: c_uint, normunreliable: c_uint, nlocks: c_uint, origintype: c_uint, ) -> __BindgenBitfieldUnit<[u8; 4]>

Trait Implementations

impl Clone for SCIP_Row

fn clone(&self) -> SCIP_Row

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SCIP_Row

impl Debug for SCIP_Row

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

Formats the value using the given formatter.