From 4e99daeebf7058df7f9df166377dcc7bebca3505 Mon Sep 17 00:00:00 2001 From: oblonski <4sschroeder@gmail.com> Date: Mon, 14 Oct 2013 08:30:21 +0200 Subject: [PATCH] improve route-level search --- ... => ActivityInsertionCostsCalculator.java} | 8 +- .../CalculatesServiceInsertion.java | 26 ++-- ...alculatesServiceInsertionOnRouteLevel.java | 44 +++--- .../java/algorithms/CalculatorBuilder.java | 4 +- ...ocalActivityInsertionCostsCalculator.java} | 8 +- ...eLevelActivityInsertionCostsEstimator.java | 142 ++++++++++++++++++ .../BuildCVRPAlgoFromScratchTest.java | 2 +- .../BuildPDVRPAlgoFromScratchTest.java | 2 +- .../java/algorithms/GendreauPostOptTest.java | 2 +- .../TestCalculatesServiceInsertion.java | 2 +- ...alculatesServiceInsertionOnRouteLevel.java | 2 +- 11 files changed, 195 insertions(+), 47 deletions(-) rename jsprit-core/src/main/java/algorithms/{MarginalsCalculus.java => ActivityInsertionCostsCalculator.java} (82%) rename jsprit-core/src/main/java/algorithms/{MarginalsCalculusTriangleInequality.java => LocalActivityInsertionCostsCalculator.java} (88%) create mode 100644 jsprit-core/src/main/java/algorithms/RouteLevelActivityInsertionCostsEstimator.java diff --git a/jsprit-core/src/main/java/algorithms/MarginalsCalculus.java b/jsprit-core/src/main/java/algorithms/ActivityInsertionCostsCalculator.java similarity index 82% rename from jsprit-core/src/main/java/algorithms/MarginalsCalculus.java rename to jsprit-core/src/main/java/algorithms/ActivityInsertionCostsCalculator.java index d17e9bfc..4a72322b 100644 --- a/jsprit-core/src/main/java/algorithms/MarginalsCalculus.java +++ b/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); } diff --git a/jsprit-core/src/main/java/algorithms/CalculatesServiceInsertion.java b/jsprit-core/src/main/java/algorithms/CalculatesServiceInsertion.java index a792fb53..bbbfbdba 100644 --- a/jsprit-core/src/main/java/algorithms/CalculatesServiceInsertion.java +++ b/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) { - return marginalCalculus.calculate(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct); + public ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double departureTimeAtPrevAct) { + return activityInsertionCostsCalculator.calculate(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct); } } diff --git a/jsprit-core/src/main/java/algorithms/CalculatesServiceInsertionOnRouteLevel.java b/jsprit-core/src/main/java/algorithms/CalculatesServiceInsertionOnRouteLevel.java index fc255536..8b1a1c73 100644 --- a/jsprit-core/src/main/java/algorithms/CalculatesServiceInsertionOnRouteLevel.java +++ b/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){ - this.states = activityStates2; + public void setStates(StateManager stateManager){ + 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 path = new ArrayList(); 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 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 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(); } /** diff --git a/jsprit-core/src/main/java/algorithms/CalculatorBuilder.java b/jsprit-core/src/main/java/algorithms/CalculatorBuilder.java index 0a3898a2..621a8f27 100644 --- a/jsprit-core/src/main/java/algorithms/CalculatorBuilder.java +++ b/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()); diff --git a/jsprit-core/src/main/java/algorithms/MarginalsCalculusTriangleInequality.java b/jsprit-core/src/main/java/algorithms/LocalActivityInsertionCostsCalculator.java similarity index 88% rename from jsprit-core/src/main/java/algorithms/MarginalsCalculusTriangleInequality.java rename to jsprit-core/src/main/java/algorithms/LocalActivityInsertionCostsCalculator.java index f4ab4005..f845fd33 100644 --- a/jsprit-core/src/main/java/algorithms/MarginalsCalculusTriangleInequality.java +++ b/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); } } diff --git a/jsprit-core/src/main/java/algorithms/RouteLevelActivityInsertionCostsEstimator.java b/jsprit-core/src/main/java/algorithms/RouteLevelActivityInsertionCostsEstimator.java new file mode 100644 index 00000000..53d265fe --- /dev/null +++ b/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 path = new ArrayList(); + 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 getForwardLookingPath(VehicleRoute route, int actIndex) { + List forwardLookingPath = new ArrayList(); + 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; + } + +} diff --git a/jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java b/jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java index 63df0617..f3efa59c 100644 --- a/jsprit-core/src/test/java/algorithms/BuildCVRPAlgoFromScratchTest.java +++ b/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()); diff --git a/jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java b/jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java index b96ce7ec..1bed85a2 100644 --- a/jsprit-core/src/test/java/algorithms/BuildPDVRPAlgoFromScratchTest.java +++ b/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)); diff --git a/jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java b/jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java index c130af57..661918a4 100644 --- a/jsprit-core/src/test/java/algorithms/GendreauPostOptTest.java +++ b/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); diff --git a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java b/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java index 8ab72ed7..8b67dd73 100644 --- a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertion.java +++ b/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); diff --git a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java b/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java index 7798a263..ae1ef0c9 100644 --- a/jsprit-core/src/test/java/algorithms/TestCalculatesServiceInsertionOnRouteLevel.java +++ b/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);