Struct RuleContext 

pub struct RuleContext {
    pub depth: usize,
    pub upper_bound: f64,
    pub node_lower_bound: f64,
    pub node_upper_bound: f64,
    pub item: usize,
    pub support: usize,
    pub position: usize,
    pub discrepancy: usize,
    pub gain: f64,
    pub error: f64,
    pub leaf_error: f64,
}

What the rules know about the node being evaluated.

Fields

depth: usize

Depth of the node (the root is at 0).

upper_bound: f64

Error the subtree must beat to be of use to its parent.

node_lower_bound: f64

Proven lower bound on the node’s error.

node_upper_bound: f64

Upper bound the node was last solved under (infinite if never).

item: usize

The item (feature and branch) leading to the node.

support: usize

Number of instances in the node.

position: usize

Rank of the node’s feature among its siblings.

discrepancy: usize

Sum of the ranks along the path from the root.

gain: f64

Accumulated heuristic score lost along the path by not taking the best-ranked feature.

error: f64

Best error found so far for the node.

leaf_error: f64

Error of the node as a leaf.

Implementations

impl RuleContext

pub fn depth(&mut self, depth: usize)

pub fn upper_bound(&mut self, upper_bound: f64)

pub fn node_lower_bound(&mut self, node_lower_bound: f64)

pub fn node_upper_bound(&mut self, node_upper_bound: f64)

pub fn item(&mut self, item: usize)

pub fn support(&mut self, support: usize)

pub fn position(&mut self, position: usize)

pub fn gain(&mut self, gain: f64)

pub fn error(&mut self, error: f64)

pub fn leaf_error(&mut self, error: f64)

pub fn discrepancy(&mut self, discrepancy: usize)

Trait Implementations

impl Debug for RuleContext

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

Formats the value using the given formatter.

impl Default for RuleContext

fn default() -> Self

Returns the “default value” for a type.