improve route-level search

jsprit-core/src/main/java/algorithms/ActivityInsertionCostsCalculator.java

@@ -22,13 +22,13 @@ package algorithms;
 
 import basics.route.TourActivity;
 
-interface MarginalsCalculus {
+interface ActivityInsertionCostsCalculator {
 	
-	class Marginals {
+	class ActivityInsertionCosts {
 		
 		private double additionalCosts;
 		private double additionalTime;
-		public Marginals(double additionalCosts, double additionalTime) {
+		public ActivityInsertionCosts(double additionalCosts, double additionalTime) {
 			super();
 			this.additionalCosts = additionalCosts;
 			this.additionalTime = additionalTime;
@@ -50,6 +50,6 @@ interface MarginalsCalculus {
 
 	}
 	
-	Marginals calculate(InsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct);
+	ActivityInsertionCosts calculate(InsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct);
 
 }

jsprit-core/src/main/java/algorithms/CalculatesServiceInsertion.java

@@ -15,18 +15,17 @@ package algorithms;
 import org.apache.log4j.Logger;
 
 import util.Neighborhood;
+import algorithms.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
 import algorithms.HardConstraints.HardRouteLevelConstraint;
-import algorithms.MarginalsCalculus.Marginals;
 import basics.Job;
 import basics.Service;
 import basics.costs.VehicleRoutingTransportCosts;
+import basics.route.DefaultTourActivityFactory;
 import basics.route.Driver;
 import basics.route.End;
-import basics.route.ServiceActivity;
 import basics.route.Start;
 import basics.route.TourActivity;
 import basics.route.TourActivityFactory;
-import basics.route.DefaultTourActivityFactory;
 import basics.route.Vehicle;
 import basics.route.VehicleImpl.NoVehicle;
 import basics.route.VehicleRoute;
@@ -47,7 +46,7 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		}
 	};
 	
-	private MarginalsCalculus marginalCalculus;
+	private ActivityInsertionCostsCalculator activityInsertionCostsCalculator;
 	
 	private VehicleRoutingTransportCosts transportCosts;
 	
@@ -58,9 +57,9 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		logger.info("initialise neighborhood " + neighborhood);
 	}
 	
-	public CalculatesServiceInsertion(VehicleRoutingTransportCosts routingCosts, MarginalsCalculus marginalsCalculus, HardRouteLevelConstraint hardRouteLevelConstraint) {
+	public CalculatesServiceInsertion(VehicleRoutingTransportCosts routingCosts, ActivityInsertionCostsCalculator activityInsertionCostsCalculator, HardRouteLevelConstraint hardRouteLevelConstraint) {
 		super();
-		this.marginalCalculus = marginalsCalculus;
+		this.activityInsertionCostsCalculator = activityInsertionCostsCalculator;
 		this.hardRouteLevelConstraint = hardRouteLevelConstraint;
 		this.transportCosts = routingCosts;
 		activityFactory = new DefaultTourActivityFactory();
@@ -88,7 +87,7 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		}
 		
 		double bestCost = bestKnownCosts;
-		Marginals bestMarginals = null;
+		ActivityInsertionCosts bestMarginals = null;
 		Service service = (Service)jobToInsert;
 		int insertionIndex = InsertionData.NO_INDEX;
 		
@@ -102,11 +101,10 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		TourActivity prevAct = start;
 		double prevActStartTime = newVehicleDepartureTime;
 		int actIndex = 0;
-//		logger.info("start");
+
 		for(TourActivity nextAct : currentRoute.getTourActivities().getActivities()){
-//			logger.info("prevActStartTime="+prevActStartTime);
 			if(neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), nextAct.getLocationId())){
-				Marginals mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
+				ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
 				if(mc != null){ 
 					if(mc.getAdditionalCosts() < bestCost){
 						bestCost = mc.getAdditionalCosts();
@@ -115,7 +113,6 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 					}
 				}
 			}
-
 			double nextActArrTime = prevActStartTime + transportCosts.getTransportTime(prevAct.getLocationId(), nextAct.getLocationId(), prevActStartTime, newDriver, newVehicle);
 			double nextActEndTime = CalcUtils.getActivityEndTime(nextActArrTime, nextAct);
 			
@@ -124,10 +121,9 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 			prevAct = nextAct;
 			actIndex++;
 		}
-//		logger.info("prevActStartTime="+prevActStartTime);
 		End nextAct = end;
 		if(neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(deliveryAct2Insert.getLocationId(), nextAct.getLocationId())){
-			Marginals mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
+			ActivityInsertionCosts mc = calculate(insertionContext, prevAct, nextAct, deliveryAct2Insert, prevActStartTime);
 			if(mc != null) {
 				if(mc.getAdditionalCosts() < bestCost){
 					bestCost = mc.getAdditionalCosts();
@@ -146,8 +142,8 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		return insertionData;
 	}
 
-	public Marginals calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double departureTimeAtPrevAct) {	
+	public ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double departureTimeAtPrevAct) {	
-		return marginalCalculus.calculate(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct);
+		return activityInsertionCostsCalculator.calculate(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct);
 		
 	}
 }

jsprit-core/src/main/java/algorithms/CalculatesServiceInsertionOnRouteLevel.java

@@ -23,6 +23,7 @@ import java.util.PriorityQueue;
 import org.apache.log4j.Logger;
 
 import util.Neighborhood;
+import algorithms.HardConstraints.HardRouteLevelConstraint;
 import basics.Job;
 import basics.Service;
 import basics.costs.VehicleRoutingActivityCosts;
@@ -30,7 +31,6 @@ import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.DefaultTourActivityFactory;
 import basics.route.Driver;
 import basics.route.End;
-import basics.route.ServiceActivity;
 import basics.route.Start;
 import basics.route.TourActivities;
 import basics.route.TourActivity;
@@ -53,7 +53,11 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 	
 	private TourActivityFactory tourActivityFactory = new DefaultTourActivityFactory();
 	
-	private StateManager states;
+	private StateManager stateManager;
+	
+	private HardRouteLevelConstraint hardRouteLevelConstraint;
+	
+	private ActivityInsertionCostsCalculator activityInsertionCostsCalculator;
 	
 	private int nuOfActsForwardLooking = 0;
 	
@@ -86,17 +90,18 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		logger.info("set [solutionMemory="+memorySize+"]");
 	}
 
-	public CalculatesServiceInsertionOnRouteLevel(VehicleRoutingTransportCosts vehicleRoutingCosts, VehicleRoutingActivityCosts costFunc) {
+	public CalculatesServiceInsertionOnRouteLevel(VehicleRoutingTransportCosts vehicleRoutingCosts, VehicleRoutingActivityCosts costFunc, HardRouteLevelConstraint hardRouteLevelConstraint) {
 			super();
 			this.transportCosts = vehicleRoutingCosts;
 			this.activityCosts = costFunc;
+			this.hardRouteLevelConstraint = hardRouteLevelConstraint;
 			auxilliaryPathCostCalculator = new AuxilliaryCostCalculator(transportCosts, activityCosts);
 			logger.info("initialise " + this);
 		}
 
 
-	public void setStates(StateManager activityStates2){
+	public void setStates(StateManager stateManager){
-		this.states = activityStates2;
+		this.stateManager = stateManager;
 	}
 	
 	void setNuOfActsForwardLooking(int nOfActsForwardLooking) {
@@ -122,6 +127,11 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		if(jobToInsert == null) throw new IllegalStateException("job is null. cannot calculate the insertion of a null-job.");
 		if(newVehicle == null || newVehicle instanceof NoVehicle) throw new IllegalStateException("no vehicle given. set para vehicle!");
 		
+		InsertionContext insertionContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, newVehicleDepartureTime);
+		if(!hardRouteLevelConstraint.fulfilled(insertionContext)){
+			return InsertionData.noInsertionFound();
+		}
+		
 		/**
 		 * map that memorizes the costs with newVehicle, which is a cost-snapshot at tour-activities. 
 		 */
@@ -136,13 +146,6 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		double best_insertion_costs = best_known_insertion_costs;
 		Service service = (Service)jobToInsert;
 		
-		/**
-		 * pre-check whether vehicle-capacity of new vehicle is sufficient to load service.
-		 */
-		if(states.getRouteState(currentRoute, StateTypes.LOAD).toDouble() + service.getCapacityDemand() > newVehicle.getCapacity()){
-			return InsertionData.noInsertionFound();
-		}
-		
 		/**
 		 * some inis
 		 */
@@ -167,6 +170,9 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 				/**
 				 * builds a path on this route forwardPath={i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking}
 				 */
+				
+				//---------------------------
+				//ActivityInsertionCostsEstimator
 				List<TourActivity> path = new ArrayList<TourActivity>();
 				path.add(prevAct); path.add(serviceAct2Insert); path.add(nextAct);
 				if(nuOfActsForwardLooking > 0){ path.addAll(getForwardLookingPath(currentRoute,actIndex)); }
@@ -175,7 +181,8 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 				 * calculates the path costs with new vehicle, c(forwardPath,newVehicle).
 				 */
 				double forwardPathCost_newVehicle = auxilliaryPathCostCalculator.costOfPath(path, prevActDepTime_newVehicle, newDriver, newVehicle); 
-
+				//---------------------------
+				
 				/**
 				 * insertion_cost_approximation = c({0,1,...,i},newVehicle) + c({i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking},newVehicle) - c({0,1,...,i,j,j+1,...,j+nuOfActsForwardLooking},oldVehicle)
 				 */
@@ -220,12 +227,15 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		End nextAct = end;
 		if(neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), nextAct.getLocationId())){
 
+			//----------------------------
+			//ActivityInsertionCostsEstimator
 			/**
 			 * calculates the path costs with new vehicle, c(forwardPath,newVehicle).
 			 */
 			List<TourActivity> path = Arrays.asList(prevAct,serviceAct2Insert,end);
 			double forwardPathCost_newVehicle = auxilliaryPathCostCalculator.costOfPath(path, prevActDepTime_newVehicle, newDriver, newVehicle);
-
+			//----------------------------
+			
 			/**
 			 * insertion_cost_approximation = c({0,1,...,i},newVehicle) + c({i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking},newVehicle) - c({0,1,...,i,j,j+1,...,j+nuOfActsForwardLooking},oldVehicle)
 			 */
@@ -271,7 +281,7 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 			/**
 			 * compute cost-diff of tour with and without new activity --> insertion_costs
 			 */
-			double insertion_costs = auxilliaryPathCostCalculator.costOfPath(wholeTour, start.getEndTime(), newDriver, newVehicle) - states.getRouteState(currentRoute,StateTypes.COSTS).toDouble();
+			double insertion_costs = auxilliaryPathCostCalculator.costOfPath(wholeTour, start.getEndTime(), newDriver, newVehicle) - stateManager.getRouteState(currentRoute,StateTypes.COSTS).toDouble();
 			
 			/**
 			 * if better than best known, make it the best known
@@ -316,9 +326,9 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 	private double pathCost_oldVehicle(VehicleRoute vehicleRoute, List<TourActivity> path) {
 		TourActivity act = path.get(path.size()-1);
 		if(act instanceof End){
-			return states.getRouteState(vehicleRoute,StateTypes.COSTS).toDouble();
+			return stateManager.getRouteState(vehicleRoute,StateTypes.COSTS).toDouble();
 		}
-		return states.getActivityState(act,StateTypes.COSTS).toDouble();
+		return stateManager.getActivityState(act,StateTypes.COSTS).toDouble();
 	}
 
 	/**

jsprit-core/src/main/java/algorithms/CalculatorBuilder.java

@@ -219,7 +219,7 @@ class CalculatorBuilder {
 	private CalculatorPlusListeners createStandardLocal(VehicleRoutingProblem vrp, StateManager statesManager){
 		if(constraintManager == null) throw new IllegalStateException("constraint-manager is null");
  		
-		MarginalsCalculus defaultCalc = new MarginalsCalculusTriangleInequality(vrp.getTransportCosts(), vrp.getActivityCosts(), constraintManager);
+		ActivityInsertionCostsCalculator defaultCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), constraintManager);
 		JobInsertionCalculator standardServiceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), defaultCalc, constraintManager);
 		
 		((CalculatesServiceInsertion) standardServiceInsertion).setNeighborhood(vrp.getNeighborhood());
@@ -238,7 +238,7 @@ class CalculatorBuilder {
 
 	private CalculatorPlusListeners createStandardRoute(VehicleRoutingProblem vrp, StateManager activityStates2, int forwardLooking, int solutionMemory){
 		int after = forwardLooking;
-		JobInsertionCalculator jobInsertionCalculator = new CalculatesServiceInsertionOnRouteLevel(vrp.getTransportCosts(), vrp.getActivityCosts());
+		JobInsertionCalculator jobInsertionCalculator = new CalculatesServiceInsertionOnRouteLevel(vrp.getTransportCosts(), vrp.getActivityCosts(), hardRouteLevelConstraint);
 		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setNuOfActsForwardLooking(after);
 		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setMemorySize(solutionMemory);
 		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setNeighborhood(vrp.getNeighborhood());

jsprit-core/src/main/java/algorithms/LocalActivityInsertionCostsCalculator.java

@@ -25,14 +25,14 @@ import basics.costs.VehicleRoutingActivityCosts;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.TourActivity;
 
-class MarginalsCalculusTriangleInequality implements MarginalsCalculus{
+class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCalculator{
 
 	private HardActivityLevelConstraint hardConstraint;
 
 	private VehicleRoutingTransportCosts routingCosts;
 	private VehicleRoutingActivityCosts activityCosts;
 	
-	public MarginalsCalculusTriangleInequality(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, HardActivityLevelConstraint hardActivityLevelConstraint) {
+	public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, HardActivityLevelConstraint hardActivityLevelConstraint) {
 		super();
 		this.routingCosts = routingCosts;
 		this.activityCosts = actCosts;
@@ -40,7 +40,7 @@ class MarginalsCalculusTriangleInequality implements MarginalsCalculus{
 	}
 
 	@Override
-	public Marginals calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) {
+	public ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) {
 		if(!hardConstraint.fulfilled(iFacts, prevAct, newAct, nextAct, depTimeAtPrevAct)){
 			return null;
 		}
@@ -81,7 +81,7 @@ class MarginalsCalculusTriangleInequality implements MarginalsCalculus{
 		double additionalCosts = totalCosts - oldCosts;
 		double additionalTime = (nextAct_arrTime - iFacts.getNewDepTime()) - oldTime;
 
-		return new Marginals(additionalCosts,additionalTime);
+		return new ActivityInsertionCosts(additionalCosts,additionalTime);
 	}
 
 }

jsprit-core/src/main/java/algorithms/RouteLevelActivityInsertionCostsEstimator.java

@@ -0,0 +1,142 @@
+/*******************************************************************************
+ * Copyright (C) 2013  Stefan Schroeder
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ * 
+ * Contributors:
+ *     Stefan Schroeder - initial API and implementation
+ ******************************************************************************/
+package algorithms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import algorithms.HardConstraints.HardActivityLevelConstraint;
+import basics.costs.VehicleRoutingActivityCosts;
+import basics.costs.VehicleRoutingTransportCosts;
+import basics.route.End;
+import basics.route.Start;
+import basics.route.TourActivity;
+import basics.route.VehicleRoute;
+
+class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCostsCalculator{
+
+	private HardActivityLevelConstraint hardConstraint;
+
+	private VehicleRoutingTransportCosts routingCosts;
+	
+	private VehicleRoutingActivityCosts activityCosts;
+	
+	private AuxilliaryCostCalculator auxilliaryPathCostCalculator;
+	
+	private StateManager stateManager;
+	
+	private int nuOfActivities2LookForward = 0;
+	
+	public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, HardActivityLevelConstraint hardActivityLevelConstraint, StateManager stateManager) {
+		super();
+		this.routingCosts = routingCosts;
+		this.activityCosts = actCosts;
+		this.hardConstraint = hardActivityLevelConstraint;
+		auxilliaryPathCostCalculator = new AuxilliaryCostCalculator(routingCosts, activityCosts);
+	}
+
+	@Override
+	public ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) {
+		if(!hardConstraint.fulfilled(iFacts, prevAct, newAct, nextAct, depTimeAtPrevAct)){
+			return null;
+		}
+		
+		List<TourActivity> path = new ArrayList<TourActivity>();
+		path.add(prevAct); path.add(newAct); path.add(nextAct);
+		int actIndex;
+		if(prevAct instanceof Start) actIndex = 0;
+		else actIndex = iFacts.getRoute().getTourActivities().getActivities().indexOf(prevAct);
+		if(nuOfActivities2LookForward > 0){ path.addAll(getForwardLookingPath(iFacts.getRoute(),actIndex)); }
+
+		/**
+		 * calculates the path costs with new vehicle, c(forwardPath,newVehicle).
+		 */
+		double forwardPathCost_newVehicle = auxilliaryPathCostCalculator.costOfPath(path, depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); 
+
+		double additionalCosts = forwardPathCost_newVehicle - (actCostsOld(iFacts.getRoute(), path.get(path.size()-1)) - actCostsOld(iFacts.getRoute(), prevAct));
+		
+		return new ActivityInsertionCosts(additionalCosts, 0.0);
+		
+		
+//		
+//		
+//		double tp_costs_prevAct_newAct = routingCosts.getTransportCost(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
+//		double tp_time_prevAct_newAct = routingCosts.getTransportTime(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
+//		
+//		double newAct_arrTime = depTimeAtPrevAct + tp_time_prevAct_newAct;
+//		
+//		double newAct_endTime = CalcUtils.getActivityEndTime(newAct_arrTime, newAct);
+//		
+//		double act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
+//		
+//		double tp_costs_newAct_nextAct = routingCosts.getTransportCost(newAct.getLocationId(), nextAct.getLocationId(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
+//		double tp_time_newAct_nextAct = routingCosts.getTransportTime(newAct.getLocationId(), nextAct.getLocationId(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
+//		
+//		double nextAct_arrTime = newAct_endTime + tp_time_newAct_nextAct;
+//				
+//		double act_costs_nextAct = activityCosts.getActivityCost(nextAct, nextAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle());
+//		
+//		double totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + act_costs_newAct + act_costs_nextAct; 
+//		
+//		double oldCosts;
+//		double oldTime;
+//		if(iFacts.getRoute().isEmpty()){
+//			oldCosts = 0.0;
+//			oldTime = 0.0;
+//		}
+//		else{
+//			double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocationId(), nextAct.getLocationId(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle());
+//			double arrTime_nextAct = routingCosts.getTransportTime(prevAct.getLocationId(), nextAct.getLocationId(), prevAct.getEndTime(), iFacts.getNewDriver(), iFacts.getNewVehicle());
+//			
+//			double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle());
+//			oldCosts = tp_costs_prevAct_nextAct + actCost_nextAct;
+//			oldTime = (nextAct.getArrTime() - iFacts.getRoute().getDepartureTime());
+//		}
+//		
+//		double additionalCosts = totalCosts - oldCosts;
+//		double additionalTime = (nextAct_arrTime - iFacts.getNewDepTime()) - oldTime;
+//
+//		return new ActivityInsertionCosts(additionalCosts,additionalTime);
+	}
+	
+	private double actCostsOld(VehicleRoute vehicleRoute, TourActivity act) {
+		if(act instanceof End){
+			return stateManager.getRouteState(vehicleRoute,StateTypes.COSTS).toDouble();
+		}
+		return stateManager.getActivityState(act,StateTypes.COSTS).toDouble();
+	}
+	
+	private List<TourActivity> getForwardLookingPath(VehicleRoute route, int actIndex) {
+		List<TourActivity> forwardLookingPath = new ArrayList<TourActivity>();
+		int nuOfActsInPath = 0;
+		int index = actIndex + 1;
+		while(index < route.getTourActivities().getActivities().size() && nuOfActsInPath < nuOfActivities2LookForward){
+			forwardLookingPath.add(route.getTourActivities().getActivities().get(index));
+			index++;
+			nuOfActsInPath++;
+		}
+		if(nuOfActsInPath < nuOfActivities2LookForward){
+			forwardLookingPath.add(route.getEnd());
+		}
+		return forwardLookingPath;
+	}
+
+}

jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java

@@ -64,7 +64,7 @@ public class BuildCVRPAlgoFromScratchTest {
 				return true;
 			}
 		};
-		MarginalsCalculus marginalCalculus = new MarginalsCalculusTriangleInequality(vrp.getTransportCosts(), vrp.getActivityCosts(), hardActLevelConstraint);
+		ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), hardActLevelConstraint);
 		CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardConstraints.HardLoadConstraint(stateManager));
 		
 		VehicleFleetManager fleetManager = new InfiniteVehicles(vrp.getVehicles());

jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java

@@ -79,7 +79,7 @@ public class BuildPDVRPAlgoFromScratchTest {
 			actLevelConstraintAccumulator.addConstraint(new HardConstraints.HardPickupAndDeliveryActivityLevelConstraint(stateManager));
 			actLevelConstraintAccumulator.addConstraint(new HardConstraints.HardTimeWindowActivityLevelConstraint(stateManager, vrp.getTransportCosts()));
 			
-			MarginalsCalculus marginalCalculus = new MarginalsCalculusTriangleInequality(vrp.getTransportCosts(), vrp.getActivityCosts(), actLevelConstraintAccumulator);
+			ActivityInsertionCostsCalculator marginalCalculus = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), actLevelConstraintAccumulator);
 
 			CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardConstraints.HardPickupAndDeliveryLoadConstraint(stateManager));
 //			CalculatesServiceInsertion serviceInsertion = new CalculatesServiceInsertion(vrp.getTransportCosts(), marginalCalculus, new HardConstraints.HardLoadConstraint(stateManager));

jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java

@@ -152,7 +152,7 @@ public class GendreauPostOptTest {
 		
 		activityCosts = new ExampleActivityCostFunction();
 		
-		CalculatesServiceInsertion standardServiceInsertion = new CalculatesServiceInsertion(cost, new MarginalsCalculusTriangleInequality(cost, activityCosts, new HardConstraints.HardTimeWindowActivityLevelConstraint(states, cost)), new HardConstraints.HardLoadConstraint(states));
+		CalculatesServiceInsertion standardServiceInsertion = new CalculatesServiceInsertion(cost, new LocalActivityInsertionCostsCalculator(cost, activityCosts, new HardConstraints.HardTimeWindowActivityLevelConstraint(states, cost)), new HardConstraints.HardLoadConstraint(states));
 		
 		CalculatesServiceInsertionConsideringFixCost withFixCost = new CalculatesServiceInsertionConsideringFixCost(standardServiceInsertion, states);
 		withFixCost.setWeightOfFixCost(1.2);

jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java

@@ -157,7 +157,7 @@ public class TestCalculatesServiceInsertion {
 		
 		ExampleActivityCostFunction activityCosts = new ExampleActivityCostFunction();
 
-		serviceInsertion = new CalculatesServiceInsertion(costs, new MarginalsCalculusTriangleInequality(costs, activityCosts, new HardConstraints.HardTimeWindowActivityLevelConstraint(states, costs)), new HardConstraints.HardLoadConstraint(states));
+		serviceInsertion = new CalculatesServiceInsertion(costs, new LocalActivityInsertionCostsCalculator(costs, activityCosts, new HardConstraints.HardTimeWindowActivityLevelConstraint(states, costs)), new HardConstraints.HardLoadConstraint(states));
 		
 		stateUpdater = new UpdateStates(states, costs, activityCosts);
 		

jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java

@@ -147,7 +147,7 @@ public class TestCalculatesServiceInsertionOnRouteLevel {
 		states = new StateManagerImpl();
 		
 		ExampleActivityCostFunction activityCosts = new ExampleActivityCostFunction();
-		serviceInsertion = new CalculatesServiceInsertionOnRouteLevel(costs,activityCosts);
+		serviceInsertion = new CalculatesServiceInsertionOnRouteLevel(costs,activityCosts, hardRouteLevelConstraint);
 		serviceInsertion.setNuOfActsForwardLooking(4);
 		serviceInsertion.setStates(states);