Merge pull request #269 from HunkBenny/variable

mmghannam · web-flow · commit 2622e5ee3dd7 · 2025-12-16T16:01:54.000+01:00
Added `redcost` method to Variable.rs
diff --git a/src/col.rs b/src/col.rs
@@ -169,6 +169,11 @@ impl Col {
         assert!(age >= 0);
         age as usize
     }
+
+    /// Returns the reduced cost of the column.
+    pub fn redcost(&self) -> f64 {
+        unsafe { ffi::SCIPgetColRedcost(self.scip.raw, self.raw) }
+    }
 }
 
 impl PartialEq for Col {
diff --git a/src/variable.rs b/src/variable.rs
@@ -82,7 +82,7 @@ impl Variable {
 
     /// Returns the column associated with the variable.
     pub fn col(&self) -> Option<Col> {
-        if self.is_in_lp() {
+        if self.status() == VarStatus::Column {
             let col_ptr = unsafe { ffi::SCIPvarGetCol(self.raw) };
             let col = Col {
                 raw: col_ptr,
@@ -152,6 +152,21 @@ impl Variable {
         };
         Some(var)
     }
+
+    /// Gets the reduced costs of the variable in the current node's LP relaxation; the current node has to have a feasible LP.
+    ///
+    /// # Returns:
+    ///   `None` - if the variable is active but not in the current LP
+    ///   `Some(0.0)` - if the variable has been aggregated out or fixed in presolving.
+    ///   `Some(f64)` - the reduced cost of the variable
+    pub fn redcost(&self) -> Option<f64> {
+        let rc = unsafe { ffi::SCIPgetVarRedcost(self.scip.raw, self.raw) };
+        // SCIP can return SCIP_INVALID. In this case, we return None.
+        if rc == ffi::SCIP_INVALID {
+            return None;
+        }
+        Some(rc)
+    }
 }
 
 /// The type of variable in an optimization problem.
@@ -227,7 +242,10 @@ impl From<SCIP_Status> for VarStatus {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{Model, ObjSense, ProblemOrSolving, minimal_model};
+    use crate::{
+        Model, ModelWithProblem, ObjSense, Pricer, ProblemOrSolving, minimal_model,
+        prelude::{cons, pricer},
+    };
 
     #[test]
     fn var_data() {
@@ -278,4 +296,64 @@ mod tests {
 
         assert_eq!(x.sol_val(), 1.0);
     }
+
+    struct PricerRedcost;
+    impl Pricer for PricerRedcost {
+        fn generate_columns(
+            &mut self,
+            mut model: Model<crate::Solving>,
+            _pricer: crate::SCIPPricer,
+            _farkas: bool,
+        ) -> crate::PricerResult {
+            if model.vars().len() > 3 {
+                // initial call, no vars yet
+                return crate::PricerResult {
+                    state: crate::PricerResultState::NoColumns,
+                    lower_bound: None,
+                };
+            }
+            let conss = model.conss();
+            let cons1 = &conss[0];
+            let cons2 = &conss[1];
+            let dual1 = cons1.dual_sol().unwrap();
+            let dual2 = cons2.dual_sol().unwrap();
+            // coeff
+            let c = 1.0;
+            // rc
+            let rc = c - dual1 - dual2;
+            // make var
+            let var_obj = model.add_priced_var(0.0, 1.0, c, "testvar", VarType::Continuous);
+            model.add_cons_coef(cons1, &var_obj, 1.0);
+            model.add_cons_coef(cons2, &var_obj, 1.0);
+            // check if calculated rc matches Variable::redcost
+            assert_eq!(rc, var_obj.redcost().unwrap());
+
+            crate::PricerResult {
+                state: crate::PricerResultState::FoundColumns,
+                lower_bound: None,
+            }
+        }
+    }
+
+    #[test]
+    fn var_redcost() {
+        let mut model = minimal_model()
+            .set_longint_param("limits/nodes", 3)
+            .unwrap()
+            .minimize();
+        let x = model.add_var(0.0, 1.0, 10.3, "x", VarType::Binary);
+        let y = model.add_var(0.0, 1.0, 5.5, "y", VarType::Binary);
+        let cons1 = model.add(cons().modifiable(true).ge(5.0));
+        let cons2 = model.add(cons().modifiable(true).ge(10.0));
+        model.add_cons_coef(&cons1, &y, 10.0);
+        model.add_cons_coef(&cons2, &x, 10.0);
+        let pricer_obj = PricerRedcost;
+        model.add(pricer(pricer_obj));
+        // Check if variable is none
+        assert_eq!(x.redcost(), None);
+
+        model.solve();
+        assert!(x.redcost().is_some());
+        assert!(x.transformed().is_some());
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -169,6 +169,11 @@ impl Col {`
`169`	`169`	`assert!(age >= 0);`
`170`	`170`	`age as usize`
`171`	`171`	`}`
	`172`	`+`
	`173`	`+ /// Returns the reduced cost of the column.`
	`174`	`+ pub fn redcost(&self) -> f64 {`
	`175`	`+ unsafe { ffi::SCIPgetColRedcost(self.scip.raw, self.raw) }`
	`176`	`+ }`
`172`	`177`	`}`
`173`	`178`
`174`	`179`	`impl PartialEq for Col {`