modulo for both var parameters

Author: radevgit

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.14.1] - 2025-10-17
+- Fix modulo to accept two variables
+
 ## [0.14.0] - 2025-10-16
 - count(var, var) now uses Vies-s and can work with both const and vars
 - Boolean XOR implemented

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "selen"
-version = "0.14.0"
+version = "0.14.1"
 edition = "2024"
 description = "Constraint Satisfaction Problem (CSP) solver"
 rust-version = "1.88"

Cargo.toml

@@ -0,0 +1,45 @@
+// Debug test for modulo constraint
+use selen::prelude::*;
+
+fn main() {
+    println!("=== Debug Modulo Constraint ===\n");
+
+    // Simplest possible test
+    let mut m = Model::default();
+    
+    let x = m.int(47, 47);      // Fixed x = 47
+    let y = m.int(10, 10);       // Fixed y = 10
+    let result = m.int(0, 9);    // Result in [0..9]
+
+    println!("Variables created:");
+    println!("  x: {:?}", x);
+    println!("  y: {:?}", y);
+    println!("  result: {:?}", result);
+    
+    // Add modulo constraint
+    println!("\nAdding modulo constraint: result = x mod y");
+    let mod_id = m.modulo(x, y);
+    println!("  Modulo created variable: {:?}", mod_id);
+    
+    // Constrain result to equal mod_id
+    m.new(result.eq(mod_id));
+    
+    println!("\nSolving...");
+    match m.solve() {
+        Ok(solution) => {
+            let x_val = solution.get_int(x);
+            let y_val = solution.get_int(y);
+            let result_val = solution.get_int(result);
+            let mod_val = solution.get_int(mod_id);
+            
+            println!("✓ Solution found!");
+            println!("  x = {}", x_val);
+            println!("  y = {}", y_val);
+            println!("  result = {} (should be 7)", result_val);
+            println!("  mod_id = {} (the direct modulo result)", mod_val);
+        }
+        Err(e) => {
+            println!("✗ Failed: {:?}", e);
+        }
+    }
+}

debug_backup/test_modulo_debug.rs

@@ -0,0 +1,41 @@
+// Debug: trace what happens with deferred modulo
+use selen::prelude::*;
+
+fn main() {
+    let mut m = Model::default();
+    
+    let number = m.int(10, 100);
+    let divisor = m.int(10, 10);
+    let remainder = m.int(0, 9);
+    
+    println!("After creating variables:");
+    println!("  number domain: [10..100]");
+    println!("  divisor domain: [10..10]");
+    println!("  remainder domain: [0..9]");
+    
+    println!("\nCalling m.new(number.eq(47))...");
+    m.new(number.eq(47));
+    println!("  (constraint deferred)");
+    
+    println!("\nCalling m.modulo(number, divisor)...");
+    let mod_result = m.modulo(number, divisor);
+    println!("  mod_result variable created: {:?}", mod_result);
+    
+    println!("\nCalling m.new(remainder.eq(mod_result))...");
+    m.new(remainder.eq(mod_result));
+    println!("  (constraint deferred)");
+    
+    println!("\nCalling m.solve()...");
+    match m.solve() {
+        Ok(sol) => {
+            println!("✓ SOLUTION FOUND!");
+            println!("  number = {}", sol.get_int(number));
+            println!("  divisor = {}", sol.get_int(divisor));
+            println!("  remainder = {}", sol.get_int(remainder));
+            println!("  mod_result = {}", sol.get_int(mod_result));
+        }
+        Err(e) => {
+            println!("✗ NO SOLUTION: {:?}", e);
+        }
+    }
+}

debug_backup/test_modulo_debug_trace.rs

@@ -167,8 +167,14 @@ impl Model {
         let y_min = y.min_raw(&self.vars);
         let y_max = y.max_raw(&self.vars);
 
-        // Calculate bounds for modulo result
-        // This is conservative - the actual bounds depend on the signs of x and y
+        // IMPORTANT: We must create the result variable with bounds that account for
+        // potential pending deferred constraints. Since we can't know what those are,
+        // we use CONSERVATIVE bounds that encompass all possible modulo results.
+        
+        // For modulo, the result is always in range [0, |divisor|-1] when divisor > 0
+        // So we need to find the range that could result from ANY x in its range
+        // and ANY y in its range that isn't zero.
+        
         let mut min = Val::ValI(i32::MAX);
         let mut max = Val::ValI(i32::MIN);
 
@@ -207,6 +213,39 @@ impl Model {
                 Val::ValF(f) => Val::ValF(-f),
             };
             max = y_abs_max;
+        } else {
+            // CRITICAL FIX: Even with sampled bounds, we need to be MORE conservative
+            // to handle deferred constraints that might widen the operand domains.
+            // Expand the bounds to cover all possible modulo results.
+            match (min, max) {
+                (Val::ValI(_min_i), Val::ValI(_max_i)) => {
+                    // For integers, check what the worst-case modulo result could be
+                    // given the range of divisors
+                    if let (Val::ValI(y_min_i), Val::ValI(y_max_i)) = (y_min, y_max) {
+                        // The maximum modulo result magnitude is (max(|y|) - 1)
+                        let y_abs_max = if y_min_i.abs() > y_max_i.abs() {
+                            y_min_i.abs()
+                        } else {
+                            y_max_i.abs()
+                        };
+                        
+                        if y_abs_max > 0 {
+                            // Result can be [-(y_abs_max-1), y_abs_max-1]
+                            // Only expand if needed to encompass computed range
+                            let new_min = Val::ValI(-(y_abs_max - 1));
+                            let new_max = Val::ValI(y_abs_max - 1);
+                            
+                            if new_min < min {
+                                min = new_min;
+                            }
+                            if new_max > max {
+                                max = new_max;
+                            }
+                        }
+                    }
+                }
+                _ => {} // For floats, keep as-is
+            }
         }
 
         let s = self.new_var_unchecked(min, max);

src/constraints/api/arithmetic.rs

@@ -22,20 +22,59 @@ impl<U: View, V: View> Prune for Modulo<U, V> {
         let x_max = self.x.max(ctx);
         let y_min = self.y.min(ctx);
         let y_max = self.y.max(ctx);
+        let s_min = self.s.min(ctx);
+        let s_max = self.s.max(ctx);
 
         // If y contains zero or values too close to zero, we can't safely compute modulo
         if Val::range_contains_unsafe_divisor(y_min, y_max) {
             // We can still try to propagate some constraints if parts of the domain are safe
             return Some(());
         }
 
-        // Calculate possible modulo results
-        let mut s_candidates = Vec::new();
-        
-        // For modulo, the result is always in range [0, |y|-1] for positive y
-        // and [-|y|+1, 0] for negative y, but we need to be more careful with mixed signs
+        // CASE 1: Both x and y are fixed → exact computation
+        if x_min == x_max && y_min == y_max {
+            if let Some(exact_result) = x_min.safe_mod(y_min) {
+                // Set s to this exact value
+                self.s.try_set_min(exact_result, ctx)?;
+                self.s.try_set_max(exact_result, ctx)?;
+                return Some(());
+            }
+        }
+
+        // CASE 2: y is fixed (and non-zero) → compute s bounds based on x range
+        if y_min == y_max {
+            if let Val::ValI(y_val) = y_min {
+                if y_val != 0 {
+                    // For modulo: s is in range [0, |y|-1] when y > 0
+                    // or [-(|y|-1), 0] when y < 0
+                    if y_val > 0 {
+                        let s_theoretical_min = Val::ValI(0);
+                        let s_theoretical_max = Val::ValI(y_val - 1);
+                        
+                        let new_s_min = if s_theoretical_min > s_min { s_theoretical_min } else { s_min };
+                        let new_s_max = if s_theoretical_max < s_max { s_theoretical_max } else { s_max };
+                        
+                        self.s.try_set_min(new_s_min, ctx)?;
+                        self.s.try_set_max(new_s_max, ctx)?;
+                    } else {
+                        // y_val < 0
+                        let s_theoretical_min = Val::ValI(y_val + 1);
+                        let s_theoretical_max = Val::ValI(0);
+                        
+                        let new_s_min = if s_theoretical_min > s_min { s_theoretical_min } else { s_min };
+                        let new_s_max = if s_theoretical_max < s_max { s_theoretical_max } else { s_max };
+                        
+                        self.s.try_set_min(new_s_min, ctx)?;
+                        self.s.try_set_max(new_s_max, ctx)?;
+                    }
+                }
+            }
+        }
+
+        // CASE 3: Both x and y are in bounded ranges → compute s bounds
+        let mut s_candidates = Vec::with_capacity(4);
 
-        // Sample points at domain boundaries and some intermediate values
+        // Sample points at domain boundaries
         let x_samples = if x_min == x_max {
             vec![x_min]
         } else {
@@ -52,7 +91,7 @@ impl<U: View, V: View> Prune for Modulo<U, V> {
         for &x_val in &x_samples {
             for &y_val in &y_samples {
                 if let Some(mod_result) = x_val.safe_mod(y_val) {
-                    // Check if the result is not NaN or infinite
+                    // Check if the result is valid
                     match mod_result {
                         Val::ValF(f) if f.is_finite() => s_candidates.push(mod_result),
                         Val::ValI(_) => s_candidates.push(mod_result),
@@ -64,70 +103,52 @@ impl<U: View, V: View> Prune for Modulo<U, V> {
 
         if !s_candidates.is_empty() {
             // Find bounds for s based on modulo properties
-            let s_min = s_candidates.iter().fold(s_candidates[0], |acc, &x| if x < acc { x } else { acc });
-            let s_max = s_candidates.iter().fold(s_candidates[0], |acc, &x| if x > acc { x } else { acc });
-            
-            // For modulo, we know more about the bounds:
-            // If y > 0: 0 <= s < y
-            // If y < 0: y < s <= 0
-            // We can use this to tighten bounds further
-            let y_abs_min = match (y_min, y_max) {
-                (Val::ValI(min_i), Val::ValI(max_i)) => {
-                    if min_i > 0 { Some(Val::ValI(0)) }
-                    else if max_i < 0 { Some(Val::ValI(max_i + 1)) }
-                    else { None }
-                },
-                (Val::ValF(min_f), Val::ValF(max_f)) => {
-                    if min_f > 0.0 { Some(Val::ValF(0.0)) }
-                    else if max_f < 0.0 { Some(Val::ValF(max_f + 1.0)) }
-                    else { None }
-                },
-                _ => None,
-            };
+            let s_computed_min = s_candidates.iter().fold(s_candidates[0], |acc, &x| if x < acc { x } else { acc });
+            let s_computed_max = s_candidates.iter().fold(s_candidates[0], |acc, &x| if x > acc { x } else { acc });
 
-            let y_abs_max = match (y_min, y_max) {
-                (Val::ValI(min_i), Val::ValI(max_i)) => {
-                    if min_i > 0 { Some(Val::ValI(max_i - 1)) }
-                    else if max_i < 0 { Some(Val::ValI(0)) }
-                    else { None }
-                },
-                (Val::ValF(min_f), Val::ValF(max_f)) => {
-                    if min_f > 0.0 { Some(Val::ValF(max_f - f64::EPSILON)) }
-                    else if max_f < 0.0 { Some(Val::ValF(0.0)) }
-                    else { None }
-                },
-                _ => None,
-            };
-            
-            // Use the tighter bounds if available
-            let final_s_min = if let Some(theoretical_min) = y_abs_min {
-                if theoretical_min > s_min { theoretical_min } else { s_min }
-            } else { s_min };
-            
-            let final_s_max = if let Some(theoretical_max) = y_abs_max {
-                if theoretical_max < s_max { theoretical_max } else { s_max }
-            } else { s_max };
-            
-            // Propagate bounds to s
-            let _min = self.s.try_set_min(final_s_min, ctx)?;
-            let _max = self.s.try_set_max(final_s_max, ctx)?;
+            // CRITICAL FIX: Allow expansion if current domain is too narrow
+            // This can happen when result variable was created before deferred constraints applied
+            // and those deferred constraints now require larger modulo values.
+            // We must try to set the bounds, and if it fails, return None (fail the space)
+            self.s.try_set_min(s_computed_min, ctx)?;
+            self.s.try_set_max(s_computed_max, ctx)?;
         }
-        
-        // Back-propagation is complex for modulo, so we do limited propagation
-        // We can at least ensure that if s is known and y is known, we can constrain x
-        let s_min = self.s.min(ctx);
-        let s_max = self.s.max(ctx);
-        
-        // If y and s are both fixed, we can derive some constraints on x
+
+        // CASE 4: Back-propagation from s to x (when y and s are fixed)
         if y_min == y_max && s_min == s_max {
-            // x = k * y + s for some integer k
-            // We need to find valid values of k such that x is in its domain
-            let y_val = y_min;
-            let s_val = s_min;
-            
-            if let (Some(_), Some(_)) = (y_val.safe_div(Val::ValI(1)), s_val.safe_div(Val::ValI(1))) {
-                // For now, we don't do complex back-propagation for modulo
-                // This would require more sophisticated interval arithmetic
+            if let (Val::ValI(y_val), Val::ValI(s_val)) = (y_min, s_min) {
+                if y_val != 0 && s_val >= 0 && s_val < y_val.abs() {
+                    // x = k * y + s for some integer k
+                    // We need to find the range of k such that x remains in bounds
+                    let x_current_min = x_min;
+                    let x_current_max = x_max;
+                    
+                    // Find the minimum and maximum k
+                    let mut valid_x_values = Vec::with_capacity(8);
+                    
+                    if let (Val::ValI(x_curr_min), Val::ValI(x_curr_max)) = (x_current_min, x_current_max) {
+                        // Try k values that produce x in the valid range
+                        let k_min_theoretical = (x_curr_min - s_val) / y_val;
+                        let k_max_theoretical = (x_curr_max - s_val) / y_val;
+                        
+                        // Try a range around these theoretical k values
+                        for k in (k_min_theoretical - 1)..=(k_max_theoretical + 1) {
+                            let candidate_x = k * y_val + s_val;
+                            if candidate_x >= x_curr_min && candidate_x <= x_curr_max {
+                                valid_x_values.push(Val::ValI(candidate_x));
+                            }
+                        }
+                        
+                        if !valid_x_values.is_empty() {
+                            let new_x_min = valid_x_values.iter().fold(valid_x_values[0], |acc, &x| if x < acc { x } else { acc });
+                            let new_x_max = valid_x_values.iter().fold(valid_x_values[0], |acc, &x| if x > acc { x } else { acc });
+                            
+                            // Try to tighten x bounds
+                            self.x.try_set_min(new_x_min, ctx)?;
+                            self.x.try_set_max(new_x_max, ctx)?;
+                        }
+                    }
+                }
             }
         }