rapid_solve 0.1.7

This library provides a metaheuristic framework for solving combinatorial optimization problems.
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

//! Contains the [`ObjectiveValue`] struct, which represents the hierarchical objective value of a
//! solution.
use std::{
    cmp::Ordering,
    ops::{Add, Mul, Sub},
    slice::Iter,
};

use super::{base_value::BaseValue, Coefficient};

// TODO: Implement Copy
/// The hierarchical objective value of a solution, which is a vector of
/// [`BaseValues`][`BaseValue`].
#[derive(Clone, Debug)]
pub struct ObjectiveValue {
    objective_vector: Vec<BaseValue>,
}

impl ObjectiveValue {
    /// Creates a new objective value. This is usally done by the [evaluate][super::Objective::evaluate] method of an Objective.
    pub fn new(objective_vector: Vec<BaseValue>) -> ObjectiveValue {
        ObjectiveValue { objective_vector }
    }

    /// Returns the entries of the objective vector.
    pub fn iter(&self) -> Iter<'_, BaseValue> {
        self.objective_vector.iter()
    }

    /// Returns the entries of the objective vector as a vector.
    pub fn as_vec(&self) -> &Vec<BaseValue> {
        &self.objective_vector
    }
}

impl Ord for ObjectiveValue {
    fn cmp(&self, other: &Self) -> Ordering {
        self.objective_vector
            .iter()
            .zip(other.objective_vector.iter())
            .fold(Ordering::Equal, |acc, (value, other_value)| {
                acc.then_with(|| value.partial_cmp(other_value).unwrap())
            })
    }
}

impl PartialOrd for ObjectiveValue {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl PartialEq for ObjectiveValue {
    fn eq(&self, other: &Self) -> bool {
        self.cmp(other).is_eq()
    }
}

impl Eq for ObjectiveValue {}

impl Add for ObjectiveValue {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        ObjectiveValue::new(
            self.objective_vector
                .into_iter()
                .zip(rhs.objective_vector)
                .map(|(value, other_value)| value + other_value)
                .collect(),
        )
    }
}

impl Sub for ObjectiveValue {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        ObjectiveValue::new(
            self.objective_vector
                .into_iter()
                .zip(rhs.objective_vector)
                .map(|(value, other_value)| value - other_value)
                .collect(),
        )
    }
}

impl Mul<f32> for ObjectiveValue {
    type Output = Self;

    fn mul(self, rhs: f32) -> Self::Output {
        let coefficient = Coefficient::Float(rhs);
        ObjectiveValue::new(
            self.objective_vector
                .into_iter()
                .map(|value| coefficient * value)
                .collect(),
        )
    }
}

impl Mul<i32> for ObjectiveValue {
    type Output = Self;

    fn mul(self, rhs: i32) -> Self::Output {
        let coefficient = Coefficient::Integer(rhs);
        ObjectiveValue::new(
            self.objective_vector
                .into_iter()
                .map(|value| coefficient * value)
                .collect(),
        )
    }
}