Refactor InfRational and Lin structs to streamline conversions and remove unused functions

Author: riccardodebenedictis

src/inf_rational.rs

@@ -32,15 +32,21 @@ impl InfRational {
     pub const EPSILON: Self = Self { rat: Rational::ZERO, inf: Rational::ONE };
 }
 
+impl From<(Rational, Rational)> for InfRational {
+    fn from(arg: (Rational, Rational)) -> Self {
+        InfRational::new(arg.0, arg.1)
+    }
+}
+
 impl From<Rational> for InfRational {
     fn from(arg: Rational) -> Self {
-        InfRational { rat: arg, inf: Rational::ZERO }
+        InfRational::new(arg, Rational::ZERO)
     }
 }
 
 impl From<i64> for InfRational {
     fn from(arg: i64) -> Self {
-        InfRational { rat: Rational::from(arg), inf: Rational::ZERO }
+        InfRational::new(Rational::from(arg), Rational::ZERO)
     }
 }
 

src/lib.rs

@@ -24,7 +24,7 @@ mod rational;
 mod var;
 
 pub use inf_rational::InfRational;
-pub use lin::{Lin, vc};
+pub use lin::Lin;
 pub use rational::Rational;
 use std::{
     collections::{BTreeMap, HashMap, HashSet},
@@ -658,8 +658,6 @@ impl fmt::Display for Engine {
 
 #[cfg(test)]
 mod tests {
-    use crate::lin::vc;
-
     use super::*;
 
     #[test]
@@ -758,7 +756,7 @@ mod tests {
         let x = e.add_var();
         let y = e.add_var();
         // x + y <= 5
-        let lhs = vc(x, 1) + vc(y, 1);
+        let lhs = Lin::from(x) + Lin::from(y);
         assert!(e.new_le(&lhs, &Lin::from(5), None).is_ok());
         assert!(e.check().is_ok());
         assert!(e.ub(VarId(e.assignments.len() - 1)) <= &InfRational::from(Rational::from(5))); // slack ub
@@ -925,8 +923,8 @@ mod tests {
         let mut e = Engine::new();
         let x = e.add_var();
         let y = e.add_var();
-        let s1 = e.add_lin_var(vc(x, -1) + vc(y, 1)); // s1 = y - x
-        let s2 = e.add_lin_var(vc(x, 1) + vc(y, 1)); // s2 = x + y
+        let s1 = e.add_lin_var(Lin::from(y) - Lin::from(x)); // s1 = y - x
+        let s2 = e.add_lin_var(Lin::from(x) + Lin::from(y)); // s2 = x + y
 
         let c0 = e.add_guard();
         assert!(e.new_le(&Lin::from(x), &Lin::from(-4), Some(c0)).is_ok()); // x <= -4
@@ -1010,7 +1008,7 @@ mod tests {
 
         // Test lin_lb with negative coefficient: 10 - 2*x + 3*y
         // lb = 10 - 2*ub(x) + 3*lb(y) = 10 - 2*5 + 3*3 = 10 - 10 + 9 = 9
-        let lin = Lin::from(10) + vc(x, -2) + vc(y, 3);
+        let lin = Lin::from(10) + Lin::from(x) * Rational::from(-2) + Lin::from(y) * Rational::from(3);
         let lb = e.lin_lb(&lin);
         assert_eq!(lb, InfRational::from(Rational::from(9)));
 

src/lin.rs

@@ -20,12 +20,6 @@ impl Lin {
         Lin { vars, known_term }
     }
 
-    pub fn new_var(var: VarId, coeff: Rational) -> Self {
-        let mut vars = HashMap::new();
-        vars.insert(var, coeff);
-        Lin::new(vars, Rational::ZERO)
-    }
-
     /// Substitutes a variable with another linear expression.
     ///
     /// If this expression is $L$ and the substitution is $x_i = E$, this method
@@ -86,14 +80,10 @@ impl From<i64> for Lin {
 
 impl From<VarId> for Lin {
     fn from(var: VarId) -> Self {
-        Lin::new_var(var, Rational::ONE)
+        Lin::new(HashMap::from([(var, Rational::ONE)]), Rational::ZERO)
     }
 }
 
-pub fn vc(idx: VarId, coeff: i64) -> Lin {
-    Lin::new_var(idx, Rational::from(coeff))
-}
-
 impl fmt::Display for Lin {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Sort terms to ensure deterministic formatting regardless of HashMap iteration order.

src/rational.rs

@@ -74,6 +74,12 @@ impl Rational {
     pub const ONE: Self = Self { num: 1, den: 1 };
 }
 
+impl From<(i64, i64)> for Rational {
+    fn from(arg: (i64, i64)) -> Self {
+        Rational::new(arg.0, arg.1)
+    }
+}
+
 impl From<i64> for Rational {
     fn from(arg: i64) -> Self {
         Rational::new(arg, 1)