because it is sometimes useful, the transition cost function now has …

…an access to the target node that is reached
xgillard · Feb 22, 2024 · d5adf2e · d5adf2e
1 parent 1752b1e
commit d5adf2e
Show file tree

Hide file tree

Showing 23 changed files with 41 additions and 41 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/ddo/Cargo.toml b/ddo/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name             = "ddo"
-version          = "1.2.0"
+version          = "2.0.0"
 authors          = ["Xavier Gillard <xavier.gillard@uclouvain.be>"]
 edition          = "2021"
 description      = "DDO a generic and efficient framework for MDD-based optimization."

diff --git a/ddo/examples/alp/model.rs b/ddo/examples/alp/model.rs
@@ -148,7 +148,7 @@ impl Problem for Alp {
         }
     }
 
-    fn transition_cost(&self, state: &Self::State, decision: ddo::Decision) -> isize {
+    fn transition_cost(&self, state: &Self::State, _: &Self::State, decision: ddo::Decision) -> isize {
         if decision.value == DUMMY {
             0
         } else {

diff --git a/ddo/examples/golomb/main.rs b/ddo/examples/golomb/main.rs
@@ -117,7 +117,7 @@ impl Problem for Golomb {
     }
 
     // compute the cost of the decision from the given state
-    fn transition_cost(&self, state: &Self::State, dec: Decision) -> isize {
+    fn transition_cost(&self, state: &Self::State, _: &Self::State, dec: Decision) -> isize {
         // distance between the new mark and the previous one
         -(dec.value - state.last_mark) // put a minus to turn objective into maximization (ddo requirement)
     }

diff --git a/ddo/examples/knapsack/main.rs b/ddo/examples/knapsack/main.rs
@@ -111,7 +111,7 @@ impl Problem for Knapsack {
         }
         ret
     }
-    fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+    fn transition_cost(&self, _state: &Self::State, _: &Self::State, dec: Decision) -> isize {
         self.profit[dec.variable.id()] * dec.value
     }
 

diff --git a/ddo/examples/lcs/model.rs b/ddo/examples/lcs/model.rs
@@ -120,7 +120,7 @@ impl Problem for Lcs {
         LcsState { position }
     }
 
-    fn transition_cost(&self, _: &Self::State, decision: ddo::Decision) -> isize {
+    fn transition_cost(&self, _: &Self::State, _: &Self::State, decision: ddo::Decision) -> isize {
         match decision.value {
             GO_TO_END_OF_STRINGS => 0,
             _ => 1,

diff --git a/ddo/examples/max2sat/model.rs b/ddo/examples/max2sat/model.rs
@@ -291,7 +291,7 @@ impl Problem for Max2Sat {
         ret
     }
 
-    fn transition_cost(&self, state: &State, d: Decision) -> isize {
+    fn transition_cost(&self, state: &State, _: &Self::State, d: Decision) -> isize {
         let k = d.variable;
         let vars = self.varset(state);
         if d.value == F {

diff --git a/ddo/examples/mcp/model.rs b/ddo/examples/mcp/model.rs
@@ -77,7 +77,7 @@ impl Problem for Mcp {
         McpState {depth: 1 + state.depth, benef: benefits}
     }
 
-    fn transition_cost(&self, state: &McpState, d: Decision) -> isize {
+    fn transition_cost(&self, state: &McpState, _: &Self::State, d: Decision) -> isize {
         match d.value {
             S => if state.depth == 0 { 0 } else { self.branch_on_s(state, d) },
             T => if state.depth == 0 { 0 } else { self.branch_on_t(state, d) },

diff --git a/ddo/examples/misp/main.rs b/ddo/examples/misp/main.rs
@@ -84,7 +84,7 @@ impl Problem for Misp {
         res
     }
 
-    fn transition_cost(&self, _: &Self::State, decision: Decision) -> isize {
+    fn transition_cost(&self, _: &Self::State, _: &Self::State, decision: Decision) -> isize {
         if decision.value == NO {
             0
         } else {

diff --git a/ddo/examples/psp/model.rs b/ddo/examples/psp/model.rs
@@ -90,7 +90,7 @@ impl Problem for Psp {
         ret
     }
 
-    fn transition_cost(&self, state: &Self::State, decision: ddo::Decision) -> isize {
+    fn transition_cost(&self, state: &Self::State, _: &Self::State, decision: ddo::Decision) -> isize {
         if decision.value == IDLE {
             0
         } else {

diff --git a/ddo/examples/sop/model.rs b/ddo/examples/sop/model.rs
@@ -118,7 +118,7 @@ impl Problem for Sop {
         next
     }
 
-    fn transition_cost(&self, state: &SopState, d: Decision) -> isize {
+    fn transition_cost(&self, state: &SopState, _: &Self::State, d: Decision) -> isize {
         // Sop is a minimization problem but the solver works with a 
         // maximization perspective. So we have to negate the cost.
 

diff --git a/ddo/examples/srflp/model.rs b/ddo/examples/srflp/model.rs
@@ -129,7 +129,7 @@ impl Problem for Srflp {
         }
     }
 
-    fn transition_cost(&self, state: &SrflpState, d: Decision) -> isize {
+    fn transition_cost(&self, state: &SrflpState, _: &Self::State, d: Decision) -> isize {
         let d = d.value as usize;
 
         let mut cut = 0;

diff --git a/ddo/examples/talentsched/model.rs b/ddo/examples/talentsched/model.rs
@@ -110,7 +110,7 @@ impl Problem for TalentSched {
         ret
     }
 
-    fn transition_cost(&self, state: &Self::State, decision: ddo::Decision) -> isize {
+    fn transition_cost(&self, state: &Self::State, _: &Self::State, decision: ddo::Decision) -> isize {
         let scene = decision.value as usize;
 
         let pay = self.get_present(state).diff(self.actors[scene]);

diff --git a/ddo/examples/tsptw/model.rs b/ddo/examples/tsptw/model.rs
@@ -113,7 +113,7 @@ impl Problem for Tsptw {
         }
     }
 
-    fn transition_cost(&self, state: &TsptwState, d: Decision) -> isize {
+    fn transition_cost(&self, state: &TsptwState, _: &Self::State, d: Decision) -> isize {
         // Tsptw is a minimization problem but the solver works with a 
         // maximization perspective. So we have to negate the min if we want to
         // yield a lower bound.

diff --git a/ddo/examples/visualisation/main.rs b/ddo/examples/visualisation/main.rs
@@ -97,7 +97,7 @@ impl Problem for Knapsack {
         }
         ret
     }
-    fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+    fn transition_cost(&self, _state: &Self::State, _: &Self::State, dec: Decision) -> isize {
         self.profit[dec.variable.id()] as isize * dec.value
     }
 

diff --git a/ddo/src/abstraction/dp.rs b/ddo/src/abstraction/dp.rs
@@ -47,7 +47,7 @@ pub trait Problem {
     fn transition(&self, state: &Self::State, decision: Decision) -> Self::State;
     /// This method is an implementation of the transition cost function mentioned
     /// in the mathematical model of a DP formulation for some problem.
-    fn transition_cost(&self, state: &Self::State, decision: Decision) -> isize;
+    fn transition_cost(&self, source: &Self::State, dest: &Self::State, decision: Decision) -> isize;
     /// Any problem needs to be able to specify an ordering on the variables
     /// in order to decide which variable should be assigned next. This choice
     /// is an **heuristic** choice. The variable ordering does not need to be
@@ -165,7 +165,7 @@ mod tests {
         fn transition(&self, _: &Self::State, _: Decision) -> Self::State {
             todo!()
         }
-        fn transition_cost(&self, _: &Self::State, _: Decision) -> isize {
+        fn transition_cost(&self, _: &Self::State, _: &Self::State, _: Decision) -> isize {
             todo!()
         }
         fn next_variable(&self, _: usize, _: &mut dyn Iterator<Item = &Self::State>)

diff --git a/ddo/src/implementation/heuristics/cutoff.rs b/ddo/src/implementation/heuristics/cutoff.rs
@@ -73,7 +73,7 @@ use crate::Cutoff;
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, next_layer: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -212,7 +212,7 @@ impl Cutoff for NoCutoff {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {

diff --git a/ddo/src/implementation/heuristics/width.rs b/ddo/src/implementation/heuristics/width.rs
@@ -84,7 +84,7 @@ use crate::{WidthHeuristic, SubProblem};
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, next_layer: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -223,7 +223,7 @@ impl <X> WidthHeuristic<X> for FixedWidth {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -312,7 +312,7 @@ impl <X> WidthHeuristic<X> for FixedWidth {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -462,7 +462,7 @@ impl <X> WidthHeuristic<X> for NbUnassignedWidth {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, next_layer: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -551,7 +551,7 @@ impl <X> WidthHeuristic<X> for NbUnassignedWidth {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, next_layer: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -702,7 +702,7 @@ impl <S, X: WidthHeuristic<S>> WidthHeuristic<S> for Times<X> {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -791,7 +791,7 @@ impl <S, X: WidthHeuristic<S>> WidthHeuristic<S> for Times<X> {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {

diff --git a/ddo/src/implementation/mdd/clean.rs b/ddo/src/implementation/mdd/clean.rs
@@ -727,7 +727,7 @@ where
     ) {
         let state = get!(node from_id, self).state.as_ref();
         let next_state = Arc::new(problem.transition(state, decision));
-        let cost = problem.transition_cost(state, decision);
+        let cost = problem.transition_cost(state, next_state.as_ref(), decision);
 
         match self.next_l.entry(next_state.clone()) {
             Entry::Vacant(e) => {
@@ -2128,7 +2128,7 @@ mod test_default_mdd {
             }
         }
 
-        fn transition_cost(&self, _: &char, d: Decision) -> isize {
+        fn transition_cost(&self, _: &char, _: &Self::State, d: Decision) -> isize {
             d.value
         }
     }
@@ -2567,7 +2567,7 @@ mod test_default_mdd {
             }
         }
 
-        fn transition_cost(&self, _: &Self::State, decision: crate::Decision) -> isize {
+        fn transition_cost(&self, _: &Self::State, _: &Self::State, decision: crate::Decision) -> isize {
             decision.value
         }
 
@@ -2608,7 +2608,7 @@ mod test_default_mdd {
             }
         }
 
-        fn transition_cost(&self, _: &Self::State, decision: crate::Decision) -> isize {
+        fn transition_cost(&self, _: &Self::State, _: &Self::State, decision: crate::Decision) -> isize {
             decision.value
         }
 

diff --git a/ddo/src/implementation/mdd/pooled.rs b/ddo/src/implementation/mdd/pooled.rs
@@ -683,7 +683,7 @@ where
     ) {
         let state = get!(node from_id, self).state.as_ref();
         let next_state = Arc::new(problem.transition(state, decision));
-        let cost = problem.transition_cost(state, decision);
+        let cost = problem.transition_cost(state, next_state.as_ref(), decision);
 
         match self.pool.entry(next_state.clone()) {
             Entry::Vacant(e) => {
@@ -2045,7 +2045,7 @@ mod test_default_mdd {
             }
         }
 
-        fn transition_cost(&self, _: &char, d: Decision) -> isize {
+        fn transition_cost(&self, _: &char, _: &Self::State, d: Decision) -> isize {
             d.value
         }
     }
@@ -2423,7 +2423,7 @@ mod test_default_mdd {
             }
         }
 
-        fn transition_cost(&self, _: &Self::State, decision: crate::Decision) -> isize {
+        fn transition_cost(&self, _: &Self::State, _: &Self::State, decision: crate::Decision) -> isize {
             decision.value
         }
 
@@ -2464,7 +2464,7 @@ mod test_default_mdd {
             }
         }
 
-        fn transition_cost(&self, _: &Self::State, decision: crate::Decision) -> isize {
+        fn transition_cost(&self, _: &Self::State, _: &Self::State, decision: crate::Decision) -> isize {
             decision.value
         }
 

diff --git a/ddo/src/implementation/solver/parallel.rs b/ddo/src/implementation/solver/parallel.rs
@@ -166,7 +166,7 @@ enum WorkLoad<T> {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -1281,7 +1281,7 @@ mod test_solver {
             }
             ret
         }
-        fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+        fn transition_cost(&self, _state: &Self::State, _: &Self::State, dec: Decision) -> isize {
             self.profit[dec.variable.id()] as isize * dec.value
         }
         fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {

diff --git a/ddo/src/implementation/solver/sequential.rs b/ddo/src/implementation/solver/sequential.rs
@@ -81,7 +81,7 @@ enum WorkLoad<T> {
 /// #         }
 /// #         ret
 /// #     }
-/// #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+/// #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 /// #         self.profit[dec.variable.id()] as isize * dec.value
 /// #     }
 /// #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -1035,7 +1035,7 @@ mod test_solver {
             }
             ret
         }
-        fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+        fn transition_cost(&self, _state: &Self::State, _: &Self::State, dec: Decision) -> isize {
             self.profit[dec.variable.id()] as isize * dec.value
         }
         fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {

diff --git a/ddo/src/lib.rs b/ddo/src/lib.rs
@@ -145,7 +145,7 @@
 //!     // This method is analogous to the transition function. But instead to returning
 //!     // the next state when a decision is made, it returns the "cost", that is the 
 //!     // impact of making that decision on the objective function.
-//!     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+//!     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 //!         self.profit[dec.variable.id()] as isize * dec.value
 //!     }
 //!     // This method is used to determine the order in which the variables will be branched
@@ -225,7 +225,7 @@
 //! #         }
 //! #         ret
 //! #     }
-//! #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+//! #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 //! #         self.profit[dec.variable.id()] as isize * dec.value
 //! #     }
 //! #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {
@@ -349,7 +349,7 @@
 //! #         }
 //! #         ret
 //! #     }
-//! #     fn transition_cost(&self, _state: &Self::State, dec: Decision) -> isize {
+//! #     fn transition_cost(&self, _state: &Self::State, _next: &Self::State, dec: Decision) -> isize {
 //! #         self.profit[dec.variable.id()] as isize * dec.value
 //! #     }
 //! #     fn next_variable(&self, depth: usize, _: &mut dyn Iterator<Item = &Self::State>) -> Option<Variable> {