russcip 0.6.2

Rust interface for SCIP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use crate::builder::CanBeAddedToModel;
use crate::{HeurTiming, Heuristic, Model, ProblemCreated};

/// A builder for easily creating primal heuristics. It can be created using the `heur` function.
pub struct HeurBuilder<H: Heuristic> {
    name: Option<String>,
    desc: Option<String>,
    priority: i32,
    dispchar: Option<char>,
    freq: i32,
    freqofs: i32,
    maxdepth: i32,
    timing: Option<HeurTiming>,
    usessubscip: bool,
    heur: H,
}

impl<H: Heuristic> HeurBuilder<H> {
    /// Creates a new `HeurBuilder` with the given heuristic.
    ///
    /// # Defaults
    /// - `name`: empty string
    /// - `desc`: empty string
    /// - `dispchar`: '?'
    /// - `timing`: `HeurTiming::BEFORE_NODE`
    /// - `priority`: 100000
    /// - `freq`: 1 (called at every node)
    /// - `freqofs`: 0
    /// - `maxdepth`: -1 (unlimited depth)
    /// - `usessubscip`: false
    pub fn new(heur: H) -> Self {
        HeurBuilder {
            name: None,
            desc: None,
            priority: 100000,
            dispchar: None,
            freq: 1,
            freqofs: 0,
            maxdepth: -1,
            timing: None,
            usessubscip: false,
            heur,
        }
    }

    /// Sets the name of the heuristic.
    pub fn name(mut self, name: &str) -> Self {
        self.name = Some(name.to_string());
        self
    }

    /// Sets the description of the heuristic.
    pub fn desc(mut self, desc: &str) -> Self {
        self.desc = Some(desc.to_string());
        self
    }

    /// Sets the priority of the heuristic.
    pub fn priority(mut self, priority: i32) -> Self {
        self.priority = priority;
        self
    }

    /// Sets the display character of the heuristic.
    pub fn dispchar(mut self, dispchar: char) -> Self {
        self.dispchar = Some(dispchar);
        self
    }

    /// Sets the frequency for calling the heuristic.
    pub fn freq(mut self, freq: i32) -> Self {
        self.freq = freq;
        self
    }

    /// Sets the frequency offset for calling the heuristic.
    pub fn freqofs(mut self, freqofs: i32) -> Self {
        self.freqofs = freqofs;
        self
    }

    /// Sets the maximum depth up to which the heuristic is used.
    pub fn maxdepth(mut self, maxdepth: i32) -> Self {
        self.maxdepth = maxdepth;
        self
    }

    /// Sets the timing mask of the heuristic.
    pub fn timing(mut self, timing: HeurTiming) -> Self {
        self.timing = Some(timing);
        self
    }

    /// Sets whether the heuristic should use a secondary SCIP instance.
    pub fn usessubscip(mut self, usessubscip: bool) -> Self {
        self.usessubscip = usessubscip;
        self
    }
}

/// Creates a new default `HeurBuilder` from a heuristic.
/// This function allows you to start chaining:
///
/// ```rust
///
/// use russcip::{HeurResult, HeurTiming, Heuristic, Model, Solving};///
///
/// use russcip::prelude::heur;
///
/// struct MyHeur;
/// impl Heuristic for MyHeur {fn execute(&mut self, model: Model<Solving>, timing: HeurTiming, node_inf: bool) -> HeurResult {
///         todo!()
///     }
/// }
///
/// let my_heur = heur(MyHeur)
///     .name("MyHeuristic")
///     .desc("A custom primal heuristic")
///     .priority(100)
///     .dispchar('H')
///     .freq(1)
///     .freqofs(0)
///     .maxdepth(10)
///     .timing(HeurTiming::BEFORE_NODE | HeurTiming::AFTER_LP_LOOP)
///     .usessubscip(true);
///
/// let mut model = Model::default();
/// model.add(my_heur);
/// ```
pub fn heur<H: Heuristic>(heur: H) -> HeurBuilder<H> {
    HeurBuilder::new(heur)
}

impl<H: Heuristic + 'static> CanBeAddedToModel for HeurBuilder<H> {
    type Return = ();

    fn add(self, model: &mut Model<ProblemCreated>) {
        let name = self.name.unwrap_or_else(|| "".into());
        let desc = self.desc.unwrap_or_else(|| "".into());
        let dispchar = self.dispchar.unwrap_or('?');
        let timing = self.timing.unwrap_or(HeurTiming::BEFORE_NODE);
        let heur_box = Box::new(self.heur);
        model.include_heur(
            &name,
            &desc,
            self.priority,
            dispchar,
            self.freq,
            self.freqofs,
            self.maxdepth,
            timing,
            self.usessubscip,
            heur_box,
        );
    }
}