milp-types 0.0.1

Mixed integer linear programming types
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

use lp_types::{LinearConstraint, LinearEquation, LinearVariable};
use num::{BigInt, BigUint};
use std::fmt::{Debug, Display, Formatter};
mod convert;
mod display;

pub enum MixedValue {
    Boolean(bool),
    Decimal(f64),
    Integer(BigInt),
}

pub struct MixedConstraint {
    wrapper: LinearConstraint<MixedValue>,
}

pub struct MixedVariable {
    wrapper: LinearVariable<MixedValue>,
}

pub struct MixedEquation {
    wrapper: LinearEquation<MixedValue>,
}

impl MixedVariable {
    pub fn free<S>(symbol: S) -> Self
    where
        S: Into<String>,
    {
        Self { wrapper: LinearVariable::new(symbol) }
    }
    pub fn ge<S, V>(symbol: S, lower: V) -> Self
    where
        S: Into<String>,
        V: Into<MixedValue>,
    {
        Self { wrapper: LinearVariable::ge(symbol, lower.into()) }
    }
    pub fn geq<S, V>(symbol: S, lower: V) -> Self
    where
        S: Into<String>,
        V: Into<MixedValue>,
    {
        Self { wrapper: LinearVariable::geq(symbol, lower.into()) }
    }
    pub fn le<S, V>(symbol: S, upper: V) -> Self
    where
        S: Into<String>,
        V: Into<MixedValue>,
    {
        Self { wrapper: LinearVariable::le(symbol, upper.into()) }
    }
    pub fn leq<S, V>(symbol: S, upper: V) -> Self
    where
        S: Into<String>,
        V: Into<MixedValue>,
    {
        Self { wrapper: LinearVariable::leq(symbol, upper.into()) }
    }
    pub fn bounds<S, V>(symbol: S, bound: MixedConstraint) -> Self
    where
        S: Into<String>,
        V: Into<MixedValue>,
    {
        Self { wrapper: LinearVariable::bounds(symbol, bound.wrapper) }
    }
    pub fn get_symbol(&self) -> &str {
        self.wrapper.get_symbol()
    }
    // pub fn get_kind(&self) -> &MixedVariableKind {
    //     self.wrapper.get_kind()
    // }
    // pub fn get_bound(&self) -> &MixedConstraint {
    //     self.wrapper.get_bound()
    // }
}

impl MixedEquation {
    pub fn variables(&self) -> impl Iterator<Item = &str> {
        self.wrapper.variables()
    }
}