selen 0.15.5

Constraint Satisfaction Problem (CSP) 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
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use selen::prelude::*;

fn main() {
    println!("Testing Element constraint...");
    
    // Test case 1: Simple element constraint with function syntax
    println!("\n=== Test 1: Basic element constraint ===");
    let mut model = Model::default();
    
    // Create an array of variables: [10, 20, 30, 40, 50]
    let a0 = model.int(10, 10);  // Fixed value 10
    let a1 = model.int(20, 20);  // Fixed value 20
    let a2 = model.int(30, 30);  // Fixed value 30
    let a3 = model.int(40, 40);  // Fixed value 40
    let a4 = model.int(50, 50);  // Fixed value 50
    
    // Index and value variables
    let index = model.int(0, 4);    // Index from 0 to 4
    let value = model.int(10, 50);  // Value should match array[index]
    
    // Element constraint: array[index] = value
    model.props.element(vec![a0, a1, a2, a3, a4], index, value);
    
    match model.solve() {
        Ok(solution) => {
            let index_val = solution[index];
            let value_val = solution[value];
            println!("Solution found:");
            println!("  index = {:?}", index_val);
            println!("  value = {:?}", value_val);
            
            // Verify the constraint
            let expected_values = [10, 20, 30, 40, 50];
            if let Val::ValI(idx) = index_val {
                if let Val::ValI(val) = value_val {
                    let expected = expected_values[idx as usize];
                    if val == expected {
                        println!("✓ Element constraint satisfied: array[{}] = {}", idx, val);
                    } else {
                        println!("✗ Element constraint failed: expected {}, got {}", expected, val);
                    }
                }
            }
        }
        Err(e) => {
            println!("No solution found: {:?}", e);
        }
    }
    
    // Test case 2: Element constraint with specific index
    println!("\n=== Test 2: Element with constrained index ===");
    let mut model2 = Model::default();
    
    let arr0 = model2.int(100, 100);
    let arr1 = model2.int(200, 200);
    let arr2 = model2.int(300, 300);
    
    let idx = model2.int(1, 1);     // Fixed to index 1
    let val = model2.int(150, 250); // Should be constrained to 200
    
    model2.props.element(vec![arr0, arr1, arr2], idx, val);
    
    match model2.solve() {
        Ok(solution) => {
            println!("Solution found:");
            println!("  index = {:?}", solution[idx]);
            println!("  value = {:?}", solution[val]);
            
            if let Val::ValI(v) = solution[val] {
                if v == 200 {
                    println!("✓ Correctly propagated: array[1] = 200");
                } else {
                    println!("✗ Expected 200, got {}", v);
                }
            }
        }
        Err(_) => {
            println!("No solution found");
        }
    }
    
    // Test case 3: Element constraint with impossible constraint
    println!("\n=== Test 3: Element with impossible constraint ===");
    let mut model3 = Model::default();
    
    let b0 = model3.int(1, 1);
    let b1 = model3.int(2, 2);
    let b2 = model3.int(3, 3);
    
    let idx3 = model3.int(0, 2);
    let val3 = model3.int(10, 20);  // No array element can have this value
    
    model3.props.element(vec![b0, b1, b2], idx3, val3);
    
    match model3.solve() {
        Ok(_) => {
            println!("✗ Unexpected solution found for impossible constraint");
        }
        Err(_) => {
            println!("✓ No solution found as expected (value not in array)");
        }
    }
    
    // Test case 4: Element with array expression (using a vector)
    println!("\n=== Test 4: Element with array expression ===");
    let mut model4 = Model::default();
    
    let c0 = model4.int(5, 5);
    let c1 = model4.int(15, 15);
    let c2 = model4.int(25, 25);
    let array_vec = vec![c0, c1, c2];
    
    let idx4 = model4.int(0, 2);
    let val4 = model4.int(10, 30);
    
    model4.props.element(array_vec, idx4, val4);
    
    match model4.solve() {
        Ok(solution) => {
            println!("Solution found:");
            println!("  index = {:?}", solution[idx4]);
            println!("  value = {:?}", solution[val4]);
            println!("✓ Element constraint with array expression works");
        }
        Err(_) => {
            println!("No solution found");
        }
    }
    
    // Test case 5: Multiple solutions - show constraint propagation
    println!("\n=== Test 5: Element constraint propagation ===");
    let mut model5 = Model::default();
    
    let d0 = model5.int(10, 15);  // Variable ranges
    let d1 = model5.int(20, 25);
    let d2 = model5.int(30, 35);
    
    let idx5 = model5.int(0, 2);
    let val5 = model5.int(22, 33);  // Should constrain both index and array elements
    
    model5.props.element(vec![d0, d1, d2], idx5, val5);
    
    match model5.solve() {
        Ok(solution) => {
            println!("Solution found:");
            println!("  index = {:?}", solution[idx5]);
            println!("  value = {:?}", solution[val5]);
            println!("  array[0] = {:?}", solution[d0]);
            println!("  array[1] = {:?}", solution[d1]);
            println!("  array[2] = {:?}", solution[d2]);
            println!("✓ Element constraint propagation working");
        }
        Err(_) => {
            println!("No solution found");
        }
    }
}