solverforge-core 0.8.2

Core types and traits for SolverForge constraint solver
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

use crate::domain::{
    ComputedValueRangeProvider, FieldValueRangeProvider, IntegerRange, StaticValueRange,
    ValueRangeProvider,
};

struct TestSolution {
    n: i32,
    values: Vec<i32>,
}

#[test]
fn test_static_value_range() {
    let range = StaticValueRange::new(vec![1, 2, 3, 4, 5]);
    let solution = TestSolution {
        n: 5,
        values: vec![],
    };

    assert_eq!(range.get_values(&solution), vec![1, 2, 3, 4, 5]);
    assert_eq!(range.value_count(&solution), 5);
    assert!(!range.is_empty(&solution));
}

#[test]
fn test_field_value_range_provider() {
    let provider = FieldValueRangeProvider::new(|s: &TestSolution| &s.values);
    let solution = TestSolution {
        n: 3,
        values: vec![10, 20, 30],
    };

    assert_eq!(provider.get_values(&solution), vec![10, 20, 30]);
    assert_eq!(provider.value_count(&solution), 3);
}

#[test]
fn test_computed_value_range_provider() {
    let provider = ComputedValueRangeProvider::new(|s: &TestSolution| (0..s.n).collect());
    let solution = TestSolution {
        n: 4,
        values: vec![],
    };

    assert_eq!(provider.get_values(&solution), vec![0, 1, 2, 3]);
    assert_eq!(provider.value_count(&solution), 4);
}

#[test]
fn test_computed_value_range_type() {
    use crate::domain::variable::ValueRangeType;
    type TestProvider =
        ComputedValueRangeProvider<TestSolution, i32, fn(&TestSolution) -> Vec<i32>>;
    assert_eq!(
        TestProvider::value_range_type(),
        ValueRangeType::EntityDependent
    );
}

#[test]
fn test_integer_range() {
    let range = IntegerRange::new(5, 10);
    let solution = TestSolution {
        n: 0,
        values: vec![],
    };

    let values: Vec<i64> = ValueRangeProvider::<TestSolution, i64>::get_values(&range, &solution);
    assert_eq!(values, vec![5, 6, 7, 8, 9]);
    assert_eq!(
        ValueRangeProvider::<TestSolution, i64>::value_count(&range, &solution),
        5
    );
}

#[test]
fn test_integer_range_value_range_type() {
    use crate::domain::variable::ValueRangeType;

    let range = IntegerRange::new(5, 10);
    assert_eq!(
        range.value_range_type(),
        ValueRangeType::CountableRange { from: 5, to: 10 }
    );
}

#[test]
fn test_integer_range_i32() {
    let range = IntegerRange::from_zero(3);
    let solution = TestSolution {
        n: 0,
        values: vec![],
    };

    let values: Vec<i32> = ValueRangeProvider::<TestSolution, i32>::get_values(&range, &solution);
    assert_eq!(values, vec![0, 1, 2]);
}