Skip to main content

bool_float_demo/
bool_float_demo.rs

1/// Example: Boolean and Float Variables
2///
3/// Demonstrates the new support for boolean and float variable types
4
5fn main() -> Result<(), Box<dyn std::error::Error>> {
6    println!("=== Boolean and Float Variables Demo ===\n");
7
8    // Example 1: Boolean variables
9    let bool_source = r#"
10        var bool: flag1;
11        var bool: flag2;
12        constraint flag1 != flag2;
13        solve satisfy;
14    "#;
15
16    println!("Example 1: Boolean Variables");
17    println!("MiniZinc Source:");
18    println!("{}", bool_source);
19    
20    let ast = zelen::parse(bool_source)?;
21    let translated = zelen::Translator::translate_with_vars(&ast)?;
22    
23    println!("✓ Translated to Selen Model");
24    println!("  Boolean variables: {:?}", translated.bool_vars.keys().collect::<Vec<_>>());
25    
26    match translated.model.solve() {
27        Ok(solution) => {
28            println!("✓ Solution found!");
29            for (name, &var_id) in &translated.bool_vars {
30                match solution[var_id] {
31                    selen::variables::Val::ValI(val) => {
32                        println!("  {} = {}", name, if val == 1 { "true" } else { "false" });
33                    }
34                    _ => {}
35                }
36            }
37        }
38        Err(e) => {
39            println!("✗ No solution: {:?}", e);
40        }
41    }
42
43    println!("\n{}\n", "=".repeat(60));
44
45    // Example 2: Float variables
46    let float_source = r#"
47        var 0.0..1.0: probability;
48        var 0.0..10.0: price;
49        constraint probability * price > 5.0;
50        solve satisfy;
51    "#;
52
53    println!("Example 2: Float Variables with Domains");
54    println!("MiniZinc Source:");
55    println!("{}", float_source);
56    
57    let ast = zelen::parse(float_source)?;
58    let translated = zelen::Translator::translate_with_vars(&ast)?;
59    
60    println!("✓ Translated to Selen Model");
61    println!("  Float variables: {:?}", translated.float_vars.keys().collect::<Vec<_>>());
62    
63    match translated.model.solve() {
64        Ok(solution) => {
65            println!("✓ Solution found!");
66            for (name, &var_id) in &translated.float_vars {
67                if let selen::variables::Val::ValF(val) = solution[var_id] {
68                    println!("  {} = {:.2}", name, val);
69                }
70            }
71        }
72        Err(e) => {
73            println!("✗ No solution: {:?}", e);
74        }
75    }
76
77    println!("\n{}\n", "=".repeat(60));
78
79    // Example 3: Boolean array
80    let bool_array_source = r#"
81        array[1..5] of var bool: flags;
82        solve satisfy;
83    "#;
84
85    println!("Example 3: Boolean Array");
86    println!("MiniZinc Source:");
87    println!("{}", bool_array_source);
88    
89    let ast = zelen::parse(bool_array_source)?;
90    let translated = zelen::Translator::translate_with_vars(&ast)?;
91    
92    println!("✓ Translated to Selen Model");
93    println!("  Boolean arrays: {:?}", translated.bool_var_arrays.keys().collect::<Vec<_>>());
94    
95    match translated.model.solve() {
96        Ok(solution) => {
97            println!("✓ Solution found!");
98            if let Some(flags) = translated.bool_var_arrays.get("flags") {
99                print!("  flags = [");
100                for (i, var_id) in flags.iter().enumerate() {
101                    if i > 0 { print!(", "); }
102                    match solution[*var_id] {
103                        selen::variables::Val::ValI(val) => {
104                            print!("{}", if val == 1 { "true" } else { "false" });
105                        }
106                        _ => print!("?"),
107                    }
108                }
109                println!("]");
110            }
111        }
112        Err(e) => {
113            println!("✗ No solution: {:?}", e);
114        }
115    }
116
117    println!("\n=== Demo Complete ===");
118    
119    Ok(())
120}