cplex-rs 0.1.10

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

use ffi::{
    CPXPARAM_Barrier_Limits_Corrections, CPXPARAM_Barrier_Limits_Growth,
    CPXPARAM_Barrier_Limits_Iteration, CPXPARAM_Barrier_Limits_ObjRange,
};

use crate::errors::{self, Result};
use crate::parameters::{private, Parameter, ParameterValue};

impl private::Parameter for Growth {}
impl private::Parameter for Iteration {}
impl private::Parameter for Corrections {}
impl private::Parameter for ObjRange {}
impl private::Parameter for Ordering {}

/// Barrier growth limit.
/// <https://www.ibm.com/docs/en/icos/22.1.1?topic=parameters-barrier-growth-limit>
#[derive(Copy, Clone, Debug)]
pub struct Growth(f64);

impl Growth {
    pub fn new(value: f64) -> Result<Self> {
        if value < 1.0 {
            return Err(errors::Input::from_message(
                "CPXPARAM_Barrier_Limits_Growth cannot be < 1.0".to_string(),
            )
            .into());
        }
        Ok(Self(value))
    }
}

impl Parameter for Growth {
    fn value(&self) -> ParameterValue {
        ParameterValue::Double(self.0)
    }

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

/// Barrier iteration limit.
/// <https://www.ibm.com/docs/en/icos/22.1.1?topic=parameters-barrier-iteration-limit>
#[derive(Copy, Clone, Debug)]
pub struct Iteration(pub u64);

impl Parameter for Iteration {
    fn value(&self) -> ParameterValue {
        ParameterValue::Long(self.0 as i64)
    }

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

/// Barrier maximum correction limit.
/// <https://www.ibm.com/docs/en/icos/22.1.1?topic=parameters-barrier-maximum-correction-limit>
#[derive(Copy, Clone, Debug)]
pub enum Corrections {
    Automatic,
    Number(u64),
}

impl Parameter for Corrections {
    fn value(&self) -> ParameterValue {
        ParameterValue::Long(match self {
            Self::Automatic => -1,
            &Self::Number(n) => n as i64,
        })
    }

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

/// Barrier objective range.
/// <https://www.ibm.com/docs/en/icos/22.1.1?topic=parameters-barrier-maximum-correction-limit>
#[derive(Copy, Clone, Debug)]
pub struct ObjRange(f64);

impl ObjRange {
    pub fn new(value: f64) -> Result<Self> {
        if value < 0.0 {
            return Err(errors::Input::from_message(
                "CPXPARAM_Barrier_Limits_ObjRange cannot be < 0.0".to_string(),
            )
            .into());
        }
        Ok(Self(value))
    }
}

impl Parameter for ObjRange {
    fn value(&self) -> ParameterValue {
        ParameterValue::Double(self.0)
    }

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

/// Barrier ordering algorithm.
/// <https://www.ibm.com/docs/en/icos/22.1.1?topic=parameters-barrier-ordering-algorithm>
#[derive(Copy, Clone, Debug)]
pub enum Ordering {
    Automatic,
    ApproximateMinimumDegree,
    ApproximateMinimumFill,
    NestedDissection,
}

impl Parameter for Ordering {
    fn value(&self) -> ParameterValue {
        ParameterValue::Integer(match self {
            Self::Automatic => 0,
            Self::ApproximateMinimumDegree => 1,
            Self::ApproximateMinimumFill => 2,
            Self::NestedDissection => 3,
        })
    }

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