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

use selen::prelude::*;

fn main() {
    // Test 1: Basic modulo constraint
    println!("Test 1: Basic modulo - x % 3 == 1, x in 0..10");
    let mut m = Model::default();
    let x = m.int(0, 10);
    let divisor = m.int(3, 3); // Constant 3 as a variable
    
    m.new(x.modulo(divisor).eq(1));
    
    match m.solve() {
        Ok(solution) => {
            let x_val = solution.get_int(x);
            println!("  Solution: x = {}", x_val);
            println!("  Verification: {} % 3 = {}", x_val, x_val % 3);
            assert_eq!(x_val % 3, 1, "Modulo constraint not satisfied!");
        }
        Err(e) => {
            println!("  Error: {:?}", e);
            panic!("Should have found a solution!");
        }
    }
    
    // Test 2: Modulo with variable bounds
    println!("\nTest 2: x % 4 == 2, x in 0..15");
    let mut m = Model::default();
    let x = m.int(0, 15);
    let divisor = m.int(4, 4);
    
    m.new(x.modulo(divisor).eq(2));
    
    match m.solve() {
        Ok(solution) => {
            let x_val = solution.get_int(x);
            println!("  Solution: x = {} (check: {} % 4 = {})", 
                     x_val, x_val, x_val % 4);
            assert_eq!(x_val % 4, 2);
        }
        Err(e) => {
            println!("  Error: {:?}", e);
            panic!("Should have found a solution!");
        }
    }
    
    // Test 3: Modulo in more complex expression
    println!("\nTest 3: Complex - (x % 5) + y == 7, x in 0..20, y in 0..10");
    let mut m = Model::default();
    let x = m.int(0, 20);
    let y = m.int(0, 10);
    let divisor = m.int(5, 5);
    
    m.new(x.modulo(divisor).add(y).eq(7));
    
    match m.solve() {
        Ok(solution) => {
            let x_val = solution.get_int(x);
            let y_val = solution.get_int(y);
            println!("  Solution: x = {}, y = {}", x_val, y_val);
            println!("  Verification: ({} % 5) + {} = {}", 
                     x_val, y_val, (x_val % 5) + y_val);
            assert_eq!((x_val % 5) + y_val, 7, "Constraint not satisfied!");
        }
        Err(e) => {
            println!("  Error: {:?}", e);
            panic!("Should have found a solution!");
        }
    }
    
    println!("\n✅ All modulo tests passed!");
}