Struct SCIP_Tree 

#[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 SCIP_BRANCHDIR; 2],
    pub divebdchgvals: [*mut f64; 2],
    pub pathnlpcols: *mut c_int,
    pub pathnlprows: *mut c_int,
    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: c_int,
    pub focuslpstateforklpcount: c_longlong,
    pub lastbranchparentid: c_longlong,
    pub divebdchgsize: [c_int; 2],
    pub ndivebdchanges: [c_int; 2],
    pub pendingbdchgssize: c_int,
    pub npendingbdchgs: c_int,
    pub childrensize: c_int,
    pub nchildren: c_int,
    pub siblingssize: c_int,
    pub nsiblings: c_int,
    pub pathlen: c_int,
    pub pathsize: c_int,
    pub effectiverootdepth: c_int,
    pub updatedeffectiverootdepth: c_int,
    pub correctlpdepth: c_int,
    pub cutoffdepth: c_int,
    pub repropdepth: c_int,
    pub repropsubtreecount: c_int,
    pub probingsumchgdobjs: c_int,
    pub focusnodehaslp: c_uint,
    pub probingnodehaslp: c_uint,
    pub focuslpconstructed: c_uint,
    pub cutoffdelayed: c_uint,
    pub probinglpwasflushed: c_uint,
    pub probinglpwassolved: c_uint,
    pub probingloadlpistate: c_uint,
    pub probinglpwasrelax: c_uint,
    pub probingsolvedlp: c_uint,
    pub forcinglpmessage: c_uint,
    pub probingobjchanged: c_uint,
    pub sbprobing: c_uint,
    pub probinglpwasprimfeas: c_uint,
    pub probinglpwasprimchecked: c_uint,
    pub probinglpwasdualfeas: c_uint,
    pub probinglpwasdualchecked: c_uint,
    pub probinglphadsafebound: c_uint,
    pub probdiverelaxstored: c_uint,
    pub probdiverelaxincludeslp: c_uint,
}

branch and bound tree

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 SCIP_BRANCHDIR; 2]

< arrays to hold the directions for diving

divebdchgvals: [*mut f64; 2]

< arrays to store bound change values for diving

pathnlpcols: *mut c_int

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

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

< size of probdiverelaxsol

focuslpstateforklpcount: c_longlong

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

lastbranchparentid: c_longlong

< last node id/number of branching parent

divebdchgsize: [c_int; 2]

< holds the two sizes of the dive bound change information

ndivebdchanges: [c_int; 2]

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

pendingbdchgssize: c_int

< size of pendingbdchgs array

npendingbdchgs: c_int

< number of pending bound changes

childrensize: c_int

< available slots in children vector

nchildren: c_int

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

siblingssize: c_int

< available slots in siblings vector

nsiblings: c_int

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

pathlen: c_int

< length of the current path

pathsize: c_int

< number of available slots in path arrays

effectiverootdepth: c_int

< the effective root depth which was already enforced

updatedeffectiverootdepth: c_int

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

correctlpdepth: c_int

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

cutoffdepth: c_int

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

repropdepth: c_int

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

repropsubtreecount: c_int

< cyclicly increased counter to create markers for subtree repropagation

probingsumchgdobjs: c_int

< number of changed objective coefficients in all probing nodes

focusnodehaslp: c_uint

< is LP being processed in the focus node?

probingnodehaslp: c_uint

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

focuslpconstructed: c_uint

< was the LP of the focus node already constructed?

cutoffdelayed: c_uint

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

probinglpwasflushed: c_uint

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

probinglpwassolved: c_uint

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

probingloadlpistate: c_uint

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

probinglpwasrelax: c_uint

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

probingsolvedlp: c_uint

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

forcinglpmessage: c_uint

< was forcing LP solving message be posted

probingobjchanged: c_uint

< was the objective function changed during probing?

sbprobing: c_uint

< is the probing mode used for strong branching?

probinglpwasprimfeas: c_uint

< primal feasibility when probing started

probinglpwasprimchecked: c_uint

< primal feasibility has been checked when probing started

probinglpwasdualfeas: c_uint

< dual feasibility when probing started

probinglpwasdualchecked: c_uint

< dual feasibility has been check when probing started

probinglphadsafebound: c_uint

< lp had a proven dual bound when probing started?

probdiverelaxstored: c_uint

< was a relax solution stored before diving or probing ?

probdiverelaxincludeslp: c_uint

< did the stored relaxation solution include all lp cuts ?

Trait Implementations

impl Clone for SCIP_Tree

fn clone(&self) -> SCIP_Tree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SCIP_Tree

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

Formats the value using the given formatter.

impl Copy for SCIP_Tree