Updated documentation

Author: radevgit

docs/guides/getting_started.md

@@ -33,12 +33,12 @@ Let's solve a simple problem: **Find two numbers where one is less than the othe
 ### Step 1: Set Up Your Project
 
 Add to your `Cargo.toml`:
+
 ```toml
-```toml
-selen = "0.8.0"
-```
+selen = "0.8.3"
 ```
 
+
 ### Step 2: Write Your First Solver
 
 ```rust
@@ -103,8 +103,8 @@ let weight = m.float(1.5, 25.0);    // weight ∈ [1.5, 25.0]
 
 ### Custom Domains (Specific Values)
 ```rust
-let day = m.ints(vec![1, 3, 5, 7]);     // Only odd numbers
-let color = m.ints(vec![10, 20, 30]);   // Only these values
+let day = m.intset(vec![1, 3, 5, 7]);     // Only odd numbers
+let color = m.intset(vec![10, 20, 30]);   // Only these values
 ```
 
 ### Boolean Variables
@@ -141,20 +141,18 @@ post!(m, abs(x - y) <= int(3));
 Use method calls for runtime constraint building:
 
 ```rust
-// Basic comparisons
-m.post(x.lt(y));
-m.post(x.ge(5));
-m.post(y.ne(0));
+// Expression builder with m.new()
+m.new(x.lt(y));                    // x < y
+m.new(x.ge(int(5)));               // x >= 5
+m.new(y.ne(int(0)));               // y != 0
 
-// Arithmetic expressions  
-m.post(x.add(y).eq(12));
-m.post(x.mul(y).le(50));
-m.post(x.sub(y).ge(2));
+// Arithmetic expressions
+m.new(x.add(y).eq(int(12)));       // x + y == 12
+m.new(x.mul(y).le(int(50)));       // x * y <= 50
+m.new(x.sub(y).ge(int(2)));        // x - y >= 2
 
-// Complex expressions
-m.post(x.add(y.mul(2)).eq(z));
-let abs_diff = m.abs(x.sub(y));
-m.post(abs_diff.le(3));
+// Complex chaining
+m.new(x.mul(int(2)).add(y).le(int(10)));  // x * 2 + y <= 10
 ```
 
 **When to use each:**
@@ -215,7 +213,7 @@ post!(m, condition2 == (y < int(10)));
 post!(m, and([condition1, condition2]));  // Both conditions must be true
 
 // Alternative: Use runtime API for constraint combinations
-// m.post(x.gt(5).and(y.lt(10)));  // (x > 5) AND (y < 10)
+// post!(m, x > 5 & y < 10);  // (x > 5) AND (y < 10)
 
 // OR logic with boolean variables
 let options = vec![m.bool(), m.bool(), m.bool()];
@@ -395,17 +393,17 @@ fn main() {
 
     // Constraints:
     // 1. Task A must finish before Task B starts
-    post!(m, task_a + int(duration_a) <= task_b);
+    post!(m, task_a + duration_a <= task_b);
 
     // 2. Task B must finish before Task C starts  
-    post!(m, task_b + int(duration_b) <= task_c);
+    post!(m, task_b + duration_b <= task_c);
 
     // 3. All tasks must complete by time 10
-    post!(m, task_c + int(duration_c) <= int(10));
+    post!(m, task_c + duration_c <= 10);
 
     // Solve: minimize the total schedule length
     let makespan = m.int(0, 15);
-    post!(m, makespan == task_c + int(duration_c));
+    post!(m, makespan == task_c + duration_c);
 
     match m.minimize(makespan) {
         Ok(solution) => {

docs/guides/mathematical_syntax.md

@@ -10,14 +10,14 @@ use selen::math_syntax::*;
 use selen::constraint_macros::*;
 
 // Create model and variables
-let mut m = Model::new();
-let x = m.var_int(1, 10);
-let y = m.var_int(1, 20);
+let mut m = Model::default();
+let x = m.int(1, 10);
+let y = m.int(1, 20);
 
 // Post constraints using mathematical syntax
 post!(m, x < y);
 post!(m, x >= int(3));
-post!(m, y % 3 == 1);
+post!(m, y % int(3) == int(1));
 ```
 
 ## Supported Features
@@ -32,17 +32,17 @@ post!(m, x == y);   // Equal
 post!(m, x != y);   // Not equal
 ```
 
-### Typed Constants
-Use helper functions for explicit type specification:
+### Constants
+Use int() for integer constants and float() for float constants:
 ```rust
-post!(m, x >= int(5));     // Integer constant
-post!(m, y <= float(3.14)); // Float constant
+post!(m, x >= int(5));          // Integer constant
+post!(m, y <= float(3.14));     // Float constant
 ```
 
 ### Modulo Constraints
 ```rust
-post!(m, x % 3 == 1);      // x mod 3 equals 1
-post!(m, y % 7 != int(0)); // y is not divisible by 7
+post!(m, x % int(3) == int(1));      // x mod 3 equals 1
+post!(m, y % int(7) != int(0));      // y is not divisible by 7
 ```
 
 ### Logical Operations
@@ -79,7 +79,7 @@ postall!(m, [
     x < y,
     y <= int(15),
     x >= int(1),
-    y % 3 == 1
+    y % int(3) == int(1)
 ]);
 ```
 
@@ -91,17 +91,17 @@ use selen::math_syntax::*;
 use selen::constraint_macros::*;
 
 fn main() {
-    let mut m = Model::new();
+    let mut m = Model::default();
 
     // Variables
-    let x = m.var_int(1, 10);
-    let y = m.var_int(1, 20);
-    let z = m.var_int(1, 15);
+    let x = m.int(1, 10);
+    let y = m.int(1, 20);
+    let z = m.int(1, 15);
 
     // Mathematical constraints
     post!(m, x < y);
     post!(m, and(y <= int(15), z >= int(5)));
-    post!(m, x % 3 == 1);
+    post!(m, x % int(3) == int(1));
     post!(m, or(x == int(1), x == int(7)));
 
     // Solve
@@ -113,14 +113,6 @@ fn main() {
 }
 ```
 
-## Future Enhancements
-
-Planned syntax extensions include:
-- Arithmetic expressions: `post!(m, x + 3 < y)`
-- Multiplication: `post!(m, x * 2 <= 10)`
-- Function integration: `post!(m, abs(x) >= int(1))`
-- Complex expressions: `post!(m, max(x, y) <= int(15))`
-- Nested logical operations: `post!(m, and(or(c1, c2), not(c3)))`
 
 ## Implementation Details
 

docs/guides/precision_quick_reference.md

@@ -64,7 +64,7 @@ ctx.try_set_min(var_id, bounds.lower_bound);
 ### Enable Precision Handling
 
 ```rust
-let mut model = Model::new();
+let mut model = Model::default();
 
 // Add variables and constraints normally
 let x = model.new_var_float(0.0, 10.0);

docs/guides/programmatic_api.md

@@ -0,0 +1,176 @@
+## Advanced/Complicated Examples
+
+
+# Programmatic API Guide
+
+This guide explains how to use the Selen CSP solver's programmatic API for building constraints dynamically at runtime. This is useful when constraints depend on user input, data, or are not known at compile time.
+
+## When to Use the Programmatic API
+- When you need to generate constraints based on data or user input
+- When constraints are not static or known in advance
+- For advanced use cases where mathematical syntax is not flexible enough
+
+## Key Concepts
+- **Fluent builder pattern**: Chain methods to build complex expressions
+- **m.new()**: The primary method to post programmatic constraints
+- **int() / float()**: Always wrap constants in constraints
+
+## Basic Usage
+
+```rust
+use selen::prelude::*;
+
+fn main() {
+    let mut m = Model::default();
+    let x = m.int(1, 10);
+    let y = m.int(1, 10);
+
+    // Comparison constraint: x < y
+    m.new(x.lt(y));
+
+    // Comparison with constant: x >= 5
+    m.new(x.ge(int(5)));
+
+    // Arithmetic constraint: x + y == 12
+    m.new(x.add(y).eq(int(12)));
+
+    // Chained arithmetic: x * 2 + y <= 10
+    m.new(x.mul(int(2)).add(y).le(int(10)));
+}
+```
+
+## Building Expressions
+
+You can chain methods to build complex expressions:
+
+```rust
+// (x * 3 + y) % 4 == 1
+m.new(x.mul(int(3)).add(y).modulo(int(4)).eq(int(1)));
+
+// abs(x - y) <= 2
+m.new(x.sub(y).abs().le(int(2)));
+
+// (x + y) * z >= 20
+m.new(x.add(y).mul(z).ge(int(20)));
+```
+
+## Dynamic Constraint Generation
+
+You can generate constraints in loops or based on data:
+
+```rust
+let vars: Vec<_> = (0..5).map(|_| m.int(1, 10)).collect();
+
+// All variables must be different
+m.new(alldiff(vars.clone()));
+
+// Post constraints for each variable
+for v in &vars {
+    m.new(v.ge(int(3)));
+}
+```
+
+## Boolean Logic
+
+You can build boolean expressions and combine them:
+
+```rust
+let a = m.bool();
+let b = m.bool();
+
+// a == (x > 5)
+m.new(a.eq(x.gt(int(5))));
+// b == (y < 7)
+m.new(b.eq(y.lt(int(7))));
+// a AND b
+m.new(and([a, b]));
+// a OR b
+m.new(or([a, b]));
+// NOT a
+m.new(not(a));
+```
+
+## Global Constraints
+
+```rust
+let vars = vec![x, y, z];
+// All different
+m.new(alldiff(vars.clone()));
+// All equal
+m.new(allequal(vars.clone()));
+// Sum equals 15
+m.new(sum(vars.clone()).eq(int(15)));
+```
+
+## Tips
+- Always use `int()` or `float()` for constants in constraints
+- Use method chaining to build up complex expressions
+- Use `m.new()` to post each constraint
+- For static constraints, prefer the `post!` macro and mathematical syntax
+
+---
+
+For more details, see the [API documentation](https://docs.rs/selen) and the `examples/advanced_runtime_api.rs` file in the repository.
+
+
+## Advanced/Complicated Examples
+
+Here are some advanced examples demonstrating the flexibility of the programmatic API:
+
+```rust
+use selen::prelude::*;
+
+fn main() {
+    let mut m = Model::default();
+    let n = 5;
+    let vars = m.ints(1, 20, n);
+    let z = m.int(1, 100);
+
+    // 1. All variables are pairwise different and their sum is even
+    m.new(alldiff(vars.clone()));
+    let sum_var = m.int(0, 100);
+    m.new(sum(vars.clone()).eq(sum_var));
+    m.new(sum_var.modulo(int(2)).eq(int(0)));
+
+    // 2. For each i, vars[i] * (i+1) <= z
+    for (i, v) in vars.iter().enumerate() {
+        m.new(v.mul(int((i+1) as i32)).le(z));
+    }
+
+    // 3. At least 2 variables are greater than 10
+    let bools = m.bools(n);
+    for (b, v) in bools.iter().zip(vars.iter()) {
+        m.new(b.eq(v.gt(int(10))));
+    }
+    m.new(sum(bools.clone()).ge(int(2)));
+
+    // 4. Nested boolean logic: (x > 5 && y < 7) || z == 42
+    let x = vars[0];
+    let y = vars[1];
+    let cond1 = m.bool();
+    let cond2 = m.bool();
+    let cond3 = m.bool();
+    m.new(cond1.eq(x.gt(int(5))));
+    m.new(cond2.eq(y.lt(int(7))));
+    m.new(cond3.eq(z.eq(int(42))));
+    let and_cond = m.bool();
+    m.new(and_cond.eq(and([cond1, cond2])));
+    m.new(or([and_cond, cond3]));
+
+    // 5. Complex arithmetic: product of all variables >= 1000
+    let mut prod = vars[0].clone();
+    for v in vars.iter().skip(1) {
+        prod = prod.mul(*v);
+    }
+    m.new(prod.ge(int(1000)));
+
+    // 6. Absolute difference constraints: |x - y| + |y - z| <= 15
+    let abs_sum = x.sub(y).abs().add(y.sub(z).abs());
+    m.new(abs_sum.le(int(15)));
+
+    // 7. Conditional constraint: if x > 10 then z < 50
+    let cond = m.bool();
+    m.new(cond.eq(x.gt(int(10))));
+    m.new(implies(cond, z.lt(int(50))));
+}
+```