Type Alias SCIP_TREE 

pub type SCIP_TREE = SCIP_Tree;

branch and bound tree

Aliased Type

#[repr(C)]
pub struct SCIP_TREE {

    pub root: *mut SCIP_Node,
    pub leaves: *mut SCIP_NodePQ,
    pub path: *mut *mut SCIP_Node,
    pub focusnode: *mut SCIP_Node,
    pub focuslpfork: *mut SCIP_Node,
    pub focuslpstatefork: *mut SCIP_Node,
    pub focussubroot: *mut SCIP_Node,
    pub probingroot: *mut SCIP_Node,
    pub children: *mut *mut SCIP_Node,
    pub siblings: *mut *mut SCIP_Node,
    pub childrenprio: *mut f64,
    pub siblingsprio: *mut f64,
    pub divebdchgvars: [*mut *mut SCIP_Var; 2],
    pub divebdchgdirs: [*mut u32; 2],
    pub divebdchgvals: [*mut f64; 2],
    pub pathnlpcols: *mut i32,
    pub pathnlprows: *mut i32,
    pub probinglpistate: *mut SCIP_LPiState,
    pub focuslpistate: *mut SCIP_LPiState,
    pub probinglpinorms: *mut SCIP_LPiNorms,
    pub pendingbdchgs: *mut SCIP_PendingBdchg,
    pub probdiverelaxsol: *mut f64,
    pub probinglpobjval: f64,
    pub nprobdiverelaxsol: i32,
    pub focuslpstateforklpcount: i64,
    pub lastbranchparentid: i64,
    pub divebdchgsize: [i32; 2],
    pub ndivebdchanges: [i32; 2],
    pub pendingbdchgssize: i32,
    pub npendingbdchgs: i32,
    pub childrensize: i32,
    pub nchildren: i32,
    pub siblingssize: i32,
    pub nsiblings: i32,
    pub pathlen: i32,
    pub pathsize: i32,
    pub effectiverootdepth: i32,
    pub updatedeffectiverootdepth: i32,
    pub correctlpdepth: i32,
    pub cutoffdepth: i32,
    pub repropdepth: i32,
    pub repropsubtreecount: i32,
    pub probingsumchgdobjs: i32,
    pub focusnodehaslp: u32,
    pub probingnodehaslp: u32,
    pub focuslpconstructed: u32,
    pub cutoffdelayed: u32,
    pub probinglpwasflushed: u32,
    pub probinglpwassolved: u32,
    pub probingloadlpistate: u32,
    pub probinglpwasrelax: u32,
    pub probingsolvedlp: u32,
    pub forcinglpmessage: u32,
    pub probingobjchanged: u32,
    pub sbprobing: u32,
    pub probinglpwasprimfeas: u32,
    pub probinglpwasprimchecked: u32,
    pub probinglpwasdualfeas: u32,
    pub probinglpwasdualchecked: u32,
    pub probinglphadsafebound: u32,
    pub probdiverelaxstored: u32,
    pub probdiverelaxincludeslp: u32,
}

Fields

root: *mut SCIP_Node

< root node of the tree

leaves: *mut SCIP_NodePQ

< leaves of the tree

path: *mut *mut SCIP_Node

< array of nodes storing the active path from root to current node, which is usually the focus or a probing node; in case of a cut off, the path may already end earlier

focusnode: *mut SCIP_Node

< focus node: the node that is stored together with its children and siblings in the tree data structure; the focus node is the currently processed node; it doesn’t need to be active all the time, because it may be cut off and the active path stops at the cut off node

focuslpfork: *mut SCIP_Node

< LP defining pseudofork/fork/subroot of the focus node

focuslpstatefork: *mut SCIP_Node

< LP state defining fork/subroot of the focus node

focussubroot: *mut SCIP_Node

< subroot of the focus node’s sub tree

probingroot: *mut SCIP_Node

< root node of the current probing path, or NULL

children: *mut *mut SCIP_Node

< array with children of the focus node

siblings: *mut *mut SCIP_Node

< array with siblings of the focus node

childrenprio: *mut f64

< array with node selection priorities of children

siblingsprio: *mut f64

< array with node selection priorities of siblings

divebdchgvars: [*mut *mut SCIP_Var; 2]

< two arrays to store variables for branching

divebdchgdirs: [*mut u32; 2]

< arrays to hold the directions for diving

divebdchgvals: [*mut f64; 2]

< arrays to store bound change values for diving

pathnlpcols: *mut i32

< array with number of LP columns for each problem in active path (except newly added columns of the focus node and the current probing node)

pathnlprows: *mut i32

< array with number of LP rows for each problem in active path (except newly added rows of the focus node and the current probing node)

probinglpistate: *mut SCIP_LPiState

< LP state information before probing started

focuslpistate: *mut SCIP_LPiState

< LP state information of focus node

probinglpinorms: *mut SCIP_LPiNorms

< LP pricing norms information before probing started

pendingbdchgs: *mut SCIP_PendingBdchg

< array of pending bound changes, or NULL

probdiverelaxsol: *mut f64

< array with stored original relaxation solution during diving or probing

probinglpobjval: f64

< lp objective value before probing started

nprobdiverelaxsol: i32

< size of probdiverelaxsol

focuslpstateforklpcount: i64

< LP number of last solved LP in current LP state fork, or -1 if unknown

lastbranchparentid: i64

< last node id/number of branching parent

divebdchgsize: [i32; 2]

< holds the two sizes of the dive bound change information

ndivebdchanges: [i32; 2]

< current number of stored dive bound changes for the next depth

pendingbdchgssize: i32

< size of pendingbdchgs array

npendingbdchgs: i32

< number of pending bound changes

childrensize: i32

< available slots in children vector

nchildren: i32

< number of children of focus node (number of used slots in children vector)

siblingssize: i32

< available slots in siblings vector

nsiblings: i32

< number of siblings of focus node (number of used slots in siblings vector)

pathlen: i32

< length of the current path

pathsize: i32

< number of available slots in path arrays

effectiverootdepth: i32

< the effective root depth which was already enforced

updatedeffectiverootdepth: i32

< first depth of node with at least two children or focus node

correctlpdepth: i32

< depth to which current LP data corresponds to LP data of active path

cutoffdepth: i32

< depth of first node in active path that is marked being cutoff

repropdepth: i32

< depth of first node in active path that has to be propagated again

repropsubtreecount: i32

< cyclicly increased counter to create markers for subtree repropagation

probingsumchgdobjs: i32

< number of changed objective coefficients in all probing nodes

focusnodehaslp: u32

< is LP being processed in the focus node?

probingnodehaslp: u32

< was the LP solved (at least once) in the current probing node?

focuslpconstructed: u32

< was the LP of the focus node already constructed?

cutoffdelayed: u32

< the treeCutoff() call was delayed because of diving and has to be executed

probinglpwasflushed: u32

< was the LP flushed before we entered the probing mode?

probinglpwassolved: u32

< was the LP solved before we entered the probing mode?

probingloadlpistate: u32

< must the LP state be reloaded because of a backtrack in probing?

probinglpwasrelax: u32

< was the LP a valid relaxation before we entered the probing mode?

probingsolvedlp: u32

< was the LP solved during probing mode, i.e., was SCIPsolveProbingLP() called?

forcinglpmessage: u32

< was forcing LP solving message be posted

probingobjchanged: u32

< was the objective function changed during probing?

sbprobing: u32

< is the probing mode used for strong branching?

probinglpwasprimfeas: u32

< primal feasibility when probing started

probinglpwasprimchecked: u32

< primal feasibility has been checked when probing started

probinglpwasdualfeas: u32

< dual feasibility when probing started

probinglpwasdualchecked: u32

< dual feasibility has been check when probing started

probinglphadsafebound: u32

< lp had a proven dual bound when probing started?

probdiverelaxstored: u32

< was a relax solution stored before diving or probing ?

probdiverelaxincludeslp: u32

< did the stored relaxation solution include all lp cuts ?