numopt 0.2.1

Numerical optimization problem abstractions, solver interfaces, and modeling tools.
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

//! Constant expression.

use std::fmt;
use std::rc::Rc;

use super::node::Node;
use super::node_base::NodeBase;

/// Constant scalar.
pub struct ConstantScalar {
    value: f64,
}

impl ConstantScalar {

    /// Creates new scalar constant expression node.
    pub fn new(value: f64) -> Node {
        Node::ConstantScalar(Rc::new(
            Self {
                value: value,
            }
        ))
    }

    /// Gets value of constant.
    pub fn value(&self) -> f64 {
        self.value
    }

    /// Creates new scalar constant with value zero.
    pub fn zero() -> Node {
        ConstantScalar::new(0.)
    }
}

impl NodeBase for ConstantScalar {

    fn partial(&self, _arg: &Node) -> Node { ConstantScalar::new(0.) }
}

impl fmt::Display for ConstantScalar {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.value)
    }
}

#[cfg(test)]
mod tests {

    use crate::model::node_base::NodeBase;
    use crate::model::node_std::NodeStd;
    use crate::model::node_diff::NodeDiff;
    use crate::model::variable::VariableScalar;
    use crate::model::constant::ConstantScalar;

    #[test]
    fn constant_zero() {

        let z = ConstantScalar::zero();
        assert!(z.is_constant_with_value(0.));
    }

    #[test]
    fn constant_partial() {

        let x = VariableScalar::new_continuous("x");
        let c = ConstantScalar::new(3.);

        let z1 = c.partial(&x);
        assert!(z1.is_constant_with_value(0.));

        let z2 = c.partial(&c);
        assert!(z2.is_constant_with_value(0.));
    }

    #[test]
    fn constant_derivative() {

        let x = VariableScalar::new_continuous("x");
        let c = ConstantScalar::new(3.);

        let z1 = c.derivative(&x);
        assert!(z1.is_constant_with_value(0.));
    }

    #[test]
    fn constant_std_properties() {

        let c = ConstantScalar::new(5.);
        let p = c.std_properties();
        assert!(p.affine);
        assert_eq!(p.b, 5.);
        assert!(p.a.is_empty());
    }
}