cplex-rs 0.1.7

Binding of IBM Cplex library
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

pub mod barrier;
pub mod emphasis;
pub mod mip;
pub mod preprocessing;
pub mod read;
pub mod tolerances;

use std::{
    ffi::{c_double, c_int, c_long},
    time::Duration,
};

use ffi::{
    CPXPARAM_Advance, CPXPARAM_Parallel, CPXPARAM_RandomSeed, CPXPARAM_ScreenOutput,
    CPXPARAM_Threads, CPXPARAM_TimeLimit,
};

// TODO: Not all parameters have been implemented yet.
// When implementing a parameter, make sure that the rust namespace matches the CPLEX namespace.
// Next parameter to implement: https://www.ibm.com/docs/en/icos/12.9.0?topic=parameters-benders-strategy

pub(crate) mod private {
    pub trait Parameter {}
}

impl private::Parameter for Advance {}
impl private::Parameter for ParallelMode {}
impl private::Parameter for Threads {}
impl private::Parameter for ScreenOutput {}
impl private::Parameter for RandomSeed {}
impl private::Parameter for TimeLimit {}

/// Parameter trait. It is a sealed trait, as it is supposed to be implemented
/// only within the cples_rs library
pub trait Parameter: private::Parameter {
    fn value(&self) -> ParameterValue;
    fn id(&self) -> u32;
}

#[derive(Copy, Clone, Debug)]
pub enum ParameterValue {
    Integer(c_int),
    Long(c_long),
    Double(c_double),
    String(&'static str),
}

/// Advanced start switch.
/// <https://www.ibm.com/docs/en/icos/22.1.1?topic=parameters-advanced-start-switch>
#[derive(Copy, Clone, Debug)]
pub enum Advance {
    Unused = 0,
    AdvancedBasis = 1,
    AdvancedBasisOrStartingVector = 2,
}

impl Parameter for Advance {
    fn value(&self) -> ParameterValue {
        ParameterValue::Integer(match self {
            Self::Unused => 0,
            Self::AdvancedBasis => 1,
            Self::AdvancedBasisOrStartingVector => 2,
        })
    }

    fn id(&self) -> u32 {
        CPXPARAM_Advance
    }
}

/// Parallel mode switch.
/// <https://www.ibm.com/docs/en/icos/22.1.1?topic=parameters-parallel-mode-switch>
#[derive(Copy, Clone, Debug)]
pub enum ParallelMode {
    Opportunistic,
    Auto,
    Deterministic,
}

impl Parameter for ParallelMode {
    fn value(&self) -> ParameterValue {
        ParameterValue::Integer(match self {
            ParallelMode::Opportunistic => -1,
            ParallelMode::Auto => 0,
            ParallelMode::Deterministic => 1,
        })
    }

    fn id(&self) -> u32 {
        CPXPARAM_Parallel
    }
}

/// Global thread count.
/// <https://www.ibm.com/docs/en/icos/12.9.0?topic=parameters-global-thread-count>
#[derive(Copy, Clone, Debug)]
pub struct Threads(pub u32);

impl Parameter for Threads {
    fn value(&self) -> ParameterValue {
        ParameterValue::Integer(self.0 as i32)
    }

    fn id(&self) -> u32 {
        CPXPARAM_Threads
    }
}

/// Messages to screen switch.
/// <https://www.ibm.com/docs/en/icos/12.9.0?topic=parameters-messages-screen-switch>
#[derive(Copy, Clone, Debug)]
pub struct ScreenOutput(pub bool);

impl Parameter for ScreenOutput {
    fn value(&self) -> ParameterValue {
        ParameterValue::Integer(if self.0 { 1 } else { 0 })
    }

    fn id(&self) -> u32 {
        CPXPARAM_ScreenOutput
    }
}

/// Random seed.
/// <https://www.ibm.com/docs/en/icos/12.9.0?topic=parameters-random-seed>
#[derive(Copy, Clone, Debug)]
pub struct RandomSeed(pub u32);

impl Parameter for RandomSeed {
    fn value(&self) -> ParameterValue {
        ParameterValue::Integer(self.0 as i32)
    }

    fn id(&self) -> u32 {
        CPXPARAM_RandomSeed
    }
}

/// Optimizer time limit in seconds.
/// <https://www.ibm.com/docs/en/icos/12.9.0?topic=parameters-optimizer-time-limit-in-seconds>
#[derive(Copy, Clone, Debug)]
pub struct TimeLimit(pub Duration);

impl Parameter for TimeLimit {
    fn value(&self) -> ParameterValue {
        ParameterValue::Double(self.0.as_secs() as f64)
    }

    fn id(&self) -> u32 {
        CPXPARAM_TimeLimit
    }
}