Merge branch 'ImproveRouteLevelSearch'

Conflicts:
	jsprit-core/src/main/java/algorithms/MarginalsCalculus.java
	jsprit-core/src/main/java/algorithms/MarginalsCalculusTriangleInequality.java

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

@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * 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 basics.route.TourActivity;
+
+interface ActivityInsertionCostsCalculator {
+	
+	class ActivityInsertionCosts {
+		
+		private double additionalCosts;
+		private double additionalTime;
+		public ActivityInsertionCosts(double additionalCosts, double additionalTime) {
+			super();
+			this.additionalCosts = additionalCosts;
+			this.additionalTime = additionalTime;
+		}
+		/**
+		 * @return the additionalCosts
+		 */
+		public double getAdditionalCosts() {
+			return additionalCosts;
+		}
+		/**
+		 * @return the additionalTime
+		 */
+		public double getAdditionalTime() {
+			return additionalTime;
+		}
+		
+		
+
+	}
+	
+	ActivityInsertionCosts calculate(InsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct);
+
+}

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

@@ -17,9 +17,7 @@
 package algorithms;
 
 import basics.costs.ForwardTransportTime;
-import basics.route.Driver;
 import basics.route.TourActivity;
-import basics.route.Vehicle;
 import basics.route.VehicleRoute;
 
 class ActivityTimeTracker implements ActivityVisitor{

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

@@ -16,26 +16,6 @@
  ******************************************************************************/
 package algorithms;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CompletionService;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorCompletionService;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-
-import org.apache.log4j.Logger;
-
-import util.RandomNumberGeneration;
-import algorithms.InsertionData.NoInsertionFound;
-import basics.Job;
-import basics.algo.InsertionListener;
-import basics.route.VehicleRoute;
 
 //
 //

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

@@ -19,18 +19,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;
@@ -51,7 +50,7 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		}
 	};
 	
-	private MarginalsCalculus marginalCalculus;
+	private ActivityInsertionCostsCalculator activityInsertionCostsCalculator;
 	
 	private VehicleRoutingTransportCosts transportCosts;
 	
@@ -62,9 +61,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();
@@ -92,7 +91,7 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 		}
 		
 		double bestCost = bestKnownCosts;
-		Marginals bestMarginals = null;
+		ActivityInsertionCosts bestMarginals = null;
 		Service service = (Service)jobToInsert;
 		int insertionIndex = InsertionData.NO_INDEX;
 		
@@ -106,11 +105,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();
@@ -119,7 +117,6 @@ final class CalculatesServiceInsertion implements JobInsertionCalculator{
 					}
 				}
 			}
-
 			double nextActArrTime = prevActStartTime + transportCosts.getTransportTime(prevAct.getLocationId(), nextAct.getLocationId(), prevActStartTime, newDriver, newVehicle);
 			double nextActEndTime = CalcUtils.getActivityEndTime(nextActArrTime, nextAct);
 			
@@ -128,10 +125,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();
@@ -150,8 +146,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/CalculatesServiceInsertionConsideringFixCost.java

@@ -19,8 +19,6 @@ package algorithms;
 import org.apache.log4j.Logger;
 
 import algorithms.InsertionData.NoInsertionFound;
-import algorithms.StateManager.State;
-import algorithms.StateManager.States;
 import basics.Job;
 import basics.route.Driver;
 import basics.route.Vehicle;

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

@@ -17,7 +17,6 @@
 package algorithms;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
@@ -27,6 +26,8 @@ import java.util.PriorityQueue;
 import org.apache.log4j.Logger;
 
 import util.Neighborhood;
+import algorithms.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
+import algorithms.HardConstraints.HardRouteLevelConstraint;
 import basics.Job;
 import basics.Service;
 import basics.costs.VehicleRoutingActivityCosts;
@@ -34,7 +35,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;
@@ -57,7 +57,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;
 	
@@ -90,17 +94,19 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		logger.info("set [solutionMemory="+memorySize+"]");
 	}
 
-	public CalculatesServiceInsertionOnRouteLevel(VehicleRoutingTransportCosts vehicleRoutingCosts, VehicleRoutingActivityCosts costFunc) {
+	public CalculatesServiceInsertionOnRouteLevel(VehicleRoutingTransportCosts vehicleRoutingCosts, VehicleRoutingActivityCosts costFunc, HardRouteLevelConstraint hardRouteLevelConstraint, ActivityInsertionCostsCalculator activityInsertionCostsCalculator) {
 			super();
 			this.transportCosts = vehicleRoutingCosts;
 			this.activityCosts = costFunc;
+			this.hardRouteLevelConstraint = hardRouteLevelConstraint;
+			this.activityInsertionCostsCalculator = activityInsertionCostsCalculator;
 			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) {
@@ -126,6 +132,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. 
 		 */
@@ -140,13 +151,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
 		 */
@@ -171,19 +175,13 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 				/**
 				 * builds a path on this route forwardPath={i,k,j,j+1,j+2,...,j+nuOfActsForwardLooking}
 				 */		
-				List<TourActivity> path = new ArrayList<TourActivity>();
+				InsertionContext iContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, prevActDepTime_newVehicle);
-				path.add(prevAct); path.add(serviceAct2Insert); path.add(nextAct);
+				ActivityInsertionCosts actInsertionCosts = activityInsertionCostsCalculator.calculate(iContext, prevAct, nextAct, serviceAct2Insert, prevActDepTime_newVehicle);
-				if(nuOfActsForwardLooking > 0){ path.addAll(getForwardLookingPath(currentRoute,actIndex)); }
+				if(actInsertionCosts != null){
-
-				/**
-				 * 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)
 					 */
-				double insertion_cost_approximation = sumOf_prevCosts_newVehicle + forwardPathCost_newVehicle - pathCost_oldVehicle(currentRoute,path); 
+					double insertion_cost_approximation = sumOf_prevCosts_newVehicle - sumOf_prevCosts_oldVehicle(currentRoute,prevAct) + actInsertionCosts.getAdditionalCosts(); 
 
 					/**
 					 * memorize it in insertion-queue
@@ -191,7 +189,7 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 					if(insertion_cost_approximation < best_known_insertion_costs){
 						bestInsertionsQueue.add(new InsertionData(insertion_cost_approximation, InsertionData.NO_INDEX, actIndex, newVehicle, newDriver));
 					}
-				
+				}
 			}
 
 			/**
@@ -224,22 +222,20 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		End nextAct = end;
 		if(neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), prevAct.getLocationId()) && neighborhood.areNeighbors(serviceAct2Insert.getLocationId(), nextAct.getLocationId())){
 
-			/**
+			InsertionContext iContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, prevActDepTime_newVehicle);
-			 * calculates the path costs with new vehicle, c(forwardPath,newVehicle).
+			ActivityInsertionCosts actInsertionCosts = activityInsertionCostsCalculator.calculate(iContext, prevAct, nextAct, serviceAct2Insert, prevActDepTime_newVehicle);
-			 */
+			if(actInsertionCosts != null){
-			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)
 				 */
-			double insertion_cost_approximation = sumOf_prevCosts_newVehicle + forwardPathCost_newVehicle - pathCost_oldVehicle(currentRoute,path);
+				double insertion_cost_approximation = sumOf_prevCosts_newVehicle - sumOf_prevCosts_oldVehicle(currentRoute,prevAct) + actInsertionCosts.getAdditionalCosts(); 
 
 				/**
 				 * memorize it in insertion-queue
 				 */
 				if(insertion_cost_approximation < best_known_insertion_costs){
-				bestInsertionsQueue.add(new InsertionData(insertion_cost_approximation,InsertionData.NO_INDEX, actIndex, newVehicle, newDriver));
+					bestInsertionsQueue.add(new InsertionData(insertion_cost_approximation, InsertionData.NO_INDEX, actIndex, newVehicle, newDriver));
+				}
 			}
 		}
 
@@ -250,14 +246,14 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		 *  
 		 */
 		
-		if(memorySize==0){
+		if(memorySize==0){ // return bestInsertion
 			InsertionData insertion = bestInsertionsQueue.poll();
 			if(insertion != null){
 				best_insertion_index = insertion.getDeliveryInsertionIndex();
 				best_insertion_costs = insertion.getInsertionCost();
 			}
 		}
-		
+		else{
 			for(int i=0;i<memorySize;i++){
 				InsertionData data = bestInsertionsQueue.poll();
 				if(data == null){
@@ -275,7 +271,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
@@ -285,6 +281,7 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 					best_insertion_costs = insertion_costs;
 				}
 			}
+		}
 		if(best_insertion_index == InsertionData.NO_INDEX) return InsertionData.noInsertionFound();
 		return new InsertionData(best_insertion_costs, InsertionData.NO_INDEX, best_insertion_index, newVehicle, newDriver);
 	}
@@ -317,34 +314,11 @@ final class CalculatesServiceInsertionOnRouteLevel implements JobInsertionCalcul
 		}
 	}
 
-	private double pathCost_oldVehicle(VehicleRoute vehicleRoute, List<TourActivity> path) {
+	private double sumOf_prevCosts_oldVehicle(VehicleRoute vehicleRoute, TourActivity act) {
-		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();
-	}
-
-	/**
-	 * returns the path or the partial route r_partial = {j+1,j+2,...,j+nuOfActsForwardLooking}
-	 * 
-	 * @param route
-	 * @param actIndex
-	 * @return
-	 */
-	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 < nuOfActsForwardLooking){
-			forwardLookingPath.add(route.getTourActivities().getActivities().get(index));
-			index++;
-			nuOfActsInPath++;
-		}
-		if(nuOfActsInPath < nuOfActsForwardLooking){
-			forwardLookingPath.add(route.getEnd());
-		}
-		return forwardLookingPath;
 	}
 
 	/**

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

@@ -22,7 +22,6 @@ import java.util.Collection;
 import org.apache.log4j.Logger;
 
 import algorithms.InsertionData.NoInsertionFound;
-import algorithms.VehicleFleetManager.TypeKey;
 import basics.Job;
 import basics.route.Driver;
 import basics.route.Vehicle;

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

@@ -215,7 +215,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());
@@ -234,7 +234,8 @@ class CalculatorBuilder {
 
 	private CalculatorPlusListeners createStandardRoute(VehicleRoutingProblem vrp, StateManager activityStates2, int forwardLooking, int solutionMemory){
 		int after = forwardLooking;
-		JobInsertionCalculator jobInsertionCalculator = new CalculatesServiceInsertionOnRouteLevel(vrp.getTransportCosts(), vrp.getActivityCosts());
+		ActivityInsertionCostsCalculator routeLevelCostEstimator = new RouteLevelActivityInsertionCostsEstimator(vrp.getTransportCosts(), vrp.getActivityCosts(), constraintManager, activityStates2);
+		JobInsertionCalculator jobInsertionCalculator = new CalculatesServiceInsertionOnRouteLevel(vrp.getTransportCosts(), vrp.getActivityCosts(), constraintManager, routeLevelCostEstimator);
 		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setNuOfActsForwardLooking(after);
 		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setMemorySize(solutionMemory);
 		((CalculatesServiceInsertionOnRouteLevel)jobInsertionCalculator).setNeighborhood(vrp.getNeighborhood());

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

@@ -16,14 +16,9 @@
  ******************************************************************************/
 package algorithms;
 
-import java.io.File;
-import java.net.MalformedURLException;
 import java.net.URL;
 
 import util.Resource;
-
-
-
 import basics.VehicleRoutingAlgorithm;
 import basics.VehicleRoutingProblem;
 import basics.io.AlgorithmConfig;

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

@@ -19,9 +19,8 @@ package algorithms;
 import algorithms.InsertionData.NoInsertionFound;
 import basics.Job;
 import basics.Service;
-import basics.route.ServiceActivity;
-import basics.route.TourActivityFactory;
 import basics.route.DefaultTourActivityFactory;
+import basics.route.TourActivityFactory;
 import basics.route.VehicleRoute;
 
 class Inserter {

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

@@ -24,7 +24,6 @@ import org.apache.commons.configuration.HierarchicalConfiguration;
 import org.apache.log4j.Logger;
 
 import algorithms.HardConstraints.ConstraintManager;
-import algorithms.StateUpdates.UpdateStates;
 import basics.VehicleRoutingProblem;
 import basics.algo.InsertionListener;
 import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;

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

@@ -1,18 +1,22 @@
 /*******************************************************************************
  * Copyright (C) 2013  Stefan Schroeder
  * 
- * This library is free software; you can redistribute it and/or
+ * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
+ * modify it under the terms of the GNU General Public License
- * License as published by the Free Software Foundation; either 
+ * as published by the Free Software Foundation; either version 2
- * version 3.0 of the License, or (at your option) any later version.
+ * of the License, or (at your option) any later version.
  * 
- * This library is distributed in the hope that it will be useful,
+ * 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
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * Lesser General Public License for more details.
+ * GNU General Public License for more details.
  * 
- * You should have received a copy of the GNU Lesser General Public 
+ * You should have received a copy of the GNU General Public License
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * 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;
 
@@ -21,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;
@@ -36,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;
 		}
@@ -77,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/MarginalsCalculus.java

@@ -1,51 +0,0 @@
-/*******************************************************************************
- * Copyright (C) 2013  Stefan Schroeder
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either 
- * version 3.0 of the License, or (at your option) any later version.
- * 
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public 
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
- ******************************************************************************/
-package algorithms;
-
-import basics.route.TourActivity;
-
-interface MarginalsCalculus {
-	
-	class Marginals {
-		
-		private double additionalCosts;
-		private double additionalTime;
-		public Marginals(double additionalCosts, double additionalTime) {
-			super();
-			this.additionalCosts = additionalCosts;
-			this.additionalTime = additionalTime;
-		}
-		/**
-		 * @return the additionalCosts
-		 */
-		public double getAdditionalCosts() {
-			return additionalCosts;
-		}
-		/**
-		 * @return the additionalTime
-		 */
-		public double getAdditionalTime() {
-			return additionalTime;
-		}
-		
-		
-
-	}
-	
-	Marginals calculate(InsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct);
-
-}

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

@@ -27,7 +27,6 @@ import util.EuclideanDistanceCalculator;
 import util.Locations;
 import util.NeighborhoodImpl;
 import util.Solutions;
-import algorithms.selectors.SelectBest;
 import basics.VehicleRoutingAlgorithm;
 import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;

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

@@ -19,12 +19,10 @@ package algorithms;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+
 import org.apache.log4j.Logger;
 
-
-import basics.Job;
 import basics.algo.InsertionEndsListener;
-import basics.algo.InsertionStartsListener;
 import basics.route.VehicleRoute;
 
 class RemoveEmptyVehicles implements InsertionEndsListener{

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

@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * 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 VehicleRoutingActivityCosts activityCosts;
+	
+	private AuxilliaryCostCalculator auxilliaryPathCostCalculator;
+	
+	private StateManager stateManager;
+	
+	private int nuOfActivities2LookForward = 0;
+	
+	public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, HardActivityLevelConstraint hardActivityLevelConstraint, StateManager stateManager) {
+		super();
+		this.activityCosts = actCosts;
+		this.hardConstraint = hardActivityLevelConstraint;
+		this.stateManager = stateManager;
+		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);
+		
+	}
+	
+	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/main/java/algorithms/RuinAndRecreateModule.java

@@ -18,7 +18,6 @@ package algorithms;
 
 import java.util.Collection;
 
-import util.RouteUtils;
 import algorithms.RuinStrategy.RuinListener;
 import basics.Job;
 import basics.VehicleRoutingProblemSolution;

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

@@ -16,14 +16,9 @@
  ******************************************************************************/
 package algorithms;
 
-import java.io.File;
-import java.net.MalformedURLException;
 import java.net.URL;
 
 import util.Resource;
-
-
-
 import basics.VehicleRoutingAlgorithm;
 import basics.VehicleRoutingProblem;
 import basics.io.AlgorithmConfig;

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

@@ -18,13 +18,9 @@ package algorithms;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
 
 import org.apache.log4j.Logger;
 
-import algorithms.BackwardInTimeListeners.BackwardInTimeListener;
-import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
 import algorithms.RuinStrategy.RuinListener;
 import algorithms.StateManager.StateImpl;
 import basics.Delivery;
@@ -35,20 +31,15 @@ import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;
 import basics.algo.InsertionEndsListener;
 import basics.algo.InsertionStartsListener;
-import basics.algo.IterationEndsListener;
 import basics.algo.IterationStartsListener;
 import basics.algo.JobInsertedListener;
-import basics.algo.VehicleRoutingAlgorithmListener;
 import basics.costs.ForwardTransportCost;
 import basics.costs.ForwardTransportTime;
 import basics.costs.VehicleRoutingActivityCosts;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.DeliveryActivity;
-import basics.route.Driver;
-import basics.route.End;
 import basics.route.PickupActivity;
 import basics.route.ServiceActivity;
-import basics.route.Start;
 import basics.route.TourActivity;
 import basics.route.Vehicle;
 import basics.route.VehicleRoute;

jsprit-core/src/main/java/algorithms/selectors/SelectRandomly.java

@@ -21,9 +21,8 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Random;
 
-import basics.VehicleRoutingProblemSolution;
-
 import util.RandomNumberGeneration;
+import basics.VehicleRoutingProblemSolution;
 
 
 

jsprit-core/src/main/java/basics/Service.java

@@ -16,8 +16,8 @@
  ******************************************************************************/
 package basics;
 
-import basics.route.TimeWindow;
 import util.Coordinate;
+import basics.route.TimeWindow;
 
 
 public class Service implements Job {

jsprit-core/src/main/java/basics/VehicleRoutingProblem.java

@@ -32,7 +32,6 @@ import basics.costs.DefaultVehicleRoutingActivityCosts;
 import basics.costs.VehicleRoutingActivityCosts;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.Vehicle;
-import basics.route.VehicleImpl;
 import basics.route.VehicleType;
 import basics.route.VehicleTypeImpl;
 

jsprit-core/src/main/java/basics/algo/TimeBreaker.java

@@ -18,9 +18,6 @@ package basics.algo;
 
 import java.util.Collection;
 
-import org.apache.commons.math.stat.StatUtils;
-import org.apache.commons.math.stat.descriptive.moment.Mean;
-import org.apache.commons.math.stat.descriptive.moment.StandardDeviation;
 import org.apache.log4j.Logger;
 
 import basics.VehicleRoutingAlgorithm;

jsprit-core/src/main/java/basics/algo/VariationCoefficientBreaker.java

@@ -19,12 +19,10 @@ package basics.algo;
 import java.util.Collection;
 
 import org.apache.commons.math.stat.StatUtils;
-import org.apache.commons.math.stat.descriptive.moment.Mean;
 import org.apache.commons.math.stat.descriptive.moment.StandardDeviation;
 import org.apache.log4j.Logger;
 
 import util.Solutions;
-
 import basics.VehicleRoutingAlgorithm;
 import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;

jsprit-core/src/main/java/basics/algo/VehicleRoutingAlgorithmListeners.java

@@ -21,7 +21,6 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
-import java.util.PriorityQueue;
 import java.util.TreeSet;
 
 import basics.VehicleRoutingAlgorithm;

jsprit-core/src/main/java/basics/io/VrpXMLReader.java

@@ -42,12 +42,9 @@ import basics.VehicleRoutingProblem.FleetComposition;
 import basics.VehicleRoutingProblem.FleetSize;
 import basics.VehicleRoutingProblemSolution;
 import basics.route.DefaultTourActivityFactory;
-import basics.route.DeliveryActivity;
 import basics.route.Driver;
 import basics.route.DriverImpl;
 import basics.route.End;
-import basics.route.PickupActivity;
-import basics.route.ServiceActivity;
 import basics.route.Start;
 import basics.route.TimeWindow;
 import basics.route.TourActivity;

jsprit-core/src/main/java/basics/io/VrpXMLWriter.java

@@ -33,7 +33,6 @@ import basics.Job;
 import basics.Service;
 import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;
-import basics.route.ServiceActivity;
 import basics.route.TourActivity;
 import basics.route.TourActivity.JobActivity;
 import basics.route.Vehicle;

jsprit-core/src/main/java/util/VehicleRoutingTransportCostsMatrix.java

@@ -21,6 +21,7 @@ import java.util.Map;
 
 import org.apache.log4j.Logger;
 
+import basics.VehicleRoutingProblem;
 import basics.costs.VehicleRoutingTransportCosts;
 import basics.route.Driver;
 import basics.route.Vehicle;

jsprit-core/src/main/java/util/VrpVerifier.java

@@ -17,8 +17,6 @@
 package util;
 
 import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
 
 import org.apache.log4j.Logger;
 

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

@@ -60,7 +60,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

@@ -22,9 +22,6 @@ import org.apache.log4j.Logger;
 import org.junit.Before;
 import org.junit.Test;
 
-import util.Solutions;
-import algorithms.BackwardInTimeListeners.BackwardInTimeListener;
-import algorithms.ForwardInTimeListeners.ForwardInTimeListener;
 import algorithms.HardConstraints.HardActivityLevelConstraintManager;
 import algorithms.StateManager.StateImpl;
 import algorithms.StateUpdates.UpdateActivityTimes;
@@ -40,18 +37,11 @@ import basics.VehicleRoutingAlgorithm;
 import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;
 import basics.algo.InsertionStartsListener;
-import basics.algo.IterationStartsListener;
 import basics.algo.JobInsertedListener;
 import basics.algo.SearchStrategy;
 import basics.algo.SearchStrategyManager;
 import basics.algo.SolutionCostCalculator;
 import basics.io.VrpXMLReader;
-import basics.io.VrpXMLWriter;
-import basics.route.DeliveryActivity;
-import basics.route.End;
-import basics.route.PickupActivity;
-import basics.route.Start;
-import basics.route.TourActivity;
 import basics.route.VehicleRoute;
 
 public class BuildPDVRPAlgoFromScratchTest {
@@ -75,7 +65,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/ExampleActivityCostFunction.java

@@ -17,11 +17,10 @@
 package algorithms;
 
 import basics.costs.VehicleRoutingActivityCosts;
-import basics.costs.VehicleRoutingActivityCosts.Time;
 import basics.route.Driver;
 import basics.route.TourActivity;
-import basics.route.Vehicle;
 import basics.route.TourActivity.JobActivity;
+import basics.route.Vehicle;
 
 
 public class ExampleActivityCostFunction implements VehicleRoutingActivityCosts{

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

@@ -148,7 +148,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/RefuseCollectionTest.java

@@ -16,7 +16,7 @@
  ******************************************************************************/
 package algorithms;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.io.BufferedReader;
 import java.io.File;

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

@@ -21,8 +21,6 @@ import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
 
 import org.apache.commons.configuration.ConfigurationException;
 import org.apache.commons.configuration.XMLConfiguration;

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

@@ -153,7 +153,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

@@ -143,14 +143,13 @@ public class TestCalculatesServiceInsertionOnRouteLevel {
 		states = new StateManagerImpl();
 		
 		ExampleActivityCostFunction activityCosts = new ExampleActivityCostFunction();
-		serviceInsertion = new CalculatesServiceInsertionOnRouteLevel(costs,activityCosts);
+		ActivityInsertionCostsCalculator actInsertionCostCalculator = new RouteLevelActivityInsertionCostsEstimator(costs, activityCosts, new HardConstraints.HardTimeWindowActivityLevelConstraint(states, costs), states);
+		serviceInsertion = new CalculatesServiceInsertionOnRouteLevel(costs,activityCosts, new HardConstraints.HardLoadConstraint(states), actInsertionCostCalculator);
 		serviceInsertion.setNuOfActsForwardLooking(4);
 		serviceInsertion.setStates(states);
 		
 		updateStates = new UpdateStates(states, costs, activityCosts);
 		
-		
-		
 	}
 	
 	public TourActivity getActivityMock(String id, double earliestOperationStart, double currCost){

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

@@ -16,7 +16,7 @@
  ******************************************************************************/
 package algorithms;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;

jsprit-core/src/test/java/algorithms/selectors/SelectRandomlyTest.java

@@ -28,8 +28,6 @@ import java.util.Random;
 
 import org.junit.Test;
 
-import algorithms.selectors.SelectRandomly;
-import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;
 
 

jsprit-core/src/test/java/basics/algo/SearchStrategyManagerTest.java

@@ -27,9 +27,6 @@ import java.util.Random;
 
 import org.junit.Test;
 
-import basics.algo.SearchStrategy;
-import basics.algo.SearchStrategyManager;
-
 
 
 public class SearchStrategyManagerTest {

jsprit-core/src/test/java/basics/algo/SearchStrategyTest.java

@@ -30,9 +30,6 @@ import algorithms.acceptors.SolutionAcceptor;
 import algorithms.selectors.SolutionSelector;
 import basics.VehicleRoutingProblem;
 import basics.VehicleRoutingProblemSolution;
-import basics.algo.SearchStrategy;
-import basics.algo.SearchStrategyModule;
-import basics.algo.SearchStrategyModuleListener;
 
 
 

jsprit-core/src/test/java/basics/io/VrpReaderV2Test.java

@@ -30,10 +30,8 @@ import org.junit.Test;
 
 import basics.Service;
 import basics.VehicleRoutingProblem;
-import basics.VehicleRoutingProblem.Builder;
 import basics.VehicleRoutingProblem.FleetComposition;
 import basics.VehicleRoutingProblem.FleetSize;
-import basics.io.VrpXMLReader;
 import basics.route.Vehicle;
 
 public class VrpReaderV2Test {

jsprit-core/src/test/java/basics/io/VrpWriterV2Test.java

@@ -27,19 +27,16 @@ import org.junit.Test;
 
 import basics.Service;
 import basics.VehicleRoutingProblem;
-import basics.VehicleRoutingProblemSolution;
 import basics.VehicleRoutingProblem.Builder;
 import basics.VehicleRoutingProblem.FleetComposition;
 import basics.VehicleRoutingProblem.FleetSize;
-import basics.io.VrpXMLReader;
+import basics.VehicleRoutingProblemSolution;
-import basics.io.VrpXMLWriter;
 import basics.route.End;
 import basics.route.ServiceActivity;
 import basics.route.Start;
 import basics.route.Vehicle;
 import basics.route.VehicleImpl;
 import basics.route.VehicleRoute;
-import basics.route.VehicleType;
 import basics.route.VehicleTypeImpl;
 
 public class VrpWriterV2Test {

jsprit-core/src/test/java/basics/route/ServiceActTest.java

@@ -16,13 +16,12 @@
  ******************************************************************************/
 package basics.route;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 
 import basics.Service;
-import basics.Service.Builder;
-import basics.route.ServiceActivity;
 
 public class ServiceActTest {
 

jsprit-core/src/test/java/basics/route/TestTour.java

@@ -16,15 +16,14 @@
  ******************************************************************************/
 package basics.route;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Before;
 import org.junit.Test;
 
 import basics.Service;
-import basics.Service.Builder;
-import basics.route.ServiceActivity;
-import basics.route.TourActivities;
 
 
 public class TestTour {