From 552729d7ee9f87fea6e5a932aac1e7cea2ef03af Mon Sep 17 00:00:00 2001 From: oblonski Date: Wed, 22 Jul 2015 22:53:45 +0200 Subject: [PATCH 1/7] variable departure times and waiting time opt --- ...igureLocalActivityInsertionCalculator.java | 40 +++++ .../JobInsertionCostsCalculatorBuilder.java | 8 +- ...LocalActivityInsertionCostsCalculator.java | 29 +++- .../algorithm/state/UpdateDepartureTime.java | 54 +++++++ .../jsprit/core/problem/vehicle/Vehicle.java | 2 + .../core/problem/vehicle/VehicleImpl.java | 26 +++- .../VariableDepartureAndWaitingTime_IT.java | 143 ++++++++++++++++++ .../state/UpdateDepartureTimeTest.java | 97 ++++++++++++ .../core/problem/vehicle/VehicleImplTest.java | 12 +- .../jsprit/examples/CostMatrixExample.java | 6 +- 10 files changed, 403 insertions(+), 14 deletions(-) create mode 100644 jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java create mode 100644 jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java create mode 100644 jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java create mode 100644 jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java new file mode 100644 index 00000000..5f72aeb2 --- /dev/null +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java @@ -0,0 +1,40 @@ +package jsprit.core.algorithm.recreate; + +import jsprit.core.algorithm.recreate.listener.InsertionStartsListener; +import jsprit.core.algorithm.recreate.listener.JobInsertedListener; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.job.Job; +import jsprit.core.problem.solution.route.VehicleRoute; + +import java.util.Collection; + +/** + * Created by schroeder on 22/07/15. + */ +public class ConfigureLocalActivityInsertionCalculator implements InsertionStartsListener, JobInsertedListener { + + private VehicleRoutingProblem vrp; + + private LocalActivityInsertionCostsCalculator localActivityInsertionCostsCalculator; + + private int nuOfJobsToRecreate; + + public ConfigureLocalActivityInsertionCalculator(VehicleRoutingProblem vrp, LocalActivityInsertionCostsCalculator localActivityInsertionCostsCalculator) { + this.vrp = vrp; + this.localActivityInsertionCostsCalculator = localActivityInsertionCostsCalculator; + } + + @Override + public void informInsertionStarts(Collection vehicleRoutes, Collection unassignedJobs) { + this.nuOfJobsToRecreate = unassignedJobs.size(); + double completenessRatio = (1-((double)nuOfJobsToRecreate/(double)vrp.getJobs().values().size())); + localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(completenessRatio); + } + + @Override + public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { + nuOfJobsToRecreate--; + double completenessRatio = (1-((double)nuOfJobsToRecreate/(double)vrp.getJobs().values().size())); + localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(completenessRatio); + } +} diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java index 32ba952b..a7d79ae9 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java @@ -259,8 +259,10 @@ public class JobInsertionCostsCalculatorBuilder { if(constraintManager == null) throw new IllegalStateException("constraint-manager is null"); ActivityInsertionCostsCalculator actInsertionCalc; + ConfigureLocalActivityInsertionCalculator configLocal = null; if(activityInsertionCostCalculator == null && addDefaultCostCalc){ actInsertionCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts()); + configLocal = new ConfigureLocalActivityInsertionCalculator(vrp, (LocalActivityInsertionCostsCalculator) actInsertionCalc); } else if(activityInsertionCostCalculator == null && !addDefaultCostCalc){ actInsertionCalc = new ActivityInsertionCostsCalculator(){ @@ -296,7 +298,11 @@ public class JobInsertionCostsCalculatorBuilder { switcher.put(Pickup.class, serviceInsertion); switcher.put(Delivery.class, serviceInsertion); - return new CalculatorPlusListeners(switcher); + CalculatorPlusListeners calculatorPlusListeners = new CalculatorPlusListeners(switcher); + if(configLocal != null){ + calculatorPlusListeners.insertionListener.add(configLocal); + } + return calculatorPlusListeners; } private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCostsCalculator baseCalculator, RouteAndActivityStateGetter activityStates2, double weightOfFixedCosts){ diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java index 0a8e61c0..d58ecd86 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java @@ -22,6 +22,7 @@ import jsprit.core.problem.cost.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.solution.route.activity.End; +import jsprit.core.problem.solution.route.activity.Start; import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.util.CalculationUtils; @@ -40,8 +41,11 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal private VehicleRoutingTransportCosts routingCosts; private VehicleRoutingActivityCosts activityCosts; - - + + private double activityCostsWeight = 1.; + + private double solutionCompletenessRatio = 1.; + public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts) { super(); this.routingCosts = routingCosts; @@ -56,7 +60,12 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal double newAct_arrTime = depTimeAtPrevAct + tp_time_prevAct_newAct; double newAct_endTime = CalculationUtils.getActivityEndTime(newAct_arrTime, newAct); double act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); - + if(prevAct instanceof Start) { + if(iFacts.getNewVehicle().hasVariableDepartureTime()){ + act_costs_newAct = 0; + } + } + //open routes if(nextAct instanceof End){ if(!iFacts.getNewVehicle().isReturnToDepot()){ @@ -68,22 +77,30 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal double tp_time_newAct_nextAct = routingCosts.getTransportTime(newAct.getLocation(), nextAct.getLocation(), 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 totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + solutionCompletenessRatio * activityCostsWeight * (act_costs_newAct + act_costs_nextAct); double oldCosts; if(iFacts.getRoute().isEmpty()){ double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double arrTime_nextAct = routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); - oldCosts = tp_costs_prevAct_nextAct + actCost_nextAct; + oldCosts = tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; } else{ double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); double arrTime_nextAct = routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); - oldCosts = tp_costs_prevAct_nextAct + actCost_nextAct; + oldCosts = tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; } return totalCosts - oldCosts; } + public void setActivityCostWeight(double weight){ + this.activityCostsWeight = weight; + } + + public void setSolutionCompletenessRatio(double solutionCompletenessRatio) { + this.solutionCompletenessRatio = solutionCompletenessRatio; + } } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java new file mode 100644 index 00000000..11319341 --- /dev/null +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java @@ -0,0 +1,54 @@ +/******************************************************************************* + * Copyright (C) 2014 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 . + ******************************************************************************/ +package jsprit.core.algorithm.state; + +import jsprit.core.problem.cost.VehicleRoutingTransportCosts; +import jsprit.core.problem.solution.route.RouteVisitor; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.TourActivity; + +public class UpdateDepartureTime implements StateUpdater, RouteVisitor{ + + private VehicleRoutingTransportCosts routingCosts; + + public UpdateDepartureTime(VehicleRoutingTransportCosts routingCosts) { + this.routingCosts = routingCosts; + } + + @Override + public void visit(VehicleRoute route) { + if(route.getVehicle() != null){ + if(route.getVehicle().hasVariableDepartureTime()) { + if (!route.isEmpty()) { + TourActivity first = route.getActivities().get(0); + double earliestStart = first.getTheoreticalEarliestOperationStartTime(); + double backwardTravelTime = routingCosts.getBackwardTransportTime(first.getLocation(), route.getStart().getLocation(), + earliestStart, route.getDriver(), route.getVehicle()); + double newDepartureTime = Math.max(route.getStart().getEndTime(), earliestStart - backwardTravelTime); + route.setVehicleAndDepartureTime(route.getVehicle(), newDepartureTime); + } + } + } + } + + + + + + + +} diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java index b29391d1..59b025ff 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java @@ -72,4 +72,6 @@ public interface Vehicle extends HasId, HasIndex { public abstract VehicleTypeKey getVehicleTypeIdentifier(); public abstract Skills getSkills(); + + public boolean hasVariableDepartureTime(); } diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java index bfcf00a1..dcd3ee0c 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java @@ -91,7 +91,12 @@ public class VehicleImpl extends AbstractVehicle{ public Skills getSkills() { return null; } - } + + @Override + public boolean hasVariableDepartureTime() { + return false; + } + } /** * Builder that builds the vehicle. @@ -125,7 +130,9 @@ public class VehicleImpl extends AbstractVehicle{ private Location endLocation; - private Builder(String id) { + private boolean hasVariableDepartureTime = false; + + private Builder(String id) { super(); this.id = id; } @@ -142,6 +149,11 @@ public class VehicleImpl extends AbstractVehicle{ this.type = type; return this; } + + public Builder setHasVariableDepartureTime(boolean hasVariableDepartureTime){ + this.hasVariableDepartureTime = hasVariableDepartureTime; + return this; + } /** * Sets the flag whether the vehicle must return to depot or not. @@ -274,6 +286,8 @@ public class VehicleImpl extends AbstractVehicle{ private final Location startLocation; + private final boolean hasVariableDepartureTime; + private VehicleImpl(Builder builder){ id = builder.id; type = builder.type; @@ -283,6 +297,7 @@ public class VehicleImpl extends AbstractVehicle{ skills = builder.skills; endLocation = builder.endLocation; startLocation = builder.startLocation; + hasVariableDepartureTime = builder.hasVariableDepartureTime; setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(),startLocation.getId(),endLocation.getId(),earliestDeparture,latestArrival,skills)); } @@ -341,7 +356,12 @@ public class VehicleImpl extends AbstractVehicle{ return skills; } - /* (non-Javadoc) + @Override + public boolean hasVariableDepartureTime() { + return hasVariableDepartureTime; + } + + /* (non-Javadoc) * @see java.lang.Object#hashCode() */ @Override diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java new file mode 100644 index 00000000..a9432fde --- /dev/null +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java @@ -0,0 +1,143 @@ +package jsprit.core.algorithm; + +import jsprit.core.algorithm.box.Jsprit; +import jsprit.core.algorithm.state.StateManager; +import jsprit.core.algorithm.state.UpdateDepartureTime; +import jsprit.core.analysis.SolutionAnalyser; +import jsprit.core.problem.Location; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.constraint.ConstraintManager; +import jsprit.core.problem.cost.TransportDistance; +import jsprit.core.problem.cost.VehicleRoutingActivityCosts; +import jsprit.core.problem.driver.Driver; +import jsprit.core.problem.job.Service; +import jsprit.core.problem.solution.SolutionCostCalculator; +import jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import jsprit.core.problem.solution.route.activity.TimeWindow; +import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.problem.vehicle.Vehicle; +import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.util.CostFactory; +import jsprit.core.util.Solutions; +import junit.framework.Assert; +import org.junit.Before; +import org.junit.Test; + +/** + * Created by schroeder on 22/07/15. + */ +public class VariableDepartureAndWaitingTime_IT { + + static interface AlgorithmFactory { + VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp); + } + + VehicleRoutingActivityCosts activityCosts; + + AlgorithmFactory algorithmFactory; + + @Before + public void doBefore(){ + activityCosts = new VehicleRoutingActivityCosts() { + + @Override + public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { + return Math.max(0,tourAct.getTheoreticalEarliestOperationStartTime() - arrivalTime); + } + + }; + algorithmFactory = new AlgorithmFactory() { + @Override + public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + + return Jsprit.Builder.newInstance(vrp) + .addCoreStateAndConstraintStuff(true) + .setStateAndConstraintManager(stateManager,constraintManager) + .setObjectiveFunction(new SolutionCostCalculator() { + @Override + public double getCosts(VehicleRoutingProblemSolution solution) { + SolutionAnalyser sa = new SolutionAnalyser(vrp, solution, new TransportDistance() { + @Override + public double getDistance(Location from, Location to) { + return vrp.getTransportCosts().getTransportCost(from, to, 0., null, null); + } + }); + return sa.getWaitingTime() + sa.getDistance(); + } + }) + .buildAlgorithm(); + } + }; + } + + @Test + public void plainSetupShouldWork(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build(); + Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(10,0)).build(); + Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(20,0)).build(); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addJob(s1).addJob(s2).addVehicle(v) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .setRoutingCost(CostFactory.createManhattanCosts()) + .setActivityCosts(activityCosts) + .build(); + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + Assert.assertEquals(40.,solution.getCost()); + } + + @Test + public void withTimeWindowsShouldWork(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build(); + Service s1 = Service.Builder.newInstance("s1").setTimeWindow(TimeWindow.newInstance(1010,1100)).setLocation(Location.newInstance(10,0)).build(); + Service s2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(20,0)).build(); + final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addJob(s1).addJob(s2).addVehicle(v) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .setRoutingCost(CostFactory.createManhattanCosts()) + .setActivityCosts(activityCosts) + .build(); + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + Assert.assertEquals(40.+1000.,solution.getCost()); + } + + @Test + public void variableDepartureShouldWork(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + Service s1 = Service.Builder.newInstance("s1").setTimeWindow(TimeWindow.newInstance(1010,1100)).setLocation(Location.newInstance(10,0)).build(); + Service s2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(20,0)).build(); + final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addJob(s1).addJob(s2).addVehicle(v) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .setRoutingCost(CostFactory.createManhattanCosts()) + .setActivityCosts(activityCosts) + .build(); + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + Assert.assertEquals(40.,solution.getCost()); + } + + @Test + public void variableDepartureShouldWork2(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + Service s1 = Service.Builder.newInstance("s1").setTimeWindow(TimeWindow.newInstance(1010,1100)).setLocation(Location.newInstance(10,0)).build(); + Service s2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(20,0)).build(); + Service s3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(15,0)).build(); + final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addJob(s1).addJob(s2).addVehicle(v) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .setRoutingCost(CostFactory.createManhattanCosts()) + .setActivityCosts(activityCosts) + .build(); + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + Assert.assertEquals(40.,solution.getCost()); + } + + + +} diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java new file mode 100644 index 00000000..7f1c9e9d --- /dev/null +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java @@ -0,0 +1,97 @@ +package jsprit.core.algorithm.state; + +import jsprit.core.problem.Location; +import jsprit.core.problem.cost.VehicleRoutingTransportCosts; +import jsprit.core.problem.job.Service; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.TimeWindow; +import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.util.CostFactory; +import junit.framework.Assert; +import org.junit.Test; + +/** + * Created by schroeder on 22/07/15. + */ +public class UpdateDepartureTimeTest { + + @Test + public void whenNoTimeWindow_departureTimeShouldBeEarliestStartTime(){ + VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance(10,0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); + + UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); + udt.visit(route); + + Assert.assertEquals(0.,route.getDepartureTime()); + } + + @Test + public void whenNoTimeWindow_departureTimeShouldBeEarliestStartTime2(){ + VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(10).setStartLocation(Location.newInstance(0, 0)).build(); + Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance(10,0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); + + UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); + udt.visit(route); + + Assert.assertEquals(10.,route.getDepartureTime()); + } + + @Test + public void whenTimeWindowAndNoWaitingTime_departureTimeShouldBeEarliestStartTime1(){ + VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(5,20)).setLocation(Location.newInstance(10, 0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); + + UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); + udt.visit(route); + + Assert.assertEquals(0.,route.getDepartureTime()); + } + + @Test + public void whenTimeWindowAndNoWaitingTime_departureTimeShouldBeEarliestStartTime2(){ + VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(10).setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(5,20)).setLocation(Location.newInstance(10, 0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); + + UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); + udt.visit(route); + + Assert.assertEquals(10.,route.getDepartureTime()); + } + + @Test + public void whenTimeWindowAndWaitingTime_departureTimeShouldChange(){ + VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(0) + .setHasVariableDepartureTime(true) + .setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(15,20)).setLocation(Location.newInstance(10, 0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); + + UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); + udt.visit(route); + + Assert.assertEquals(5.,route.getDepartureTime()); + } + + @Test + public void whenTimeWindowAndWaitingTime_departureTimeShouldChange2(){ + VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(5).setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(18,20)).setLocation(Location.newInstance(10, 0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); + + UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); + udt.visit(route); + + Assert.assertEquals(8.,route.getDepartureTime()); + } +} diff --git a/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java b/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java index 20a2c349..229c46d9 100644 --- a/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java +++ b/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java @@ -221,5 +221,15 @@ public class VehicleImplTest { assertFalse(v.getSkills().containsSkill("ScrewDriver")); } - + @Test + public void whenSettingVariableDeparture_itShouldBeSet(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("loc")).setHasVariableDepartureTime(true).build(); + assertTrue(v.hasVariableDepartureTime()); + } + + @Test + public void defaultOfHasVariableDepartureShouldBeFalse(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("loc")).build(); + assertFalse(v.hasVariableDepartureTime()); + } } diff --git a/jsprit-examples/src/main/java/jsprit/examples/CostMatrixExample.java b/jsprit-examples/src/main/java/jsprit/examples/CostMatrixExample.java index 17bc0d74..d7bea962 100644 --- a/jsprit-examples/src/main/java/jsprit/examples/CostMatrixExample.java +++ b/jsprit-examples/src/main/java/jsprit/examples/CostMatrixExample.java @@ -18,7 +18,7 @@ package jsprit.examples; import jsprit.analysis.toolbox.Plotter; import jsprit.core.algorithm.VehicleRoutingAlgorithm; -import jsprit.core.algorithm.io.VehicleRoutingAlgorithms; +import jsprit.core.algorithm.box.Jsprit; import jsprit.core.problem.Location; import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem.FleetSize; @@ -58,7 +58,7 @@ public class CostMatrixExample { Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(Location.newInstance("2")).build(); Service s3 = Service.Builder.newInstance("3").addSizeDimension(0, 1).setLocation(Location.newInstance("3")).build(); - + /* * Assume the following symmetric distance-matrix * from,to,distance @@ -98,7 +98,7 @@ public class CostMatrixExample { VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().setFleetSize(FleetSize.INFINITE).setRoutingCost(costMatrix) .addVehicle(vehicle).addJob(s1).addJob(s2).addJob(s3).build(); - VehicleRoutingAlgorithm vra = VehicleRoutingAlgorithms.readAndCreateAlgorithm(vrp, "input/fastAlgo.xml"); + VehicleRoutingAlgorithm vra = Jsprit.createAlgorithm(vrp); Collection solutions = vra.searchSolutions(); From f9c255cc08189c5c3cc8c42b28e11d00056e5942 Mon Sep 17 00:00:00 2001 From: oblonski Date: Wed, 29 Jul 2015 20:47:26 +0200 Subject: [PATCH 2/7] variable departure times and waiting time opt --- .../algorithm/VehicleRoutingAlgorithm.java | 37 ++- .../jsprit/core/algorithm/box/Jsprit.java | 1 + ...igureLocalActivityInsertionCalculator.java | 4 +- .../JobInsertionCostsCalculatorBuilder.java | 2 +- ...LocalActivityInsertionCostsCalculator.java | 77 ++++-- ...leTypeDependentJobInsertionCalculator.java | 6 +- .../core/algorithm/state/InternalStates.java | 4 + .../algorithm/state/UpdateDepartureTime.java | 96 ++++++-- .../core/algorithm/state/UpdateTimeSlack.java | 81 +++++++ ...eVehicleDependentPracticalTimeWindows.java | 21 +- .../core/problem/VehicleRoutingProblem.java | 16 +- .../core/problem/cost/WaitingTimeCosts.java | 20 ++ .../problem/vehicle/InfiniteVehicles.java | 4 +- .../vehicle/VehicleFleetManagerImpl.java | 6 +- .../core/problem/vehicle/VehicleImpl.java | 2 +- .../core/problem/vehicle/VehicleTypeImpl.java | 58 ++++- .../core/problem/vehicle/VehicleTypeKey.java | 8 +- .../VariableDepartureAndWaitingTime_IT.java | 225 +++++++++++++++++- ...erviceInsertionAndLoadConstraintsTest.java | 2 +- .../ShipmentInsertionCalculatorTest.java | 2 +- .../TestCalculatesServiceInsertion.java | 2 +- ...LocalActivityInsertionCostsCalculator.java | 119 ++++++++- .../state/UpdateDepartureTimeTest.java | 79 ++++-- .../algorithm/state/UpdateTimeSlackTest.java | 119 +++++++++ 24 files changed, 881 insertions(+), 110 deletions(-) create mode 100644 jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java create mode 100644 jsprit-core/src/main/java/jsprit/core/problem/cost/WaitingTimeCosts.java create mode 100644 jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/VehicleRoutingAlgorithm.java b/jsprit-core/src/main/java/jsprit/core/algorithm/VehicleRoutingAlgorithm.java index df46b466..35891e16 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/VehicleRoutingAlgorithm.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/VehicleRoutingAlgorithm.java @@ -20,6 +20,7 @@ import jsprit.core.algorithm.SearchStrategy.DiscoveredSolution; import jsprit.core.algorithm.listener.*; import jsprit.core.algorithm.termination.PrematureAlgorithmTermination; import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.job.Job; import jsprit.core.problem.solution.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.route.VehicleRoute; import jsprit.core.problem.solution.route.activity.TourActivity; @@ -195,6 +196,7 @@ public class VehicleRoutingAlgorithm { Collection solutions = new ArrayList(initialSolutions); algorithmStarts(problem,solutions); bestEver = Solutions.bestOf(solutions); + if(logger.isTraceEnabled()) log(solutions); logger.info("iterations start"); for(int i=0;i< maxIterations;i++){ iterationStarts(i+1,problem,solutions); @@ -202,7 +204,7 @@ public class VehicleRoutingAlgorithm { counter.incCounter(); SearchStrategy strategy = searchStrategyManager.getRandomStrategy(); DiscoveredSolution discoveredSolution = strategy.run(problem, solutions); - logger.trace("discovered solution: " + discoveredSolution); + if(logger.isTraceEnabled()) log(discoveredSolution); memorizeIfBestEver(discoveredSolution); selectedStrategy(discoveredSolution,problem,solutions); if(terminationManager.isPrematureBreak(discoveredSolution)){ @@ -219,7 +221,38 @@ public class VehicleRoutingAlgorithm { return solutions; } - private void addBestEver(Collection solutions) { + private void log(Collection solutions) { + for(VehicleRoutingProblemSolution sol : solutions) log(sol); + } + + private void log(VehicleRoutingProblemSolution solution){ + logger.trace("solution costs: " + solution.getCost()); + for(VehicleRoute r : solution.getRoutes()){ + StringBuilder b = new StringBuilder(); + b.append(r.getVehicle().getId()).append(" : ").append("[ "); + for(TourActivity act : r.getActivities()){ + if(act instanceof TourActivity.JobActivity){ + b.append(((TourActivity.JobActivity) act).getJob().getId()).append(" "); + } + } + b.append("]"); + logger.trace(b.toString()); + } + StringBuilder b = new StringBuilder(); + b.append("unassigned : [ "); + for(Job j : solution.getUnassignedJobs()){ + b.append(j.getId()).append(" "); + } + b.append("]"); + logger.trace(b.toString()); + } + + private void log(DiscoveredSolution discoveredSolution) { + logger.trace("discovered solution: " + discoveredSolution); + log(discoveredSolution.getSolution()); + } + + private void addBestEver(Collection solutions) { if(bestEver != null) solutions.add(bestEver); } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/box/Jsprit.java b/jsprit-core/src/main/java/jsprit/core/algorithm/box/Jsprit.java index add86df7..3bbfeb86 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/box/Jsprit.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/box/Jsprit.java @@ -554,6 +554,7 @@ public class Jsprit { TourActivity prevAct = route.getStart(); for(TourActivity act : route.getActivities()){ costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); + costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle()); prevAct = act; } costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java index 5f72aeb2..1c2850df 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureLocalActivityInsertionCalculator.java @@ -28,13 +28,13 @@ public class ConfigureLocalActivityInsertionCalculator implements InsertionStart public void informInsertionStarts(Collection vehicleRoutes, Collection unassignedJobs) { this.nuOfJobsToRecreate = unassignedJobs.size(); double completenessRatio = (1-((double)nuOfJobsToRecreate/(double)vrp.getJobs().values().size())); - localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(completenessRatio); + localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(Math.max(0.5,completenessRatio)); } @Override public void informJobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime) { nuOfJobsToRecreate--; double completenessRatio = (1-((double)nuOfJobsToRecreate/(double)vrp.getJobs().values().size())); - localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(completenessRatio); + localActivityInsertionCostsCalculator.setSolutionCompletenessRatio(Math.max(0.5,completenessRatio)); } } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java index a7d79ae9..ecb7f8a5 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculatorBuilder.java @@ -261,7 +261,7 @@ public class JobInsertionCostsCalculatorBuilder { ActivityInsertionCostsCalculator actInsertionCalc; ConfigureLocalActivityInsertionCalculator configLocal = null; if(activityInsertionCostCalculator == null && addDefaultCostCalc){ - actInsertionCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts()); + actInsertionCalc = new LocalActivityInsertionCostsCalculator(vrp.getTransportCosts(), vrp.getActivityCosts(), statesManager); configLocal = new ConfigureLocalActivityInsertionCalculator(vrp, (LocalActivityInsertionCostsCalculator) actInsertionCalc); } else if(activityInsertionCostCalculator == null && !addDefaultCostCalc){ diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java index d58ecd86..276026c6 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java @@ -18,12 +18,15 @@ package jsprit.core.algorithm.recreate; +import jsprit.core.algorithm.state.InternalStates; import jsprit.core.problem.cost.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.solution.route.activity.End; import jsprit.core.problem.solution.route.activity.Start; import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter; +import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.util.CalculationUtils; /** @@ -46,56 +49,96 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal private double solutionCompletenessRatio = 1.; - public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts) { + private double variableStartTimeFactor = 1.; + + private RouteAndActivityStateGetter stateManager; + + public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, RouteAndActivityStateGetter stateManager) { super(); this.routingCosts = routingCosts; this.activityCosts = actCosts; + this.stateManager = stateManager; + } + + public void setVariableStartTimeFactor(double variableStartTimeFactor) { + this.variableStartTimeFactor = variableStartTimeFactor; } @Override public double getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) { - +// double waiting = 0; +// if(!isEnd(nextAct)){ +// waiting = stateManager.getActivityState(nextAct, InternalStates.WAITING,Double.class); +// } + double tp_costs_prevAct_newAct = routingCosts.getTransportCost(prevAct.getLocation(), newAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double tp_time_prevAct_newAct = routingCosts.getTransportTime(prevAct.getLocation(), newAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double newAct_arrTime = depTimeAtPrevAct + tp_time_prevAct_newAct; double newAct_endTime = CalculationUtils.getActivityEndTime(newAct_arrTime, newAct); + + double act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); - if(prevAct instanceof Start) { - if(iFacts.getNewVehicle().hasVariableDepartureTime()){ - act_costs_newAct = 0; - } + + double slack_time_new = 0; + double slack_time_prev = 0; + if(isStart(prevAct) && hasVariableDeparture(iFacts.getNewVehicle())) act_costs_newAct = 0; + else if(hasVariableDeparture(iFacts.getNewVehicle())){ + Double slack_time_prev_ = stateManager.getActivityState(prevAct,iFacts.getNewVehicle(),InternalStates.TIME_SLACK,Double.class); + if(slack_time_prev_ == null) slack_time_prev = 0.; + else slack_time_prev = slack_time_prev_; + act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime + slack_time_prev, iFacts.getNewDriver(), iFacts.getNewVehicle()); + slack_time_new = Math.min(newAct.getTheoreticalLatestOperationStartTime() - newAct.getTheoreticalEarliestOperationStartTime(), Math.max(newAct_arrTime + slack_time_prev - newAct.getTheoreticalEarliestOperationStartTime(), 0)); } - //open routes - if(nextAct instanceof End){ - if(!iFacts.getNewVehicle().isReturnToDepot()){ - return tp_costs_prevAct_newAct; - } - } - + if(isEnd(nextAct) && !toDepot(iFacts.getNewVehicle())) return tp_costs_prevAct_newAct; + double tp_costs_newAct_nextAct = routingCosts.getTransportCost(newAct.getLocation(), nextAct.getLocation(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); double tp_time_newAct_nextAct = routingCosts.getTransportTime(newAct.getLocation(), nextAct.getLocation(), 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()); + if(hasVariableDeparture(iFacts.getNewVehicle())){ + act_costs_nextAct = activityCosts.getActivityCost(nextAct, nextAct_arrTime + slack_time_new, iFacts.getNewDriver(), iFacts.getNewVehicle()); + } + double totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + solutionCompletenessRatio * activityCostsWeight * (act_costs_newAct + act_costs_nextAct); double oldCosts; if(iFacts.getRoute().isEmpty()){ double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); - double arrTime_nextAct = routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); - double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); - oldCosts = tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; + oldCosts = tp_costs_prevAct_nextAct; } else{ double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); - double arrTime_nextAct = routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); + double arrTime_nextAct = prevAct.getEndTime() + routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); + if(isStart(prevAct) && hasVariableDeparture(iFacts.getRoute().getVehicle())) { + actCost_nextAct = 0; + } + else if(hasVariableDeparture(iFacts.getRoute().getVehicle())){ + actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct + slack_time_prev, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); + } oldCosts = tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; } return totalCosts - oldCosts; } + private boolean toDepot(Vehicle newVehicle) { + return newVehicle.isReturnToDepot(); + } + + private boolean isEnd(TourActivity nextAct) { + return nextAct instanceof End; + } + + private boolean hasVariableDeparture(Vehicle newVehicle) { + return newVehicle.hasVariableDepartureTime(); + } + + private boolean isStart(TourActivity prevAct) { + return prevAct instanceof Start; + } + public void setActivityCostWeight(double weight){ this.activityCostsWeight = weight; } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/VehicleTypeDependentJobInsertionCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/VehicleTypeDependentJobInsertionCalculator.java index 4b630eea..0eedc539 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/VehicleTypeDependentJobInsertionCalculator.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/VehicleTypeDependentJobInsertionCalculator.java @@ -109,9 +109,9 @@ final class VehicleTypeDependentJobInsertionCalculator implements JobInsertionCo relevantVehicles.addAll(fleetManager.getAvailableVehicles()); } for(Vehicle v : relevantVehicles){ - double depTime; - if(v == selectedVehicle) depTime = currentRoute.getDepartureTime(); - else depTime = v.getEarliestDeparture(); + double depTime = v.getEarliestDeparture(); +// if(v == selectedVehicle) depTime = currentRoute.getDepartureTime(); +// else depTime = v.getEarliestDeparture(); InsertionData iData = insertionCalculator.getInsertionData(currentRoute, jobToInsert, v, depTime, selectedDriver, bestKnownCost_); if(iData instanceof NoInsertionFound) { continue; diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java index ae8336d0..a210fc8b 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java @@ -42,4 +42,8 @@ public class InternalStates { public final static StateId PAST_MAXLOAD = new StateFactory.StateIdImpl("past_max_load", 9); public static final StateId SKILLS = new StateFactory.StateIdImpl("skills", 10); + + public static final StateId WAITING = new StateFactory.StateIdImpl("waiting",11); + + public static final StateId TIME_SLACK = new StateFactory.StateIdImpl("time_slack",12); } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java index 11319341..2e9563c6 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java @@ -21,34 +21,86 @@ import jsprit.core.problem.solution.route.RouteVisitor; import jsprit.core.problem.solution.route.VehicleRoute; import jsprit.core.problem.solution.route.activity.TourActivity; -public class UpdateDepartureTime implements StateUpdater, RouteVisitor{ +import java.util.Iterator; - private VehicleRoutingTransportCosts routingCosts; +/** + * Updates and memorizes latest operation start times at activities. + * + * @author schroeder + * + */ +public class UpdateDepartureTime implements RouteVisitor, StateUpdater{ - public UpdateDepartureTime(VehicleRoutingTransportCosts routingCosts) { - this.routingCosts = routingCosts; + + + private VehicleRoute route; + + private VehicleRoutingTransportCosts transportCosts; + + private double arrTimeAtPrevActWithoutWaiting; + + private TourActivity prevAct; + + private boolean hasEarliest = false; + + private boolean hasVariableDepartureTime; + + public UpdateDepartureTime(VehicleRoutingTransportCosts tpCosts) { + super(); + this.transportCosts = tpCosts; + + } + + + public void begin(VehicleRoute route) { + this.route = route; + hasEarliest = false; + prevAct = route.getEnd(); + hasVariableDepartureTime = route.getVehicle().hasVariableDepartureTime(); + } + + + public void visit(TourActivity activity) { + if(!hasVariableDepartureTime) return; + if(hasEarliest){ + double potentialArrivalTimeAtCurrAct = arrTimeAtPrevActWithoutWaiting - transportCosts.getBackwardTransportTime(activity.getLocation(), prevAct.getLocation(), arrTimeAtPrevActWithoutWaiting, route.getDriver(),route.getVehicle()) - activity.getOperationTime(); + if(potentialArrivalTimeAtCurrAct < activity.getTheoreticalEarliestOperationStartTime()){ + arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalEarliestOperationStartTime(); + } + else if(potentialArrivalTimeAtCurrAct >= activity.getTheoreticalEarliestOperationStartTime() && potentialArrivalTimeAtCurrAct <= activity.getTheoreticalLatestOperationStartTime()){ + arrTimeAtPrevActWithoutWaiting = potentialArrivalTimeAtCurrAct; + } + else { + arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalLatestOperationStartTime(); + } + } + else{ + if(activity.getTheoreticalEarliestOperationStartTime() > 0){ + hasEarliest = true; + arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalEarliestOperationStartTime(); + } + } + prevAct = activity; + } + + + public void finish() { + if(!hasVariableDepartureTime) return; + if(hasEarliest){ + double dep = arrTimeAtPrevActWithoutWaiting - transportCosts.getBackwardTransportTime(route.getStart().getLocation(), prevAct.getLocation(), arrTimeAtPrevActWithoutWaiting, route.getDriver(),route.getVehicle()); + double newDepartureTime = Math.max(route.getVehicle().getEarliestDeparture(), dep); + route.setVehicleAndDepartureTime(route.getVehicle(),newDepartureTime); + } + else route.setVehicleAndDepartureTime(route.getVehicle(),route.getVehicle().getEarliestDeparture()); } @Override public void visit(VehicleRoute route) { - if(route.getVehicle() != null){ - if(route.getVehicle().hasVariableDepartureTime()) { - if (!route.isEmpty()) { - TourActivity first = route.getActivities().get(0); - double earliestStart = first.getTheoreticalEarliestOperationStartTime(); - double backwardTravelTime = routingCosts.getBackwardTransportTime(first.getLocation(), route.getStart().getLocation(), - earliestStart, route.getDriver(), route.getVehicle()); - double newDepartureTime = Math.max(route.getStart().getEndTime(), earliestStart - backwardTravelTime); - route.setVehicleAndDepartureTime(route.getVehicle(), newDepartureTime); - } - } + begin(route); + Iterator revIterator = route.getTourActivities().reverseActivityIterator(); + while(revIterator.hasNext()){ + visit(revIterator.next()); } + finish(); } - - - - - - - } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java new file mode 100644 index 00000000..9372d78e --- /dev/null +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java @@ -0,0 +1,81 @@ +/******************************************************************************* + * Copyright (C) 2014 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 . + ******************************************************************************/ +package jsprit.core.algorithm.state; + +import jsprit.core.problem.cost.VehicleRoutingTransportCosts; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.ActivityVisitor; +import jsprit.core.problem.solution.route.activity.TourActivity; + + +/** + * Updates arrival and end times of activities. + * + *

Note that this modifies arrTime and endTime of each activity in a route. + * + * @author stefan + * + */ +public class UpdateTimeSlack implements ActivityVisitor, StateUpdater{ + + private VehicleRoute route; + + private StateManager stateManager; + + private VehicleRoutingTransportCosts costs; + + private double prevTimeSlack; + + private double prevActDeparture; + + private TourActivity prevAct; + + public UpdateTimeSlack(StateManager stateManager, VehicleRoutingTransportCosts costs) { + this.stateManager = stateManager; + this.costs = costs; + } + + @Override + public void begin(VehicleRoute route) { + if(route.isEmpty()) return; + this.route = route; + prevActDeparture = route.getVehicle().getEarliestDeparture(); + TourActivity first = route.getActivities().get(0); + double latestArr = stateManager.getActivityState(first,route.getVehicle(),InternalStates.LATEST_OPERATION_START_TIME,Double.class); + double latest = latestArr - costs.getBackwardTransportCost(first.getLocation(),route.getStart().getLocation(),latestArr,route.getDriver(),route.getVehicle()); + prevTimeSlack = latest - prevActDeparture; + prevAct = route.getStart(); + } + + @Override + public void visit(TourActivity activity) { + double actArrTime = prevActDeparture + costs.getTransportTime(prevAct.getLocation(),activity.getLocation(),prevActDeparture,route.getDriver(),route.getVehicle()); + double actEarliestStart = Math.max(actArrTime,activity.getTheoreticalEarliestOperationStartTime()); + double actLatestStart = stateManager.getActivityState(activity,route.getVehicle(),InternalStates.LATEST_OPERATION_START_TIME,Double.class); + double latest_minus_earliest = actLatestStart - actEarliestStart; + double time_slack_ = Math.max(actArrTime + prevTimeSlack - activity.getTheoreticalEarliestOperationStartTime(),0); + double time_slack = Math.min(latest_minus_earliest,time_slack_); + stateManager.putInternalTypedActivityState(activity,route.getVehicle(), InternalStates.TIME_SLACK, time_slack); + prevTimeSlack = time_slack; + prevAct = activity; + prevActDeparture = actEarliestStart + activity.getOperationTime(); + } + + @Override + public void finish() {} + +} diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java index 7f0afa73..43b7186a 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateVehicleDependentPracticalTimeWindows.java @@ -19,15 +19,26 @@ package jsprit.core.algorithm.state; import jsprit.core.problem.Location; import jsprit.core.problem.cost.VehicleRoutingTransportCosts; +import jsprit.core.problem.solution.route.RouteVisitor; import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.ReverseActivityVisitor; import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.problem.vehicle.Vehicle; import java.util.Arrays; import java.util.Collection; +import java.util.Iterator; -public class UpdateVehicleDependentPracticalTimeWindows implements ReverseActivityVisitor, StateUpdater{ +public class UpdateVehicleDependentPracticalTimeWindows implements RouteVisitor, StateUpdater{ + + @Override + public void visit(VehicleRoute route) { + begin(route); + Iterator revIterator = route.getTourActivities().reverseActivityIterator(); + while(revIterator.hasNext()){ + visit(revIterator.next()); + } + finish(); + } public static interface VehiclesToUpdate { @@ -68,7 +79,7 @@ public class UpdateVehicleDependentPracticalTimeWindows implements ReverseActivi this.vehiclesToUpdate = vehiclesToUpdate; } - @Override + public void begin(VehicleRoute route) { this.route = route; vehicles = vehiclesToUpdate.get(route); @@ -78,7 +89,7 @@ public class UpdateVehicleDependentPracticalTimeWindows implements ReverseActivi } } - @Override + public void visit(TourActivity activity) { for(Vehicle vehicle : vehicles){ double latestArrTimeAtPrevAct = latest_arrTimes_at_prevAct[vehicle.getVehicleTypeIdentifier().getIndex()]; @@ -92,7 +103,7 @@ public class UpdateVehicleDependentPracticalTimeWindows implements ReverseActivi } } - @Override + public void finish() {} } diff --git a/jsprit-core/src/main/java/jsprit/core/problem/VehicleRoutingProblem.java b/jsprit-core/src/main/java/jsprit/core/problem/VehicleRoutingProblem.java index 57a4c376..584d6998 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/VehicleRoutingProblem.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/VehicleRoutingProblem.java @@ -18,7 +18,7 @@ package jsprit.core.problem; import jsprit.core.problem.cost.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts; -import jsprit.core.problem.driver.Driver; +import jsprit.core.problem.cost.WaitingTimeCosts; import jsprit.core.problem.job.Job; import jsprit.core.problem.job.Service; import jsprit.core.problem.job.Shipment; @@ -75,19 +75,7 @@ public class VehicleRoutingProblem { private VehicleRoutingTransportCosts transportCosts; - private VehicleRoutingActivityCosts activityCosts = new VehicleRoutingActivityCosts() { - - @Override - public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { - return 0; - } - - @Override - public String toString() { - return "[name=defaultActivityCosts]"; - } - - }; + private VehicleRoutingActivityCosts activityCosts = new WaitingTimeCosts(); private Map jobs = new LinkedHashMap(); diff --git a/jsprit-core/src/main/java/jsprit/core/problem/cost/WaitingTimeCosts.java b/jsprit-core/src/main/java/jsprit/core/problem/cost/WaitingTimeCosts.java new file mode 100644 index 00000000..91103616 --- /dev/null +++ b/jsprit-core/src/main/java/jsprit/core/problem/cost/WaitingTimeCosts.java @@ -0,0 +1,20 @@ +package jsprit.core.problem.cost; + +import jsprit.core.problem.driver.Driver; +import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.problem.vehicle.Vehicle; + +/** + * Created by schroeder on 23/07/15. + */ +public class WaitingTimeCosts implements VehicleRoutingActivityCosts { + + @Override + public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { + if(vehicle != null){ + return vehicle.getType().getVehicleCostParams().perWaitingTimeUnit * Math.max(0.,tourAct.getTheoreticalEarliestOperationStartTime()-arrivalTime); + } + return 0; + } + +} diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/InfiniteVehicles.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/InfiniteVehicles.java index 800751e0..7212e2d1 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/InfiniteVehicles.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/InfiniteVehicles.java @@ -47,7 +47,7 @@ class InfiniteVehicles implements VehicleFleetManager{ private void extractTypes(Collection vehicles) { for(Vehicle v : vehicles){ - VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(),v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills()); + VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(),v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills(), v.isReturnToDepot()); types.put(typeKey,v); // sortedTypes.add(typeKey); } @@ -83,7 +83,7 @@ class InfiniteVehicles implements VehicleFleetManager{ @Override public Collection getAvailableVehicles(Vehicle withoutThisType) { Collection vehicles = new ArrayList(); - VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills()); + VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills(), withoutThisType.isReturnToDepot()); for(VehicleTypeKey key : types.keySet()){ if(!key.equals(thisKey)){ vehicles.add(types.get(key)); diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleFleetManagerImpl.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleFleetManagerImpl.java index e5786b66..9defc0d3 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleFleetManagerImpl.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleFleetManagerImpl.java @@ -96,7 +96,7 @@ class VehicleFleetManagerImpl implements VehicleFleetManager { if(v.getType() == null){ throw new IllegalStateException("vehicle needs type"); } - VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills()); + VehicleTypeKey typeKey = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills(),v.isReturnToDepot() ); if(!typeMapOfAvailableVehicles.containsKey(typeKey)){ typeMapOfAvailableVehicles.put(typeKey, new TypeContainer()); } @@ -105,7 +105,7 @@ class VehicleFleetManagerImpl implements VehicleFleetManager { } private void removeVehicle(Vehicle v){ - VehicleTypeKey key = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills()); + VehicleTypeKey key = new VehicleTypeKey(v.getType().getTypeId(), v.getStartLocation().getId(), v.getEndLocation().getId(), v.getEarliestDeparture(), v.getLatestArrival(), v.getSkills(),v.isReturnToDepot() ); if(typeMapOfAvailableVehicles.containsKey(key)){ typeMapOfAvailableVehicles.get(key).remove(v); } @@ -137,7 +137,7 @@ class VehicleFleetManagerImpl implements VehicleFleetManager { @Override public Collection getAvailableVehicles(Vehicle withoutThisType) { List vehicles = new ArrayList(); - VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills()); + VehicleTypeKey thisKey = new VehicleTypeKey(withoutThisType.getType().getTypeId(), withoutThisType.getStartLocation().getId(), withoutThisType.getEndLocation().getId(), withoutThisType.getEarliestDeparture(), withoutThisType.getLatestArrival(), withoutThisType.getSkills(),withoutThisType.isReturnToDepot() ); for(VehicleTypeKey key : typeMapOfAvailableVehicles.keySet()){ if(key.equals(thisKey)) continue; if(!typeMapOfAvailableVehicles.get(key).isEmpty()){ diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java index dcd3ee0c..acb6a2f7 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java @@ -298,7 +298,7 @@ public class VehicleImpl extends AbstractVehicle{ endLocation = builder.endLocation; startLocation = builder.startLocation; hasVariableDepartureTime = builder.hasVariableDepartureTime; - setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(),startLocation.getId(),endLocation.getId(),earliestDeparture,latestArrival,skills)); + setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(),startLocation.getId(),endLocation.getId(),earliestDeparture,latestArrival,skills, returnToDepot)); } /** diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeImpl.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeImpl.java index fe1d5d34..8ebb56e5 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeImpl.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeImpl.java @@ -42,19 +42,32 @@ public class VehicleTypeImpl implements VehicleType { } public final double fix; + @Deprecated public final double perTimeUnit; + public final double perTransportTimeUnit; public final double perDistanceUnit; + public final double perWaitingTimeUnit; private VehicleCostParams(double fix, double perTimeUnit,double perDistanceUnit) { super(); this.fix = fix; this.perTimeUnit = perTimeUnit; + this.perTransportTimeUnit = perTimeUnit; this.perDistanceUnit = perDistanceUnit; + this.perWaitingTimeUnit = 0.; } - + + public VehicleCostParams(double fix, double perTimeUnit, double perDistanceUnit, double perWaitingTimeUnit) { + this.fix = fix; + this.perTimeUnit = perTimeUnit; + this.perTransportTimeUnit = perTimeUnit; + this.perDistanceUnit = perDistanceUnit; + this.perWaitingTimeUnit = perWaitingTimeUnit; + } + @Override public String toString() { - return "[fixed="+fix+"][perTime="+perTimeUnit+"][perDistance="+perDistanceUnit+"]"; + return "[fixed="+fix+"][perTime="+perTransportTimeUnit+"][perDistance="+perDistanceUnit+"][perWaitingTimeUnit="+perWaitingTimeUnit+"]"; } } @@ -65,7 +78,9 @@ public class VehicleTypeImpl implements VehicleType { * */ public static class Builder{ - + + + public static VehicleTypeImpl.Builder newInstance(String id) { if(id==null) throw new IllegalStateException(); return new Builder(id); @@ -80,6 +95,7 @@ public class VehicleTypeImpl implements VehicleType { private double fixedCost = 0.0; private double perDistance = 1.0; private double perTime = 0.0; + private double perWaitingTime = 0.0; private String profile = "car"; @@ -143,12 +159,46 @@ public class VehicleTypeImpl implements VehicleType { * @param perTime * @return this builder * @throws IllegalStateException if costPerTime is smaller than zero + * @deprecated use .setCostPerTransportTime(..) instead */ + @Deprecated public VehicleTypeImpl.Builder setCostPerTime(double perTime){ if(perTime < 0.0) throw new IllegalStateException(); this.perTime = perTime; return this; } + + /** + * Sets cost per time unit, for instance € per second. + * + *

by default it is 0.0 + * + * @param perTime + * @return this builder + * @throws IllegalStateException if costPerTime is smaller than zero + * + */ + public VehicleTypeImpl.Builder setCostPerTransportTime(double perTime){ + if(perTime < 0.0) throw new IllegalStateException(); + this.perTime = perTime; + return this; + } + + /** + * Sets cost per waiting time unit, for instance € per second. + * + *

by default it is 0.0 + * + * @param perWaitingTime + * @return this builder + * @throws IllegalStateException if costPerTime is smaller than zero + * + */ + public VehicleTypeImpl.Builder setCostPerWaitingTime(double perWaitingTime){ + if(perWaitingTime < 0.0) throw new IllegalStateException(); + this.perWaitingTime = perWaitingTime; + return this; + } /** * Builds the vehicle-type. @@ -256,7 +306,7 @@ public class VehicleTypeImpl implements VehicleType { typeId = builder.id; capacity = builder.capacity; maxVelocity = builder.maxVelo; - vehicleCostParams = new VehicleCostParams(builder.fixedCost, builder.perTime, builder.perDistance); + vehicleCostParams = new VehicleCostParams(builder.fixedCost, builder.perTime, builder.perDistance, builder.perWaitingTime); capacityDimensions = builder.capacityDimensions; profile = builder.profile; } diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeKey.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeKey.java index ce050058..4a9c2c67 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeKey.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleTypeKey.java @@ -37,8 +37,9 @@ public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey{ public final double earliestStart; public final double latestEnd; public final Skills skills; + public final boolean returnToDepot; - public VehicleTypeKey(String typeId, String startLocationId, String endLocationId, double earliestStart, double latestEnd, Skills skills) { + public VehicleTypeKey(String typeId, String startLocationId, String endLocationId, double earliestStart, double latestEnd, Skills skills, boolean returnToDepot) { super(); this.type = typeId; this.startLocationId = startLocationId; @@ -46,17 +47,19 @@ public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey{ this.earliestStart = earliestStart; this.latestEnd = latestEnd; this.skills = skills; + this.returnToDepot=returnToDepot; } @Override public boolean equals(Object o) { if (this == o) return true; - if (!(o instanceof VehicleTypeKey)) return false; + if (o == null || getClass() != o.getClass()) return false; VehicleTypeKey that = (VehicleTypeKey) o; if (Double.compare(that.earliestStart, earliestStart) != 0) return false; if (Double.compare(that.latestEnd, latestEnd) != 0) return false; + if (returnToDepot != that.returnToDepot) return false; if (!endLocationId.equals(that.endLocationId)) return false; if (!skills.equals(that.skills)) return false; if (!startLocationId.equals(that.startLocationId)) return false; @@ -77,6 +80,7 @@ public class VehicleTypeKey extends AbstractVehicle.AbstractTypeKey{ temp = Double.doubleToLongBits(latestEnd); result = 31 * result + (int) (temp ^ (temp >>> 32)); result = 31 * result + skills.hashCode(); + result = 31 * result + (returnToDepot ? 1 : 0); return result; } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java index a9432fde..779d6e1a 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java @@ -13,16 +13,22 @@ import jsprit.core.problem.driver.Driver; import jsprit.core.problem.job.Service; import jsprit.core.problem.solution.SolutionCostCalculator; import jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import jsprit.core.problem.solution.route.VehicleRoute; import jsprit.core.problem.solution.route.activity.TimeWindow; import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.problem.vehicle.VehicleTypeImpl; +import jsprit.core.reporting.SolutionPrinter; import jsprit.core.util.CostFactory; +import jsprit.core.util.RandomNumberGeneration; import jsprit.core.util.Solutions; import junit.framework.Assert; import org.junit.Before; import org.junit.Test; +import java.util.Random; + /** * Created by schroeder on 22/07/15. */ @@ -42,7 +48,7 @@ public class VariableDepartureAndWaitingTime_IT { @Override public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { - return Math.max(0,tourAct.getTheoreticalEarliestOperationStartTime() - arrivalTime); + return vehicle.getType().getVehicleCostParams().perWaitingTimeUnit * Math.max(0,tourAct.getTheoreticalEarliestOperationStartTime() - arrivalTime); } }; @@ -138,6 +144,223 @@ public class VariableDepartureAndWaitingTime_IT { Assert.assertEquals(40.,solution.getCost()); } + @Test + public void variableDepartureShouldWork3(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(0,10)).setTimeWindow(TimeWindow.newInstance(10,10)).build(); + Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(5,15)).build(); + Service s3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance(10,10)).build(); + final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addJob(s1).addJob(s2).addJob(s3).addVehicle(v) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .setRoutingCost(CostFactory.createEuclideanCosts()) + .setActivityCosts(activityCosts) + .build(); + AlgorithmFactory algorithmFactory = new AlgorithmFactory() { + @Override + public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + + return Jsprit.Builder.newInstance(vrp) + .addCoreStateAndConstraintStuff(true) + .setStateAndConstraintManager(stateManager,constraintManager) + .setObjectiveFunction(new SolutionCostCalculator() { + @Override + public double getCosts(VehicleRoutingProblemSolution solution) { + SolutionAnalyser sa = new SolutionAnalyser(vrp, solution, new TransportDistance() { + @Override + public double getDistance(Location from, Location to) { + return vrp.getTransportCosts().getTransportCost(from, to, 0., null, null); + } + }); + return sa.getWaitingTime() + sa.getDistance(); + } + }) + .buildAlgorithm(); + } + }; + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + vra.setMaxIterations(100); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + System.out.println("c: " + solution.getCost()); + Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); + Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); + Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); + } + + @Test + public void variableDepartureShouldWork4(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.0).setCostPerWaitingTime(1.).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setHasVariableDepartureTime(false).setStartLocation(Location.newInstance(0, 0)).build(); + Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(0,10)).setTimeWindow(TimeWindow.newInstance(15,15)).build(); + Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(0,11)).setTimeWindow(TimeWindow.newInstance(100,100)).build(); + Service s3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance(10,10)).build(); + final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addJob(s1).addJob(s2).addJob(s3).addVehicle(v) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .setRoutingCost(CostFactory.createEuclideanCosts()) + .build(); + AlgorithmFactory algorithmFactory = new AlgorithmFactory() { + @Override + public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + + return Jsprit.Builder.newInstance(vrp) + .addCoreStateAndConstraintStuff(true) + .setStateAndConstraintManager(stateManager,constraintManager) + .setObjectiveFunction(new SolutionCostCalculator() { + @Override + public double getCosts(VehicleRoutingProblemSolution solution) { + double costs = 0.; + for(VehicleRoute route : solution.getRoutes()){ + costs += route.getVehicle().getType().getVehicleCostParams().fix; + TourActivity prevAct = route.getStart(); + for(TourActivity act : route.getActivities()){ + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); + costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle()); + prevAct = act; + } + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); + } + costs += solution.getUnassignedJobs().size() * 1000; + return costs; + } + }) + .buildAlgorithm(); + } + }; + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + vra.setMaxIterations(100); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + System.out.println("c: " + solution.getCost()); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); + Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); + Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); + Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); + } + + @Test + public void variableDepartureShouldWork5(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.0).setCostPerWaitingTime(1.0).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(0,10)).setTimeWindow(TimeWindow.newInstance(15,15)).build(); + Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(0,11)).setTimeWindow(TimeWindow.newInstance(100,100)).build(); + Service s3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance(10,10)).build(); + final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() + .addJob(s1).addJob(s2).addJob(s3).addVehicle(v).addVehicle(v2) + .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) + .setRoutingCost(CostFactory.createEuclideanCosts()) + .build(); + AlgorithmFactory algorithmFactory = new AlgorithmFactory() { + @Override + public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + + return Jsprit.Builder.newInstance(vrp) + .addCoreStateAndConstraintStuff(true) + .setStateAndConstraintManager(stateManager,constraintManager) + .setObjectiveFunction(new SolutionCostCalculator() { + @Override + public double getCosts(VehicleRoutingProblemSolution solution) { + double costs = 0.; + for(VehicleRoute route : solution.getRoutes()){ + costs += route.getVehicle().getType().getVehicleCostParams().fix; + TourActivity prevAct = route.getStart(); + for(TourActivity act : route.getActivities()){ + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); + costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle()); + prevAct = act; + } + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); + } + costs += solution.getUnassignedJobs().size() * 1000; + return costs; + } + }) + .buildAlgorithm(); + } + }; + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + vra.setMaxIterations(100); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + System.out.println("c: " + solution.getCost()); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); +// Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); +// Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); +// Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); + } + + @Test + public void variableDepartureShouldWork6(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.0).setCostPerWaitingTime(1.0).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); + Random r = RandomNumberGeneration.newInstance(); + for(int i=0;i<10;i++){ + Service s = Service.Builder.newInstance("s"+i).setServiceTime(5).setLocation(Location.newInstance(0, 10 + r.nextInt(10))).build(); + vrpBuilder.addJob(s); + } + Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(10,21)).setTimeWindow(TimeWindow.newInstance(100,110)).build(); + Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10,10)).setTimeWindow(TimeWindow.newInstance(300,310)).build(); + vrpBuilder.addJob(s2).addJob(s3).addVehicle(v).addVehicle(v2); + vrpBuilder.setRoutingCost(CostFactory.createEuclideanCosts()); + vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); + final VehicleRoutingProblem vrp = vrpBuilder.build(); +// final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() +// .addJob(s1).addJob(s2).addJob(s3).addVehicle(v).addVehicle(v2) +// .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) +// .setRoutingCost(CostFactory.createEuclideanCosts()) +// .build(); + AlgorithmFactory algorithmFactory = new AlgorithmFactory() { + @Override + public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + + return Jsprit.Builder.newInstance(vrp) + .addCoreStateAndConstraintStuff(true) + .setStateAndConstraintManager(stateManager,constraintManager) + .setObjectiveFunction(new SolutionCostCalculator() { + @Override + public double getCosts(VehicleRoutingProblemSolution solution) { + double costs = 0.; + for(VehicleRoute route : solution.getRoutes()){ + costs += route.getVehicle().getType().getVehicleCostParams().fix; + TourActivity prevAct = route.getStart(); + for(TourActivity act : route.getActivities()){ + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); + costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle()); + prevAct = act; + } + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); + } + costs += solution.getUnassignedJobs().size() * 1000; + return costs; + } + }) + .buildAlgorithm(); + } + }; + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + vra.setMaxIterations(100); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + System.out.println("c: " + solution.getCost()); + SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); +// Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); +// Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); +// Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); + } + + } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java index 3d9bfaad..60fc929a 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java @@ -95,7 +95,7 @@ public class ServiceInsertionAndLoadConstraintsTest { routingCosts = CostFactory.createManhattanCosts(); VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build(); vehicle = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("0,0")).setType(type).build(); - activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts); + activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, null); createInsertionCalculator(hardRouteLevelConstraint); vehicleRoutingProblem = mock(VehicleRoutingProblem.class); } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java index 94dea056..237a8fab 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java @@ -94,7 +94,7 @@ public class ShipmentInsertionCalculatorTest { routingCosts = CostFactory.createManhattanCosts(); VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build(); vehicle = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("0,0")).setType(type).build(); - activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts); + activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, null); createInsertionCalculator(hardRouteLevelConstraint); vehicleRoutingProblem = mock(VehicleRoutingProblem.class); } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestCalculatesServiceInsertion.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestCalculatesServiceInsertion.java index 3527e5bc..6fdb1962 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestCalculatesServiceInsertion.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestCalculatesServiceInsertion.java @@ -132,7 +132,7 @@ public class TestCalculatesServiceInsertion { VehicleRoutingActivityCosts actCosts = mock(VehicleRoutingActivityCosts.class); - serviceInsertion = new ServiceInsertionCalculator(costs, new LocalActivityInsertionCostsCalculator(costs, actCosts), cManager); + serviceInsertion = new ServiceInsertionCalculator(costs, new LocalActivityInsertionCostsCalculator(costs, actCosts, states), cManager); serviceInsertion.setJobActivityFactory(new JobActivityFactory() { @Override public List createActivities(Job job) { diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java index 92b02a7d..d7509353 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java @@ -16,14 +16,20 @@ ******************************************************************************/ package jsprit.core.algorithm.recreate; +import jsprit.core.algorithm.state.StateManager; import jsprit.core.problem.Location; +import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.cost.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts; +import jsprit.core.problem.cost.WaitingTimeCosts; +import jsprit.core.problem.job.Service; import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.End; -import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.problem.solution.route.activity.*; import jsprit.core.problem.vehicle.Vehicle; +import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.problem.vehicle.VehicleTypeImpl; +import jsprit.core.util.CostFactory; import org.junit.Before; import org.junit.Test; @@ -66,7 +72,7 @@ public class TestLocalActivityInsertionCostsCalculator { when(tpCosts.getTransportTime(loc("k"), loc("j"), 0.0, null, vehicle)).thenReturn(0.0); actCosts = mock(VehicleRoutingActivityCosts.class); - calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts); + calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts, null); } private Location loc(String i) { @@ -130,4 +136,111 @@ public class TestLocalActivityInsertionCostsCalculator { double costs = calc.getCosts(jic, prevAct, nextAct, newAct, 0.0); assertEquals(3.0,costs,0.01); } + + @Test + public void test(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0, 0)).build(); + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(60, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build(); + ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); + ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(), new StateManager(mock(VehicleRoutingProblem.class))); + calc.setSolutionCompletenessRatio(1.); + calc.setVariableStartTimeFactor(.8); + double c = calc.getCosts(context,prevAct,nextAct,newAct,0); + assertEquals(40.,c,0.01); + } + +// @Test +// public void test_(){ +// VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); +// VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0, 0)).build(); +// Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); +// Service newS = Service.Builder.newInstance("new").setLocation(Location.newInstance(40, 0)).build(); +// Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(140,150)).build(); +// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); +// ServiceActivity newAct = ServiceActivity.newInstance(newS); +// ServiceActivity nextAct = ServiceActivity.newInstance(nextS); +// VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); +// JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); +// LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(mock(VehicleRoutingProblem.class)) ); +// calc.setSolutionCompletenessRatio(1.); +//// calc.setVariableStartTimeFactor(1.); +// double c = calc.getCosts(context,prevAct,nextAct,newAct,0); +// assertEquals(0.,c,0.01); +// } + + @Test + public void test2(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// +// Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)) + .setTimeWindow(TimeWindow.newInstance(40,50)).build(); + Start prevAct = new Start(Location.newInstance(0,0),0,100); +// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); + ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(nextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(mock(VehicleRoutingProblem.class)) ); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,0); + assertEquals(-10.,c,0.01); + } + + @Test + public void test3(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + +// VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)) + .setTimeWindow(TimeWindow.newInstance(140,150)).build(); + Start prevAct = new Start(Location.newInstance(0,0),0,100); +// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); + ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + VehicleRoute route = VehicleRoute.Builder.newInstance(v2).addService(nextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v2,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(), null); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,0); + assertEquals(-10.,c,0.01); + } + + @Test + public void test4(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).setTimeWindow(TimeWindow.newInstance(100,150)).build(); +// Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build(); + Start prevAct = new Start(Location.newInstance(0,0),0,100); +// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); + End nextAct = new End(Location.newInstance(0,0),0,100); +// ServiceActivity nextAct = ServiceActivity.newInstance(nextS); +// ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,0); + assertEquals(110.,c,0.01); + } } + diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java index 7f1c9e9d..0258427f 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java @@ -1,13 +1,14 @@ package jsprit.core.algorithm.state; import jsprit.core.problem.Location; -import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.job.Service; +import jsprit.core.problem.solution.route.RouteVisitor; import jsprit.core.problem.solution.route.VehicleRoute; import jsprit.core.problem.solution.route.activity.TimeWindow; import jsprit.core.problem.vehicle.VehicleImpl; import jsprit.core.util.CostFactory; import junit.framework.Assert; +import org.junit.Before; import org.junit.Test; /** @@ -15,83 +16,111 @@ import org.junit.Test; */ public class UpdateDepartureTimeTest { + RouteVisitor revVisitors; + + @Before + public void doBefore(){ + revVisitors = new UpdateDepartureTime(CostFactory.createManhattanCosts()); + } + @Test public void whenNoTimeWindow_departureTimeShouldBeEarliestStartTime(){ - VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build(); Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance(10,0)).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - - UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); - udt.visit(route); + revVisitors.visit(route); Assert.assertEquals(0.,route.getDepartureTime()); } @Test public void whenNoTimeWindow_departureTimeShouldBeEarliestStartTime2(){ - VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(10).setStartLocation(Location.newInstance(0, 0)).build(); Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance(10,0)).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - - UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); - udt.visit(route); + revVisitors.visit(route); Assert.assertEquals(10.,route.getDepartureTime()); } @Test public void whenTimeWindowAndNoWaitingTime_departureTimeShouldBeEarliestStartTime1(){ - VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(5,20)).setLocation(Location.newInstance(10, 0)).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - - UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); - udt.visit(route); + revVisitors.visit(route); Assert.assertEquals(0.,route.getDepartureTime()); } @Test public void whenTimeWindowAndNoWaitingTime_departureTimeShouldBeEarliestStartTime2(){ - VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(10).setStartLocation(Location.newInstance(0,0)).build(); Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(5,20)).setLocation(Location.newInstance(10, 0)).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - - UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); - udt.visit(route); + revVisitors.visit(route); Assert.assertEquals(10.,route.getDepartureTime()); } @Test public void whenTimeWindowAndWaitingTime_departureTimeShouldChange(){ - VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(0) .setHasVariableDepartureTime(true) .setStartLocation(Location.newInstance(0,0)).build(); Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(15,20)).setLocation(Location.newInstance(10, 0)).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - - UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); - udt.visit(route); + revVisitors.visit(route); Assert.assertEquals(5.,route.getDepartureTime()); } @Test public void whenTimeWindowAndWaitingTime_departureTimeShouldChange2(){ - VehicleRoutingTransportCosts routingCosts = CostFactory.createManhattanCosts(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(5).setStartLocation(Location.newInstance(0,0)).build(); Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(18,20)).setLocation(Location.newInstance(10, 0)).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - - UpdateDepartureTime udt = new UpdateDepartureTime(routingCosts); - udt.visit(route); + revVisitors.visit(route); Assert.assertEquals(8.,route.getDepartureTime()); } + + @Test + public void whenTimeWindowAndWaitingTime_departureTimeShouldChange3(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s") + .setTimeWindow(TimeWindow.newInstance(15, 20)).setLocation(Location.newInstance(10, 0)).build(); + Service s2 = Service.Builder.newInstance("s2") + .setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance(20, 0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).addService(s2).build(); + revVisitors.visit(route); + + Assert.assertEquals(5.,route.getDepartureTime()); + } + + @Test + public void whenTimeWindowAndWaitingTime_departureTimeShouldChange4(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s") + .setTimeWindow(TimeWindow.newInstance(15, 20)).setLocation(Location.newInstance(10, 0)).build(); + Service s2 = Service.Builder.newInstance("s2") + .setTimeWindow(TimeWindow.newInstance(29,40)).setLocation(Location.newInstance(20, 0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).addService(s2).build(); + revVisitors.visit(route); + + Assert.assertEquals(9.,route.getDepartureTime()); + } + + @Test + public void whenTimeWindowAndWaitingTime_departureTimeShouldChange5(){ + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); + Service s = Service.Builder.newInstance("s") + .setTimeWindow(TimeWindow.newInstance(15, 20)).setLocation(Location.newInstance(10, 0)).build(); + Service s2 = Service.Builder.newInstance("s2") + .setTimeWindow(TimeWindow.newInstance(35,40)).setLocation(Location.newInstance(20, 0)).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).addService(s2).build(); + revVisitors.visit(route); + + Assert.assertEquals(10.,route.getDepartureTime()); + } } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java new file mode 100644 index 00000000..62b7d3b0 --- /dev/null +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java @@ -0,0 +1,119 @@ +package jsprit.core.algorithm.state; + +import jsprit.core.problem.Location; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.job.Service; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.TimeWindow; +import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.problem.vehicle.VehicleType; +import jsprit.core.problem.vehicle.VehicleTypeImpl; +import jsprit.core.util.CostFactory; +import junit.framework.Assert; +import org.junit.Test; + +import java.util.Arrays; + +/** + * Created by schroeder on 29/07/15. + */ +public class UpdateTimeSlackTest { + + + @Test + public void test_withoutTW(){ + VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); + VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); + Service service = Service.Builder.newInstance("s").setLocation(Location.newInstance("0,10")).build(); + Service service2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance("10,10")).build(); + Service service3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance("10,0")).build(); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) + .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); + + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); + stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); + stateManager.informInsertionStarts(Arrays.asList(route), null); + + double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + Assert.assertEquals(160.,timeSlack_act1); + Assert.assertEquals(160.,timeSlack_act2); + Assert.assertEquals(160.,timeSlack_act3); + } + + @Test + public void test_TW(){ + VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); + VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); + Service service = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance("0,10")).build(); + Service service2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(0, 40)).setLocation(Location.newInstance("10,10")).build(); + Service service3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(80, 120)).setLocation(Location.newInstance("10,0")).build(); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) + .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); + + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); + stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); + stateManager.informInsertionStarts(Arrays.asList(route), null); + + double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + Assert.assertEquals(20.,timeSlack_act1); + Assert.assertEquals(20.,timeSlack_act2); + Assert.assertEquals(0.,timeSlack_act3); + } + + @Test + public void test_TW2(){ + VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); + VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); + Service service = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance("0,10")).build(); + Service service2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(0,40)).setLocation(Location.newInstance("10,10")).build(); + Service service3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(40,120)).setLocation(Location.newInstance("10,0")).build(); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) + .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); + + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); + stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); + stateManager.informInsertionStarts(Arrays.asList(route), null); + + double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + Assert.assertEquals(20.,timeSlack_act1); + Assert.assertEquals(20.,timeSlack_act2); + Assert.assertEquals(10.,timeSlack_act3); + } + + @Test + public void test_TW3(){ + VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); + VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); + Service service = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance("0,10")).build(); + Service service2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(30,60)).setLocation(Location.newInstance("10,10")).build(); + Service service3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(40,120)).setLocation(Location.newInstance("10,0")).build(); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) + .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); + VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); + + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); + stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); + stateManager.informInsertionStarts(Arrays.asList(route), null); + + double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); + Assert.assertEquals(30.,timeSlack_act1); + Assert.assertEquals(20.,timeSlack_act2); + Assert.assertEquals(20.,timeSlack_act3); + } + +} From adeceb2640dff72cd56733a523e52fa220d3eef1 Mon Sep 17 00:00:00 2001 From: oblonski Date: Wed, 29 Jul 2015 21:18:22 +0200 Subject: [PATCH 3/7] add example for variable start and waiting time --- .../VariableStartAndWaitingTimeExample.java | 107 ++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java diff --git a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java new file mode 100644 index 00000000..915b5d78 --- /dev/null +++ b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java @@ -0,0 +1,107 @@ +package jsprit.examples; + +import jsprit.analysis.toolbox.AlgorithmSearchProgressChartListener; +import jsprit.analysis.toolbox.Plotter; +import jsprit.core.algorithm.VehicleRoutingAlgorithm; +import jsprit.core.algorithm.box.Jsprit; +import jsprit.core.algorithm.state.StateManager; +import jsprit.core.algorithm.state.UpdateDepartureTime; +import jsprit.core.algorithm.state.UpdateTimeSlack; +import jsprit.core.problem.Location; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.constraint.ConstraintManager; +import jsprit.core.problem.job.Service; +import jsprit.core.problem.solution.SolutionCostCalculator; +import jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.TimeWindow; +import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.problem.vehicle.VehicleTypeImpl; +import jsprit.core.reporting.SolutionPrinter; +import jsprit.core.util.RandomNumberGeneration; +import jsprit.core.util.Solutions; + +import java.util.Random; + +/** + * Created by schroeder on 23/07/15. + */ +public class VariableStartAndWaitingTimeExample { + + static interface AlgorithmFactory { + VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp); + } + + public static void main(String[] args) { + + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.5).setCostPerWaitingTime(1.0).build(); + + VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true) + .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type).setReturnToDepot(true) + .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type).setReturnToDepot(true) + .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); + Random r = RandomNumberGeneration.newInstance(); + for(int i=0;i<20;i++){ + Service s = Service.Builder.newInstance("s_"+i) +// .setTimeWindow(TimeWindow.newInstance(r.nextInt(50),100+r.nextInt(150))) + .setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build(); + vrpBuilder.addJob(s); + } + Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-3, 15)).setTimeWindow(TimeWindow.newInstance(20, 40)).build(); +// Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(5,15)).setTimeWindow(TimeWindow.newInstance(100, 160)).build(); + Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(200, 210)).build(); + Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10, 10)).setTimeWindow(TimeWindow.newInstance(300, 310)).build(); + vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addVehicle(v4).addVehicle(v2).addVehicle(v3); + vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); + final VehicleRoutingProblem vrp = vrpBuilder.build(); + + AlgorithmFactory algorithmFactory = new AlgorithmFactory() { + @Override + public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts())); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + + return Jsprit.Builder.newInstance(vrp) + .addCoreStateAndConstraintStuff(true) + .setStateAndConstraintManager(stateManager, constraintManager) + .setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.1") + .setProperty(Jsprit.Parameter.THRESHOLD_ALPHA, "0.3") +// .setProperty(Parameter.) +// .setProperty(Jsprit.Parameter.CONSTRUCTION, Jsprit.Construction.BEST_INSERTION.toString()) + .setObjectiveFunction(new SolutionCostCalculator() { + @Override + public double getCosts(VehicleRoutingProblemSolution solution) { + double costs = 0.; + for (VehicleRoute route : solution.getRoutes()) { + costs += route.getVehicle().getType().getVehicleCostParams().fix; + TourActivity prevAct = route.getStart(); + for (TourActivity act : route.getActivities()) { + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), act.getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle()); + costs += vrp.getActivityCosts().getActivityCost(act, act.getArrTime(), route.getDriver(), route.getVehicle()); + prevAct = act; + } + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), route.getEnd().getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle()); + } + costs += solution.getUnassignedJobs().size() * 200; + return costs; + } + }) + .buildAlgorithm(); + } + }; + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + vra.setMaxIterations(1000); + vra.addListener(new AlgorithmSearchProgressChartListener("output/search")); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + System.out.println("c: " + solution.getCost()); + SolutionPrinter.print(vrp, solution, SolutionPrinter.Print.VERBOSE); + + new Plotter(vrp,solution).setLabel(Plotter.Label.ID).plot("output/plot","plot"); + } +} From 9717926b8e7ece39b11c55a709a967330f4983a5 Mon Sep 17 00:00:00 2001 From: oblonski Date: Thu, 30 Jul 2015 21:24:54 +0200 Subject: [PATCH 4/7] refine insertion calc --- ...LocalActivityInsertionCostsCalculator.java | 11 +- .../core/algorithm/state/InternalStates.java | 2 + .../state/UpdateFutureWaitingTimes.java | 60 ++++ ...LocalActivityInsertionCostsCalculator.java | 325 ++++++++++++++++-- .../VariableStartAndWaitingTimeExample.java | 19 +- 5 files changed, 375 insertions(+), 42 deletions(-) create mode 100644 jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateFutureWaitingTimes.java diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java index 276026c6..eb7054ae 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java @@ -95,6 +95,7 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal double tp_costs_newAct_nextAct = routingCosts.getTransportCost(newAct.getLocation(), nextAct.getLocation(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); double tp_time_newAct_nextAct = routingCosts.getTransportTime(newAct.getLocation(), nextAct.getLocation(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); double nextAct_arrTime = newAct_endTime + tp_time_newAct_nextAct; + double endTime_nextAct_new = CalculationUtils.getActivityEndTime(nextAct_arrTime, nextAct); double act_costs_nextAct = activityCosts.getActivityCost(nextAct, nextAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); if(hasVariableDeparture(iFacts.getNewVehicle())){ @@ -110,7 +111,8 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal } else{ double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); - double arrTime_nextAct = prevAct.getEndTime() + routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); + double arrTime_nextAct = depTimeAtPrevAct + routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); + double endTime_nextAct_old = CalculationUtils.getActivityEndTime(arrTime_nextAct,nextAct); double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); if(isStart(prevAct) && hasVariableDeparture(iFacts.getRoute().getVehicle())) { actCost_nextAct = 0; @@ -118,7 +120,12 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal else if(hasVariableDeparture(iFacts.getRoute().getVehicle())){ actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct + slack_time_prev, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); } - oldCosts = tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; + double endTimeDelay_nextAct = Math.max(0,endTime_nextAct_new - endTime_nextAct_old); + Double futureWaiting = stateManager.getActivityState(nextAct,iFacts.getRoute().getVehicle(),InternalStates.FUTURE_WAITING,Double.class); + if(futureWaiting == null) futureWaiting = 0.; + double waitingTime_savings_timeUnit = Math.min(futureWaiting,endTimeDelay_nextAct); + double waitingTime_savings = waitingTime_savings_timeUnit * iFacts.getRoute().getVehicle().getType().getVehicleCostParams().perWaitingTimeUnit; + oldCosts = tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * ( actCost_nextAct + waitingTime_savings); } return totalCosts - oldCosts; } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java index a210fc8b..c22e3839 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java @@ -46,4 +46,6 @@ public class InternalStates { public static final StateId WAITING = new StateFactory.StateIdImpl("waiting",11); public static final StateId TIME_SLACK = new StateFactory.StateIdImpl("time_slack",12); + + public static final StateId FUTURE_WAITING = new StateFactory.StateIdImpl("future_waiting",13); } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateFutureWaitingTimes.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateFutureWaitingTimes.java new file mode 100644 index 00000000..61b99284 --- /dev/null +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateFutureWaitingTimes.java @@ -0,0 +1,60 @@ +/******************************************************************************* + * Copyright (C) 2014 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 . + ******************************************************************************/ +package jsprit.core.algorithm.state; + +import jsprit.core.problem.cost.VehicleRoutingTransportCosts; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.ReverseActivityVisitor; +import jsprit.core.problem.solution.route.activity.TourActivity; + +/** + * Updates and memorizes latest operation start times at activities. + * + * @author schroeder + * + */ +public class UpdateFutureWaitingTimes implements ReverseActivityVisitor, StateUpdater{ + + private StateManager states; + + private VehicleRoute route; + + private VehicleRoutingTransportCosts transportCosts; + + private double futureWaiting; + + public UpdateFutureWaitingTimes(StateManager states, VehicleRoutingTransportCosts tpCosts) { + super(); + this.states = states; + this.transportCosts = tpCosts; + } + + @Override + public void begin(VehicleRoute route) { + this.route = route; + this.futureWaiting = 0.; + } + + @Override + public void visit(TourActivity activity) { + states.putInternalTypedActivityState(activity,route.getVehicle(),InternalStates.FUTURE_WAITING,futureWaiting); + futureWaiting += Math.max(activity.getTheoreticalEarliestOperationStartTime() - activity.getArrTime(),0); + } + + @Override + public void finish() {} +} diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java index d7509353..91c0bd75 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java @@ -16,12 +16,13 @@ ******************************************************************************/ package jsprit.core.algorithm.recreate; -import jsprit.core.algorithm.state.StateManager; +import jsprit.core.algorithm.state.*; import jsprit.core.problem.Location; import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.cost.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.WaitingTimeCosts; +import jsprit.core.problem.job.Job; import jsprit.core.problem.job.Service; import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.solution.route.VehicleRoute; @@ -33,6 +34,9 @@ import jsprit.core.util.CostFactory; import org.junit.Before; import org.junit.Test; +import java.util.ArrayList; +import java.util.Arrays; + import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -156,38 +160,17 @@ public class TestLocalActivityInsertionCostsCalculator { assertEquals(40.,c,0.01); } -// @Test -// public void test_(){ -// VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); -// VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0, 0)).build(); -// Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); -// Service newS = Service.Builder.newInstance("new").setLocation(Location.newInstance(40, 0)).build(); -// Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(140,150)).build(); -// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); -// ServiceActivity newAct = ServiceActivity.newInstance(newS); -// ServiceActivity nextAct = ServiceActivity.newInstance(nextS); -// VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); -// JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); -// LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(mock(VehicleRoutingProblem.class)) ); -// calc.setSolutionCompletenessRatio(1.); -//// calc.setVariableStartTimeFactor(1.); -// double c = calc.getCosts(context,prevAct,nextAct,newAct,0); -// assertEquals(0.,c,0.01); -// } - @Test - public void test2(){ + public void whenAddingNewBetweenStartAndAct_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// -// Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build(); - Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)) - .setTimeWindow(TimeWindow.newInstance(40,50)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30, 0)) + .setTimeWindow(TimeWindow.newInstance(40, 50)).build(); Start prevAct = new Start(Location.newInstance(0,0),0,100); -// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); ServiceActivity nextAct = ServiceActivity.newInstance(nextS); VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(nextS).build(); @@ -199,10 +182,9 @@ public class TestLocalActivityInsertionCostsCalculator { } @Test - public void test3(){ + public void whenAddingNewBetweenStartAndAct2_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); -// VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build(); @@ -221,13 +203,13 @@ public class TestLocalActivityInsertionCostsCalculator { } @Test - public void test4(){ + public void whenAddingNewInEmptyRoute_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); // VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); - Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).setTimeWindow(TimeWindow.newInstance(100,150)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).setTimeWindow(TimeWindow.newInstance(100, 150)).build(); // Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build(); Start prevAct = new Start(Location.newInstance(0,0),0,100); // ServiceActivity prevAct = ServiceActivity.newInstance(prevS); @@ -242,5 +224,286 @@ public class TestLocalActivityInsertionCostsCalculator { double c = calc.getCosts(context,prevAct,nextAct,newAct,0); assertEquals(110.,c,0.01); } + + @Test + public void whenAddingNewBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10, 0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build(); + + ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); + ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(-10.,c,0.01); + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100, 120)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build(); + + ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); + ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + calc.setSolutionCompletenessRatio(0.5); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(35.,c,0.01); + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs2_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(400,500)).build(); + + ServiceActivity prevAct = ServiceActivity.newInstance(prevS); + ServiceActivity newAct = ServiceActivity.newInstance(newS); + ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).addService(afterNextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(-90.,c,0.01); + //360 + //270 + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs3_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80,500)).build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) + .addJob(afterNextS).addJob(afterAfterNextS).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); + + StateManager stateManager = getStateManager(vrp,route); + + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(20.,c,0.01); + //start-delay = new - old = 120 - 40 = 80 > future waiting time savings = 30 + 20 + 10 + //ref: 10 + 50 + 20 = 80 + //new: 80 - 10 - 30 - 20 = 20 + /* + w(new) + w(next) - w_old(next) - min{start_delay(next),future_waiting} + */ + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs4_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80,500)).build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) + .addJob(afterNextS).addJob(afterAfterNextS).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + + StateManager stateManager = getStateManager(vrp, route); + + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(30.,c,0.01); + //ref: 10 + 30 + 10 = 50 + //new: 50 - 50 = 0 + + /* + activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings + */ + /* + old = 10 + 30 + 10 = 50 + new = 80 + 0 - 10 - min{80,40} = 30 + */ + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs4WithVarStart_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80,500)).build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) + .addJob(afterNextS).addJob(afterAfterNextS).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + + StateManager stateManager = getStateManager(vrp, route); + + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(0.,c,0.01); + /* + activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings + */ + /* + old = 10 + 30 + 10 = 50 + new = 80 + 0 - 10 - min{80,40} = 30 + */ + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs3WithVarStart_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(50,70)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,70)).build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(50,100)).build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) + .addJob(afterNextS).addJob(afterAfterNextS).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + + StateManager stateManager = getStateManager(vrp, route); + + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(-10.,c,0.01); + /* + activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings + */ + /* + old = s:40,act1:50,act2:60,act3:70,act4:80 --> w=20 + new = s:30,act1:40,act2:50,act3:70,act4:80,act5:90 --> w=10 => -10 + */ + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs2WithVarStart_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(10,20)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,70)).build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(50,100)).build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) + .addJob(afterNextS).addJob(afterAfterNextS).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + + StateManager stateManager = getStateManager(vrp, route); + + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(20.,c,0.01); + /* + activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings + */ + /* + old = s:40,act1:50,act2:60,act3:70,act4:80 --> w=20 + new = s:0,act1:10,act2:20,act3:40,act4:50,act5:60 --> w=40 => 20 + */ + } + + private StateManager getStateManager(VehicleRoutingProblem vrp, VehicleRoute route) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList()); + return stateManager; + } } diff --git a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java index 915b5d78..20b0f6c5 100644 --- a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java +++ b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java @@ -35,25 +35,26 @@ public class VariableStartAndWaitingTimeExample { public static void main(String[] args) { - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.5).setCostPerWaitingTime(1.0).build(); + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(2.5).setCostPerWaitingTime(2.0).build(); +// VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(1.5).setCostPerWaitingTime(.0).build(); VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true) .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type).setReturnToDepot(true) .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type).setReturnToDepot(true) - .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + .setHasVariableDepartureTime(false).setStartLocation(Location.newInstance(0, 0)).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); Random r = RandomNumberGeneration.newInstance(); - for(int i=0;i<20;i++){ - Service s = Service.Builder.newInstance("s_"+i) + for(int i=0;i<40;i++){ + Service s = Service.Builder.newInstance("s_"+i).setServiceTime(0) // .setTimeWindow(TimeWindow.newInstance(r.nextInt(50),100+r.nextInt(150))) .setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build(); vrpBuilder.addJob(s); } - Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-3, 15)).setTimeWindow(TimeWindow.newInstance(20, 40)).build(); + Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-3, 15)).setTimeWindow(TimeWindow.newInstance(20, 60)).build(); // Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(5,15)).setTimeWindow(TimeWindow.newInstance(100, 160)).build(); - Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(200, 210)).build(); + Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(200, 250)).build(); Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10, 10)).setTimeWindow(TimeWindow.newInstance(300, 310)).build(); vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addVehicle(v4).addVehicle(v2).addVehicle(v3); vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); @@ -70,8 +71,8 @@ public class VariableStartAndWaitingTimeExample { return Jsprit.Builder.newInstance(vrp) .addCoreStateAndConstraintStuff(true) .setStateAndConstraintManager(stateManager, constraintManager) - .setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.1") - .setProperty(Jsprit.Parameter.THRESHOLD_ALPHA, "0.3") +// .setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.1") +// .setProperty(Jsprit.Parameter.THRESHOLD_ALPHA, "0.3") // .setProperty(Parameter.) // .setProperty(Jsprit.Parameter.CONSTRUCTION, Jsprit.Construction.BEST_INSERTION.toString()) .setObjectiveFunction(new SolutionCostCalculator() { @@ -96,7 +97,7 @@ public class VariableStartAndWaitingTimeExample { } }; VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - vra.setMaxIterations(1000); + vra.setMaxIterations(500); vra.addListener(new AlgorithmSearchProgressChartListener("output/search")); VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); System.out.println("c: " + solution.getCost()); From 70d6ae17974fca568f27ae8d0dae64812efd031a Mon Sep 17 00:00:00 2001 From: oblonski Date: Mon, 3 Aug 2015 09:15:52 +0200 Subject: [PATCH 5/7] further refine wainting time min --- ...LocalActivityInsertionCostsCalculator.java | 35 ++++--- .../core/algorithm/state/InternalStates.java | 2 + .../algorithm/state/UpdateDepartureTime.java | 9 +- .../VariableDepartureAndWaitingTime_IT.java | 10 +- ...LocalActivityInsertionCostsCalculator.java | 98 +++++++++++++++++-- .../state/UpdateDepartureTimeTest.java | 6 +- .../VariableStartAndWaitingTimeExample.java | 31 ++++-- .../VariableStartAndWaitingTimeExample2.java | 98 +++++++++++++++++++ 8 files changed, 251 insertions(+), 38 deletions(-) create mode 100644 jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java index eb7054ae..c8d004d1 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java @@ -45,7 +45,7 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal private VehicleRoutingActivityCosts activityCosts; - private double activityCostsWeight = 1.; + private double activityCostsWeight = 0.75; private double solutionCompletenessRatio = 1.; @@ -66,17 +66,12 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal @Override public double getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) { -// double waiting = 0; -// if(!isEnd(nextAct)){ -// waiting = stateManager.getActivityState(nextAct, InternalStates.WAITING,Double.class); -// } double tp_costs_prevAct_newAct = routingCosts.getTransportCost(prevAct.getLocation(), newAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double tp_time_prevAct_newAct = routingCosts.getTransportTime(prevAct.getLocation(), newAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double newAct_arrTime = depTimeAtPrevAct + tp_time_prevAct_newAct; double newAct_endTime = CalculationUtils.getActivityEndTime(newAct_arrTime, newAct); - double act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); double slack_time_new = 0; @@ -104,10 +99,10 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal double totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + solutionCompletenessRatio * activityCostsWeight * (act_costs_newAct + act_costs_nextAct); - double oldCosts; + double oldCosts = 0.; if(iFacts.getRoute().isEmpty()){ double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); - oldCosts = tp_costs_prevAct_nextAct; + oldCosts += tp_costs_prevAct_nextAct; } else{ double tp_costs_prevAct_nextAct = routingCosts.getTransportCost(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); @@ -119,13 +114,24 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal } else if(hasVariableDeparture(iFacts.getRoute().getVehicle())){ actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct + slack_time_prev, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); + Double earliestWithoutWaiting = stateManager.getActivityState(nextAct,iFacts.getRoute().getVehicle(),InternalStates.EARLIEST_WITHOUT_WAITING,Double.class); + if(earliestWithoutWaiting != null){ + double potentialArrivalTimeAtNewAct = earliestWithoutWaiting - routingCosts.getBackwardTransportTime(nextAct.getLocation(), newAct.getLocation(), earliestWithoutWaiting, iFacts.getRoute().getDriver(),iFacts.getRoute().getVehicle()) - newAct.getOperationTime(); + if(potentialArrivalTimeAtNewAct > newAct.getTheoreticalLatestOperationStartTime()){ + double delta = potentialArrivalTimeAtNewAct - newAct.getTheoreticalLatestOperationStartTime(); + totalCosts += solutionCompletenessRatio * activityCostsWeight * delta * iFacts.getNewVehicle().getType().getVehicleCostParams().perWaitingTimeUnit; + } + } } - double endTimeDelay_nextAct = Math.max(0,endTime_nextAct_new - endTime_nextAct_old); - Double futureWaiting = stateManager.getActivityState(nextAct,iFacts.getRoute().getVehicle(),InternalStates.FUTURE_WAITING,Double.class); - if(futureWaiting == null) futureWaiting = 0.; - double waitingTime_savings_timeUnit = Math.min(futureWaiting,endTimeDelay_nextAct); - double waitingTime_savings = waitingTime_savings_timeUnit * iFacts.getRoute().getVehicle().getType().getVehicleCostParams().perWaitingTimeUnit; - oldCosts = tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * ( actCost_nextAct + waitingTime_savings); + else { + double endTimeDelay_nextAct = Math.max(0, endTime_nextAct_new - endTime_nextAct_old); + Double futureWaiting = stateManager.getActivityState(nextAct, iFacts.getRoute().getVehicle(), InternalStates.FUTURE_WAITING, Double.class); + if (futureWaiting == null) futureWaiting = 0.; + double waitingTime_savings_timeUnit = Math.min(futureWaiting, endTimeDelay_nextAct); + double waitingTime_savings = waitingTime_savings_timeUnit * iFacts.getRoute().getVehicle().getType().getVehicleCostParams().perWaitingTimeUnit; + oldCosts += solutionCompletenessRatio * activityCostsWeight * waitingTime_savings; + } + oldCosts += tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; } return totalCosts - oldCosts; } @@ -151,6 +157,7 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal } public void setSolutionCompletenessRatio(double solutionCompletenessRatio) { +// this.solutionCompletenessRatio = 1.; this.solutionCompletenessRatio = solutionCompletenessRatio; } } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java index c22e3839..5f85e2c1 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/InternalStates.java @@ -48,4 +48,6 @@ public class InternalStates { public static final StateId TIME_SLACK = new StateFactory.StateIdImpl("time_slack",12); public static final StateId FUTURE_WAITING = new StateFactory.StateIdImpl("future_waiting",13); + + public static final StateId EARLIEST_WITHOUT_WAITING = new StateFactory.StateIdImpl("earliest_without_waiting",14); } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java index 2e9563c6..fe0fed9f 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java @@ -45,13 +45,14 @@ public class UpdateDepartureTime implements RouteVisitor, StateUpdater{ private boolean hasVariableDepartureTime; - public UpdateDepartureTime(VehicleRoutingTransportCosts tpCosts) { + private StateManager stateManager; + + public UpdateDepartureTime(VehicleRoutingTransportCosts tpCosts, StateManager stateManager) { super(); this.transportCosts = tpCosts; - + this.stateManager = stateManager; } - public void begin(VehicleRoute route) { this.route = route; hasEarliest = false; @@ -73,11 +74,13 @@ public class UpdateDepartureTime implements RouteVisitor, StateUpdater{ else { arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalLatestOperationStartTime(); } + stateManager.putInternalTypedActivityState(activity,route.getVehicle(),InternalStates.EARLIEST_WITHOUT_WAITING,arrTimeAtPrevActWithoutWaiting); } else{ if(activity.getTheoreticalEarliestOperationStartTime() > 0){ hasEarliest = true; arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalEarliestOperationStartTime(); + stateManager.putInternalTypedActivityState(activity,route.getVehicle(),InternalStates.EARLIEST_WITHOUT_WAITING,arrTimeAtPrevActWithoutWaiting); } } prevAct = activity; diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java index 779d6e1a..10a91738 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java @@ -56,7 +56,7 @@ public class VariableDepartureAndWaitingTime_IT { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(),stateManager )); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) @@ -160,7 +160,7 @@ public class VariableDepartureAndWaitingTime_IT { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) @@ -206,7 +206,7 @@ public class VariableDepartureAndWaitingTime_IT { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) @@ -260,7 +260,7 @@ public class VariableDepartureAndWaitingTime_IT { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) @@ -323,7 +323,7 @@ public class VariableDepartureAndWaitingTime_IT { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java index 91c0bd75..15d29de0 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java @@ -446,12 +446,12 @@ public class TestLocalActivityInsertionCostsCalculator { LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(-10.,c,0.01); + assertEquals(0.,c,0.01); /* activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings */ /* - old = s:40,act1:50,act2:60,act3:70,act4:80 --> w=20 + old = s:40,act1:50,act2:60,act3:70,act4:90 --> w=10 new = s:30,act1:40,act2:50,act3:70,act4:80,act5:90 --> w=10 => -10 */ } @@ -485,13 +485,99 @@ public class TestLocalActivityInsertionCostsCalculator { LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(20.,c,0.01); + assertEquals(30.,c,0.01); /* activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings */ /* - old = s:40,act1:50,act2:60,act3:70,act4:80 --> w=20 - new = s:0,act1:10,act2:20,act3:40,act4:50,act5:60 --> w=40 => 20 + old = s:40,act1:50,act2:60,70,act3:(70,80),act4:90 --> w=10 + new = s:0,act1:10,act2:20,act3:(40,50),act4:50,act5:60 --> w=40 => 20 + */ + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs1WithVarStart_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(10,20)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,70)).build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(50,100)).build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) + .addJob(afterNextS).addJob(afterAfterNextS).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + + StateManager stateManager = getStateManager(vrp, route); + + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(30.,c,0.01); + /* + activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings + */ + /* + old = s:40,act1:50,act2:60,70,act3:(70,80),act4:90 --> w=10 + new = s:0,act1:10,act2:20,act3:(40,50),act4:50,act5:60 --> w=40 => 20 + */ + } + + @Test + public void whenAddingNewWithTWBetweenTwoActs5WithVarStart_itShouldCalcInsertionCostsCorrectly(){ + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); + + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); +// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + + Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10) + .setTimeWindow(TimeWindow.newInstance(0,20)) + .setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)) +// .setTimeWindow(TimeWindow.newInstance(40,80)) + .build(); + + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)) +// .setTimeWindow(TimeWindow.newInstance(50,100)) + .build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)) + .setTimeWindow(TimeWindow.newInstance(100,500)) + .build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) + .addJob(afterNextS).addJob(afterAfterNextS).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); + JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); + + StateManager stateManager = getStateManager(vrp, route); + + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); + calc.setSolutionCompletenessRatio(1.); + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(40.,c,0.01); + /* + activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings + */ + /* + old = s:40,act1:50,act2:60,70,act3:(70,80),act4:90 --> w=10 + new = s:0,act1:10,act2:20,act3:(40,50),act4:50,act5:60 --> w=40 => 20 */ } @@ -501,7 +587,7 @@ public class TestLocalActivityInsertionCostsCalculator { stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts())); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(),stateManager )); stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList()); return stateManager; } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java index 0258427f..29a6147e 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java @@ -1,6 +1,7 @@ package jsprit.core.algorithm.state; import jsprit.core.problem.Location; +import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.job.Service; import jsprit.core.problem.solution.route.RouteVisitor; import jsprit.core.problem.solution.route.VehicleRoute; @@ -11,6 +12,8 @@ import junit.framework.Assert; import org.junit.Before; import org.junit.Test; +import static org.mockito.Mockito.mock; + /** * Created by schroeder on 22/07/15. */ @@ -20,7 +23,8 @@ public class UpdateDepartureTimeTest { @Before public void doBefore(){ - revVisitors = new UpdateDepartureTime(CostFactory.createManhattanCosts()); + StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class)); + revVisitors = new UpdateDepartureTime(CostFactory.createManhattanCosts(), stateManager); } @Test diff --git a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java index 20b0f6c5..9ad267f1 100644 --- a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java +++ b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java @@ -7,9 +7,11 @@ import jsprit.core.algorithm.box.Jsprit; import jsprit.core.algorithm.state.StateManager; import jsprit.core.algorithm.state.UpdateDepartureTime; import jsprit.core.algorithm.state.UpdateTimeSlack; +import jsprit.core.analysis.SolutionAnalyser; import jsprit.core.problem.Location; import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.constraint.ConstraintManager; +import jsprit.core.problem.cost.TransportDistance; import jsprit.core.problem.job.Service; import jsprit.core.problem.solution.SolutionCostCalculator; import jsprit.core.problem.solution.VehicleRoutingProblemSolution; @@ -35,19 +37,20 @@ public class VariableStartAndWaitingTimeExample { public static void main(String[] args) { - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(2.5).setCostPerWaitingTime(2.0).build(); -// VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(1.5).setCostPerWaitingTime(.0).build(); + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); + VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); + VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type2").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true) .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type).setReturnToDepot(true) + VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type1).setReturnToDepot(true) + .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type2).setReturnToDepot(true) .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type).setReturnToDepot(true) - .setHasVariableDepartureTime(false).setStartLocation(Location.newInstance(0, 0)).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); Random r = RandomNumberGeneration.newInstance(); for(int i=0;i<40;i++){ - Service s = Service.Builder.newInstance("s_"+i).setServiceTime(0) + Service s = Service.Builder.newInstance("s_"+i).setServiceTime(1) // .setTimeWindow(TimeWindow.newInstance(r.nextInt(50),100+r.nextInt(150))) .setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build(); vrpBuilder.addJob(s); @@ -64,14 +67,14 @@ public class VariableStartAndWaitingTimeExample { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts())); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) .addCoreStateAndConstraintStuff(true) .setStateAndConstraintManager(stateManager, constraintManager) -// .setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.1") + .setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.1") // .setProperty(Jsprit.Parameter.THRESHOLD_ALPHA, "0.3") // .setProperty(Parameter.) // .setProperty(Jsprit.Parameter.CONSTRUCTION, Jsprit.Construction.BEST_INSERTION.toString()) @@ -97,12 +100,22 @@ public class VariableStartAndWaitingTimeExample { } }; VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - vra.setMaxIterations(500); + vra.setMaxIterations(2000); vra.addListener(new AlgorithmSearchProgressChartListener("output/search")); VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); System.out.println("c: " + solution.getCost()); SolutionPrinter.print(vrp, solution, SolutionPrinter.Print.VERBOSE); + SolutionAnalyser sa = new SolutionAnalyser(vrp, solution, new TransportDistance() { + @Override + public double getDistance(Location from, Location to) { + return vrp.getTransportCosts().getTransportTime(from,to,0.,null,null); + } + }); + + System.out.println("totalWaiting: " + sa.getWaitingTime()); + System.out.println("brokenTWs: " + sa.getTimeWindowViolation()); + new Plotter(vrp,solution).setLabel(Plotter.Label.ID).plot("output/plot","plot"); } } diff --git a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java new file mode 100644 index 00000000..06ef61b4 --- /dev/null +++ b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java @@ -0,0 +1,98 @@ +package jsprit.examples; + +import jsprit.analysis.toolbox.AlgorithmSearchProgressChartListener; +import jsprit.analysis.toolbox.Plotter; +import jsprit.core.algorithm.VehicleRoutingAlgorithm; +import jsprit.core.algorithm.box.Jsprit; +import jsprit.core.algorithm.state.StateManager; +import jsprit.core.algorithm.state.UpdateDepartureTime; +import jsprit.core.algorithm.state.UpdateTimeSlack; +import jsprit.core.problem.Location; +import jsprit.core.problem.VehicleRoutingProblem; +import jsprit.core.problem.constraint.ConstraintManager; +import jsprit.core.problem.job.Service; +import jsprit.core.problem.solution.SolutionCostCalculator; +import jsprit.core.problem.solution.VehicleRoutingProblemSolution; +import jsprit.core.problem.solution.route.VehicleRoute; +import jsprit.core.problem.solution.route.activity.TimeWindow; +import jsprit.core.problem.solution.route.activity.TourActivity; +import jsprit.core.problem.vehicle.VehicleImpl; +import jsprit.core.problem.vehicle.VehicleTypeImpl; +import jsprit.core.reporting.SolutionPrinter; +import jsprit.core.util.Solutions; + +/** + * Created by schroeder on 23/07/15. + */ +public class VariableStartAndWaitingTimeExample2 { + + static interface AlgorithmFactory { + VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp); + } + + public static void main(String[] args) { + + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.5).setCostPerWaitingTime(1.0).build(); +// VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(1.5).setCostPerWaitingTime(.0).build(); + + VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true) + .setHasVariableDepartureTime(false).setStartLocation(Location.newInstance(0, 0)).build(); + + VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); + + + Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-1, 5)).setTimeWindow(TimeWindow.newInstance(100, 110)).build(); + Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(0, 10)).build(); + Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(1, 12)).build(); + Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(4, 10)).build(); + Service s5 = Service.Builder.newInstance("s14").setLocation(Location.newInstance(6, 5)).setTimeWindow(TimeWindow.newInstance(100,220)).build(); + vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addJob(s4).addJob(s5).addVehicle(v2); + vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); + final VehicleRoutingProblem vrp = vrpBuilder.build(); + + AlgorithmFactory algorithmFactory = new AlgorithmFactory() { + @Override + public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { + StateManager stateManager = new StateManager(vrp); + stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); + stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts())); + ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); + + return Jsprit.Builder.newInstance(vrp) + .addCoreStateAndConstraintStuff(true) + .setStateAndConstraintManager(stateManager, constraintManager) +// .setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.1") +// .setProperty(Jsprit.Parameter.THRESHOLD_ALPHA, "0.3") +// .setProperty(Parameter.) +// .setProperty(Jsprit.Parameter.CONSTRUCTION, Jsprit.Construction.BEST_INSERTION.toString()) + .setObjectiveFunction(new SolutionCostCalculator() { + @Override + public double getCosts(VehicleRoutingProblemSolution solution) { + double costs = 0.; + for (VehicleRoute route : solution.getRoutes()) { + costs += route.getVehicle().getType().getVehicleCostParams().fix; + TourActivity prevAct = route.getStart(); + for (TourActivity act : route.getActivities()) { + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), act.getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle()); + costs += vrp.getActivityCosts().getActivityCost(act, act.getArrTime(), route.getDriver(), route.getVehicle()); + prevAct = act; + } + costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(), route.getEnd().getLocation(), prevAct.getEndTime(), route.getDriver(), route.getVehicle()); + } + costs += solution.getUnassignedJobs().size() * 200; + return costs; + } + }) + .buildAlgorithm(); + } + }; + VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); + vra.setMaxIterations(1000); + vra.addListener(new AlgorithmSearchProgressChartListener("output/search")); + VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); + System.out.println("c: " + solution.getCost()); + SolutionPrinter.print(vrp, solution, SolutionPrinter.Print.VERBOSE); + + new Plotter(vrp,solution).setLabel(Plotter.Label.ID).plot("output/plot","plot"); + } +} From c8eb1dd7b4407b852a5eed66f9d953856211153a Mon Sep 17 00:00:00 2001 From: oblonski Date: Mon, 3 Aug 2015 22:31:55 +0200 Subject: [PATCH 6/7] separate waiting time feature from variable start times --- ...LocalActivityInsertionCostsCalculator.java | 66 +--- .../algorithm/state/UpdateDepartureTime.java | 109 ------- .../core/algorithm/state/UpdateTimeSlack.java | 81 ----- .../jsprit/core/problem/vehicle/Vehicle.java | 1 - .../core/problem/vehicle/VehicleImpl.java | 19 +- .../VariableDepartureAndWaitingTime_IT.java | 258 --------------- ...erviceInsertionAndLoadConstraintsTest.java | 2 +- .../ShipmentInsertionCalculatorTest.java | 2 +- ...LocalActivityInsertionCostsCalculator.java | 305 +++++++----------- .../state/UpdateDepartureTimeTest.java | 130 -------- .../algorithm/state/UpdateTimeSlackTest.java | 119 ------- .../core/problem/vehicle/VehicleImplTest.java | 10 - .../VariableStartAndWaitingTimeExample.java | 36 ++- .../VariableStartAndWaitingTimeExample2.java | 12 +- 14 files changed, 148 insertions(+), 1002 deletions(-) delete mode 100644 jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java delete mode 100644 jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java delete mode 100644 jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java delete mode 100644 jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java index c8d004d1..02209716 100644 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java @@ -23,7 +23,6 @@ import jsprit.core.problem.cost.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.solution.route.activity.End; -import jsprit.core.problem.solution.route.activity.Start; import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter; import jsprit.core.problem.vehicle.Vehicle; @@ -45,12 +44,10 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal private VehicleRoutingActivityCosts activityCosts; - private double activityCostsWeight = 0.75; + private double activityCostsWeight = 1.; private double solutionCompletenessRatio = 1.; - private double variableStartTimeFactor = 1.; - private RouteAndActivityStateGetter stateManager; public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, RouteAndActivityStateGetter stateManager) { @@ -60,10 +57,6 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal this.stateManager = stateManager; } - public void setVariableStartTimeFactor(double variableStartTimeFactor) { - this.variableStartTimeFactor = variableStartTimeFactor; - } - @Override public double getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) { @@ -74,17 +67,6 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal double act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); - double slack_time_new = 0; - double slack_time_prev = 0; - if(isStart(prevAct) && hasVariableDeparture(iFacts.getNewVehicle())) act_costs_newAct = 0; - else if(hasVariableDeparture(iFacts.getNewVehicle())){ - Double slack_time_prev_ = stateManager.getActivityState(prevAct,iFacts.getNewVehicle(),InternalStates.TIME_SLACK,Double.class); - if(slack_time_prev_ == null) slack_time_prev = 0.; - else slack_time_prev = slack_time_prev_; - act_costs_newAct = activityCosts.getActivityCost(newAct, newAct_arrTime + slack_time_prev, iFacts.getNewDriver(), iFacts.getNewVehicle()); - slack_time_new = Math.min(newAct.getTheoreticalLatestOperationStartTime() - newAct.getTheoreticalEarliestOperationStartTime(), Math.max(newAct_arrTime + slack_time_prev - newAct.getTheoreticalEarliestOperationStartTime(), 0)); - } - if(isEnd(nextAct) && !toDepot(iFacts.getNewVehicle())) return tp_costs_prevAct_newAct; double tp_costs_newAct_nextAct = routingCosts.getTransportCost(newAct.getLocation(), nextAct.getLocation(), newAct_endTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); @@ -93,10 +75,6 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal double endTime_nextAct_new = CalculationUtils.getActivityEndTime(nextAct_arrTime, nextAct); double act_costs_nextAct = activityCosts.getActivityCost(nextAct, nextAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); - if(hasVariableDeparture(iFacts.getNewVehicle())){ - act_costs_nextAct = activityCosts.getActivityCost(nextAct, nextAct_arrTime + slack_time_new, iFacts.getNewDriver(), iFacts.getNewVehicle()); - } - double totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + solutionCompletenessRatio * activityCostsWeight * (act_costs_newAct + act_costs_nextAct); double oldCosts = 0.; @@ -109,28 +87,13 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal double arrTime_nextAct = depTimeAtPrevAct + routingCosts.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevAct.getEndTime(), iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); double endTime_nextAct_old = CalculationUtils.getActivityEndTime(arrTime_nextAct,nextAct); double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); - if(isStart(prevAct) && hasVariableDeparture(iFacts.getRoute().getVehicle())) { - actCost_nextAct = 0; - } - else if(hasVariableDeparture(iFacts.getRoute().getVehicle())){ - actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct + slack_time_prev, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); - Double earliestWithoutWaiting = stateManager.getActivityState(nextAct,iFacts.getRoute().getVehicle(),InternalStates.EARLIEST_WITHOUT_WAITING,Double.class); - if(earliestWithoutWaiting != null){ - double potentialArrivalTimeAtNewAct = earliestWithoutWaiting - routingCosts.getBackwardTransportTime(nextAct.getLocation(), newAct.getLocation(), earliestWithoutWaiting, iFacts.getRoute().getDriver(),iFacts.getRoute().getVehicle()) - newAct.getOperationTime(); - if(potentialArrivalTimeAtNewAct > newAct.getTheoreticalLatestOperationStartTime()){ - double delta = potentialArrivalTimeAtNewAct - newAct.getTheoreticalLatestOperationStartTime(); - totalCosts += solutionCompletenessRatio * activityCostsWeight * delta * iFacts.getNewVehicle().getType().getVehicleCostParams().perWaitingTimeUnit; - } - } - } - else { - double endTimeDelay_nextAct = Math.max(0, endTime_nextAct_new - endTime_nextAct_old); - Double futureWaiting = stateManager.getActivityState(nextAct, iFacts.getRoute().getVehicle(), InternalStates.FUTURE_WAITING, Double.class); - if (futureWaiting == null) futureWaiting = 0.; - double waitingTime_savings_timeUnit = Math.min(futureWaiting, endTimeDelay_nextAct); - double waitingTime_savings = waitingTime_savings_timeUnit * iFacts.getRoute().getVehicle().getType().getVehicleCostParams().perWaitingTimeUnit; - oldCosts += solutionCompletenessRatio * activityCostsWeight * waitingTime_savings; - } + + double endTimeDelay_nextAct = Math.max(0, endTime_nextAct_new - endTime_nextAct_old); + Double futureWaiting = stateManager.getActivityState(nextAct, iFacts.getRoute().getVehicle(), InternalStates.FUTURE_WAITING, Double.class); + if (futureWaiting == null) futureWaiting = 0.; + double waitingTime_savings_timeUnit = Math.min(futureWaiting, endTimeDelay_nextAct); + double waitingTime_savings = waitingTime_savings_timeUnit * iFacts.getRoute().getVehicle().getType().getVehicleCostParams().perWaitingTimeUnit; + oldCosts += solutionCompletenessRatio * activityCostsWeight * waitingTime_savings; oldCosts += tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; } return totalCosts - oldCosts; @@ -144,20 +107,7 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal return nextAct instanceof End; } - private boolean hasVariableDeparture(Vehicle newVehicle) { - return newVehicle.hasVariableDepartureTime(); - } - - private boolean isStart(TourActivity prevAct) { - return prevAct instanceof Start; - } - - public void setActivityCostWeight(double weight){ - this.activityCostsWeight = weight; - } - public void setSolutionCompletenessRatio(double solutionCompletenessRatio) { -// this.solutionCompletenessRatio = 1.; this.solutionCompletenessRatio = solutionCompletenessRatio; } } diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java deleted file mode 100644 index fe0fed9f..00000000 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java +++ /dev/null @@ -1,109 +0,0 @@ -/******************************************************************************* - * Copyright (C) 2014 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 . - ******************************************************************************/ -package jsprit.core.algorithm.state; - -import jsprit.core.problem.cost.VehicleRoutingTransportCosts; -import jsprit.core.problem.solution.route.RouteVisitor; -import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.TourActivity; - -import java.util.Iterator; - -/** - * Updates and memorizes latest operation start times at activities. - * - * @author schroeder - * - */ -public class UpdateDepartureTime implements RouteVisitor, StateUpdater{ - - - - private VehicleRoute route; - - private VehicleRoutingTransportCosts transportCosts; - - private double arrTimeAtPrevActWithoutWaiting; - - private TourActivity prevAct; - - private boolean hasEarliest = false; - - private boolean hasVariableDepartureTime; - - private StateManager stateManager; - - public UpdateDepartureTime(VehicleRoutingTransportCosts tpCosts, StateManager stateManager) { - super(); - this.transportCosts = tpCosts; - this.stateManager = stateManager; - } - - public void begin(VehicleRoute route) { - this.route = route; - hasEarliest = false; - prevAct = route.getEnd(); - hasVariableDepartureTime = route.getVehicle().hasVariableDepartureTime(); - } - - - public void visit(TourActivity activity) { - if(!hasVariableDepartureTime) return; - if(hasEarliest){ - double potentialArrivalTimeAtCurrAct = arrTimeAtPrevActWithoutWaiting - transportCosts.getBackwardTransportTime(activity.getLocation(), prevAct.getLocation(), arrTimeAtPrevActWithoutWaiting, route.getDriver(),route.getVehicle()) - activity.getOperationTime(); - if(potentialArrivalTimeAtCurrAct < activity.getTheoreticalEarliestOperationStartTime()){ - arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalEarliestOperationStartTime(); - } - else if(potentialArrivalTimeAtCurrAct >= activity.getTheoreticalEarliestOperationStartTime() && potentialArrivalTimeAtCurrAct <= activity.getTheoreticalLatestOperationStartTime()){ - arrTimeAtPrevActWithoutWaiting = potentialArrivalTimeAtCurrAct; - } - else { - arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalLatestOperationStartTime(); - } - stateManager.putInternalTypedActivityState(activity,route.getVehicle(),InternalStates.EARLIEST_WITHOUT_WAITING,arrTimeAtPrevActWithoutWaiting); - } - else{ - if(activity.getTheoreticalEarliestOperationStartTime() > 0){ - hasEarliest = true; - arrTimeAtPrevActWithoutWaiting = activity.getTheoreticalEarliestOperationStartTime(); - stateManager.putInternalTypedActivityState(activity,route.getVehicle(),InternalStates.EARLIEST_WITHOUT_WAITING,arrTimeAtPrevActWithoutWaiting); - } - } - prevAct = activity; - } - - - public void finish() { - if(!hasVariableDepartureTime) return; - if(hasEarliest){ - double dep = arrTimeAtPrevActWithoutWaiting - transportCosts.getBackwardTransportTime(route.getStart().getLocation(), prevAct.getLocation(), arrTimeAtPrevActWithoutWaiting, route.getDriver(),route.getVehicle()); - double newDepartureTime = Math.max(route.getVehicle().getEarliestDeparture(), dep); - route.setVehicleAndDepartureTime(route.getVehicle(),newDepartureTime); - } - else route.setVehicleAndDepartureTime(route.getVehicle(),route.getVehicle().getEarliestDeparture()); - } - - @Override - public void visit(VehicleRoute route) { - begin(route); - Iterator revIterator = route.getTourActivities().reverseActivityIterator(); - while(revIterator.hasNext()){ - visit(revIterator.next()); - } - finish(); - } -} diff --git a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java b/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java deleted file mode 100644 index 9372d78e..00000000 --- a/jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java +++ /dev/null @@ -1,81 +0,0 @@ -/******************************************************************************* - * Copyright (C) 2014 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 . - ******************************************************************************/ -package jsprit.core.algorithm.state; - -import jsprit.core.problem.cost.VehicleRoutingTransportCosts; -import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.ActivityVisitor; -import jsprit.core.problem.solution.route.activity.TourActivity; - - -/** - * Updates arrival and end times of activities. - * - *

Note that this modifies arrTime and endTime of each activity in a route. - * - * @author stefan - * - */ -public class UpdateTimeSlack implements ActivityVisitor, StateUpdater{ - - private VehicleRoute route; - - private StateManager stateManager; - - private VehicleRoutingTransportCosts costs; - - private double prevTimeSlack; - - private double prevActDeparture; - - private TourActivity prevAct; - - public UpdateTimeSlack(StateManager stateManager, VehicleRoutingTransportCosts costs) { - this.stateManager = stateManager; - this.costs = costs; - } - - @Override - public void begin(VehicleRoute route) { - if(route.isEmpty()) return; - this.route = route; - prevActDeparture = route.getVehicle().getEarliestDeparture(); - TourActivity first = route.getActivities().get(0); - double latestArr = stateManager.getActivityState(first,route.getVehicle(),InternalStates.LATEST_OPERATION_START_TIME,Double.class); - double latest = latestArr - costs.getBackwardTransportCost(first.getLocation(),route.getStart().getLocation(),latestArr,route.getDriver(),route.getVehicle()); - prevTimeSlack = latest - prevActDeparture; - prevAct = route.getStart(); - } - - @Override - public void visit(TourActivity activity) { - double actArrTime = prevActDeparture + costs.getTransportTime(prevAct.getLocation(),activity.getLocation(),prevActDeparture,route.getDriver(),route.getVehicle()); - double actEarliestStart = Math.max(actArrTime,activity.getTheoreticalEarliestOperationStartTime()); - double actLatestStart = stateManager.getActivityState(activity,route.getVehicle(),InternalStates.LATEST_OPERATION_START_TIME,Double.class); - double latest_minus_earliest = actLatestStart - actEarliestStart; - double time_slack_ = Math.max(actArrTime + prevTimeSlack - activity.getTheoreticalEarliestOperationStartTime(),0); - double time_slack = Math.min(latest_minus_earliest,time_slack_); - stateManager.putInternalTypedActivityState(activity,route.getVehicle(), InternalStates.TIME_SLACK, time_slack); - prevTimeSlack = time_slack; - prevAct = activity; - prevActDeparture = actEarliestStart + activity.getOperationTime(); - } - - @Override - public void finish() {} - -} diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java index 59b025ff..3e5d0e96 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java @@ -73,5 +73,4 @@ public interface Vehicle extends HasId, HasIndex { public abstract Skills getSkills(); - public boolean hasVariableDepartureTime(); } diff --git a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java index acb6a2f7..9389bbce 100644 --- a/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java +++ b/jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java @@ -92,10 +92,7 @@ public class VehicleImpl extends AbstractVehicle{ return null; } - @Override - public boolean hasVariableDepartureTime() { - return false; - } + } /** @@ -130,7 +127,6 @@ public class VehicleImpl extends AbstractVehicle{ private Location endLocation; - private boolean hasVariableDepartureTime = false; private Builder(String id) { super(); @@ -150,11 +146,7 @@ public class VehicleImpl extends AbstractVehicle{ return this; } - public Builder setHasVariableDepartureTime(boolean hasVariableDepartureTime){ - this.hasVariableDepartureTime = hasVariableDepartureTime; - return this; - } - + /** * Sets the flag whether the vehicle must return to depot or not. * @@ -286,8 +278,6 @@ public class VehicleImpl extends AbstractVehicle{ private final Location startLocation; - private final boolean hasVariableDepartureTime; - private VehicleImpl(Builder builder){ id = builder.id; type = builder.type; @@ -297,7 +287,6 @@ public class VehicleImpl extends AbstractVehicle{ skills = builder.skills; endLocation = builder.endLocation; startLocation = builder.startLocation; - hasVariableDepartureTime = builder.hasVariableDepartureTime; setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(),startLocation.getId(),endLocation.getId(),earliestDeparture,latestArrival,skills, returnToDepot)); } @@ -356,10 +345,6 @@ public class VehicleImpl extends AbstractVehicle{ return skills; } - @Override - public boolean hasVariableDepartureTime() { - return hasVariableDepartureTime; - } /* (non-Javadoc) * @see java.lang.Object#hashCode() diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java index 10a91738..baf2d17d 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java @@ -2,7 +2,6 @@ package jsprit.core.algorithm; import jsprit.core.algorithm.box.Jsprit; import jsprit.core.algorithm.state.StateManager; -import jsprit.core.algorithm.state.UpdateDepartureTime; import jsprit.core.analysis.SolutionAnalyser; import jsprit.core.problem.Location; import jsprit.core.problem.VehicleRoutingProblem; @@ -13,22 +12,16 @@ import jsprit.core.problem.driver.Driver; import jsprit.core.problem.job.Service; import jsprit.core.problem.solution.SolutionCostCalculator; import jsprit.core.problem.solution.VehicleRoutingProblemSolution; -import jsprit.core.problem.solution.route.VehicleRoute; import jsprit.core.problem.solution.route.activity.TimeWindow; import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.VehicleImpl; -import jsprit.core.problem.vehicle.VehicleTypeImpl; -import jsprit.core.reporting.SolutionPrinter; import jsprit.core.util.CostFactory; -import jsprit.core.util.RandomNumberGeneration; import jsprit.core.util.Solutions; import junit.framework.Assert; import org.junit.Before; import org.junit.Test; -import java.util.Random; - /** * Created by schroeder on 22/07/15. */ @@ -56,7 +49,6 @@ public class VariableDepartureAndWaitingTime_IT { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(),stateManager )); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) @@ -111,256 +103,6 @@ public class VariableDepartureAndWaitingTime_IT { Assert.assertEquals(40.+1000.,solution.getCost()); } - @Test - public void variableDepartureShouldWork(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - Service s1 = Service.Builder.newInstance("s1").setTimeWindow(TimeWindow.newInstance(1010,1100)).setLocation(Location.newInstance(10,0)).build(); - Service s2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(20,0)).build(); - final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() - .addJob(s1).addJob(s2).addVehicle(v) - .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) - .setRoutingCost(CostFactory.createManhattanCosts()) - .setActivityCosts(activityCosts) - .build(); - VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); - Assert.assertEquals(40.,solution.getCost()); - } - - @Test - public void variableDepartureShouldWork2(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - Service s1 = Service.Builder.newInstance("s1").setTimeWindow(TimeWindow.newInstance(1010,1100)).setLocation(Location.newInstance(10,0)).build(); - Service s2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(20,0)).build(); - Service s3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(1020,1100)).setLocation(Location.newInstance(15,0)).build(); - final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() - .addJob(s1).addJob(s2).addVehicle(v) - .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) - .setRoutingCost(CostFactory.createManhattanCosts()) - .setActivityCosts(activityCosts) - .build(); - VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); - Assert.assertEquals(40.,solution.getCost()); - } - - @Test - public void variableDepartureShouldWork3(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(0,10)).setTimeWindow(TimeWindow.newInstance(10,10)).build(); - Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(5,15)).build(); - Service s3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance(10,10)).build(); - final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() - .addJob(s1).addJob(s2).addJob(s3).addVehicle(v) - .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) - .setRoutingCost(CostFactory.createEuclideanCosts()) - .setActivityCosts(activityCosts) - .build(); - AlgorithmFactory algorithmFactory = new AlgorithmFactory() { - @Override - public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); - ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); - - return Jsprit.Builder.newInstance(vrp) - .addCoreStateAndConstraintStuff(true) - .setStateAndConstraintManager(stateManager,constraintManager) - .setObjectiveFunction(new SolutionCostCalculator() { - @Override - public double getCosts(VehicleRoutingProblemSolution solution) { - SolutionAnalyser sa = new SolutionAnalyser(vrp, solution, new TransportDistance() { - @Override - public double getDistance(Location from, Location to) { - return vrp.getTransportCosts().getTransportCost(from, to, 0., null, null); - } - }); - return sa.getWaitingTime() + sa.getDistance(); - } - }) - .buildAlgorithm(); - } - }; - VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - vra.setMaxIterations(100); - VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); - System.out.println("c: " + solution.getCost()); - Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); - Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); - Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); - } - - @Test - public void variableDepartureShouldWork4(){ - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.0).setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setHasVariableDepartureTime(false).setStartLocation(Location.newInstance(0, 0)).build(); - Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(0,10)).setTimeWindow(TimeWindow.newInstance(15,15)).build(); - Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(0,11)).setTimeWindow(TimeWindow.newInstance(100,100)).build(); - Service s3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance(10,10)).build(); - final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() - .addJob(s1).addJob(s2).addJob(s3).addVehicle(v) - .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) - .setRoutingCost(CostFactory.createEuclideanCosts()) - .build(); - AlgorithmFactory algorithmFactory = new AlgorithmFactory() { - @Override - public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); - ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); - - return Jsprit.Builder.newInstance(vrp) - .addCoreStateAndConstraintStuff(true) - .setStateAndConstraintManager(stateManager,constraintManager) - .setObjectiveFunction(new SolutionCostCalculator() { - @Override - public double getCosts(VehicleRoutingProblemSolution solution) { - double costs = 0.; - for(VehicleRoute route : solution.getRoutes()){ - costs += route.getVehicle().getType().getVehicleCostParams().fix; - TourActivity prevAct = route.getStart(); - for(TourActivity act : route.getActivities()){ - costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); - costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle()); - prevAct = act; - } - costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); - } - costs += solution.getUnassignedJobs().size() * 1000; - return costs; - } - }) - .buildAlgorithm(); - } - }; - VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - vra.setMaxIterations(100); - VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); - System.out.println("c: " + solution.getCost()); - SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); - Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); - Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); - Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); - } - - @Test - public void variableDepartureShouldWork5(){ - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.0).setCostPerWaitingTime(1.0).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(0,10)).setTimeWindow(TimeWindow.newInstance(15,15)).build(); - Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(0,11)).setTimeWindow(TimeWindow.newInstance(100,100)).build(); - Service s3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance(10,10)).build(); - final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() - .addJob(s1).addJob(s2).addJob(s3).addVehicle(v).addVehicle(v2) - .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) - .setRoutingCost(CostFactory.createEuclideanCosts()) - .build(); - AlgorithmFactory algorithmFactory = new AlgorithmFactory() { - @Override - public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); - ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); - - return Jsprit.Builder.newInstance(vrp) - .addCoreStateAndConstraintStuff(true) - .setStateAndConstraintManager(stateManager,constraintManager) - .setObjectiveFunction(new SolutionCostCalculator() { - @Override - public double getCosts(VehicleRoutingProblemSolution solution) { - double costs = 0.; - for(VehicleRoute route : solution.getRoutes()){ - costs += route.getVehicle().getType().getVehicleCostParams().fix; - TourActivity prevAct = route.getStart(); - for(TourActivity act : route.getActivities()){ - costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); - costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle()); - prevAct = act; - } - costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); - } - costs += solution.getUnassignedJobs().size() * 1000; - return costs; - } - }) - .buildAlgorithm(); - } - }; - VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - vra.setMaxIterations(100); - VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); - System.out.println("c: " + solution.getCost()); - SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); -// Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); -// Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); -// Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); - } - - @Test - public void variableDepartureShouldWork6(){ - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.0).setCostPerWaitingTime(1.0).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); - Random r = RandomNumberGeneration.newInstance(); - for(int i=0;i<10;i++){ - Service s = Service.Builder.newInstance("s"+i).setServiceTime(5).setLocation(Location.newInstance(0, 10 + r.nextInt(10))).build(); - vrpBuilder.addJob(s); - } - Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(10,21)).setTimeWindow(TimeWindow.newInstance(100,110)).build(); - Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10,10)).setTimeWindow(TimeWindow.newInstance(300,310)).build(); - vrpBuilder.addJob(s2).addJob(s3).addVehicle(v).addVehicle(v2); - vrpBuilder.setRoutingCost(CostFactory.createEuclideanCosts()); - vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); - final VehicleRoutingProblem vrp = vrpBuilder.build(); -// final VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance() -// .addJob(s1).addJob(s2).addJob(s3).addVehicle(v).addVehicle(v2) -// .setFleetSize(VehicleRoutingProblem.FleetSize.FINITE) -// .setRoutingCost(CostFactory.createEuclideanCosts()) -// .build(); - AlgorithmFactory algorithmFactory = new AlgorithmFactory() { - @Override - public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); - ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); - - return Jsprit.Builder.newInstance(vrp) - .addCoreStateAndConstraintStuff(true) - .setStateAndConstraintManager(stateManager,constraintManager) - .setObjectiveFunction(new SolutionCostCalculator() { - @Override - public double getCosts(VehicleRoutingProblemSolution solution) { - double costs = 0.; - for(VehicleRoute route : solution.getRoutes()){ - costs += route.getVehicle().getType().getVehicleCostParams().fix; - TourActivity prevAct = route.getStart(); - for(TourActivity act : route.getActivities()){ - costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),act.getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); - costs += vrp.getActivityCosts().getActivityCost(act,act.getArrTime(),route.getDriver(),route.getVehicle()); - prevAct = act; - } - costs += vrp.getTransportCosts().getTransportCost(prevAct.getLocation(),route.getEnd().getLocation(),prevAct.getEndTime(),route.getDriver(),route.getVehicle()); - } - costs += solution.getUnassignedJobs().size() * 1000; - return costs; - } - }) - .buildAlgorithm(); - } - }; - VehicleRoutingAlgorithm vra = algorithmFactory.createAlgorithm(vrp); - vra.setMaxIterations(100); - VehicleRoutingProblemSolution solution = Solutions.bestOf(vra.searchSolutions()); - System.out.println("c: " + solution.getCost()); - SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); -// Assert.assertEquals("s1", ((TourActivity.JobActivity) solution.getRoutes().iterator().next().getActivities().get(0)).getJob().getId()); -// Assert.assertEquals("s3",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(1)).getJob().getId()); -// Assert.assertEquals("s2",((TourActivity.JobActivity)solution.getRoutes().iterator().next().getActivities().get(2)).getJob().getId()); - } - - } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java index 60fc929a..0c2c4340 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java @@ -95,7 +95,7 @@ public class ServiceInsertionAndLoadConstraintsTest { routingCosts = CostFactory.createManhattanCosts(); VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build(); vehicle = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("0,0")).setType(type).build(); - activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, null); + activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, mock(StateManager.class)); createInsertionCalculator(hardRouteLevelConstraint); vehicleRoutingProblem = mock(VehicleRoutingProblem.class); } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java index 237a8fab..6b3bc144 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java @@ -94,7 +94,7 @@ public class ShipmentInsertionCalculatorTest { routingCosts = CostFactory.createManhattanCosts(); VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build(); vehicle = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("0,0")).setType(type).build(); - activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, null); + activityInsertionCostsCalculator = new LocalActivityInsertionCostsCalculator(routingCosts, activityCosts, mock(StateManager.class)); createInsertionCalculator(hardRouteLevelConstraint); vehicleRoutingProblem = mock(VehicleRoutingProblem.class); } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java index 15d29de0..c0f42345 100644 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java +++ b/jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java @@ -16,7 +16,10 @@ ******************************************************************************/ package jsprit.core.algorithm.recreate; -import jsprit.core.algorithm.state.*; +import jsprit.core.algorithm.state.StateManager; +import jsprit.core.algorithm.state.UpdateActivityTimes; +import jsprit.core.algorithm.state.UpdateFutureWaitingTimes; +import jsprit.core.algorithm.state.UpdateVehicleDependentPracticalTimeWindows; import jsprit.core.problem.Location; import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.cost.VehicleRoutingActivityCosts; @@ -26,7 +29,10 @@ import jsprit.core.problem.job.Job; import jsprit.core.problem.job.Service; import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.*; +import jsprit.core.problem.solution.route.activity.End; +import jsprit.core.problem.solution.route.activity.Start; +import jsprit.core.problem.solution.route.activity.TimeWindow; +import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.VehicleImpl; import jsprit.core.problem.vehicle.VehicleTypeImpl; @@ -66,6 +72,7 @@ public class TestLocalActivityInsertionCostsCalculator { jic = mock(JobInsertionContext.class); when(jic.getRoute()).thenReturn(route); when(jic.getNewVehicle()).thenReturn(vehicle); + when(vehicle.getType()).thenReturn(VehicleTypeImpl.Builder.newInstance("type").build()); tpCosts = mock(VehicleRoutingTransportCosts.class); when(tpCosts.getTransportCost(loc("i"), loc("j"), 0.0, null, vehicle)).thenReturn(2.0); @@ -76,7 +83,7 @@ public class TestLocalActivityInsertionCostsCalculator { when(tpCosts.getTransportTime(loc("k"), loc("j"), 0.0, null, vehicle)).thenReturn(0.0); actCosts = mock(VehicleRoutingActivityCosts.class); - calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts, null); + calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts, mock(StateManager.class)); } private Location loc(String i) { @@ -87,11 +94,14 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenInsertingActBetweenTwoRouteActs_itCalcsMarginalTpCosts(){ TourActivity prevAct = mock(TourActivity.class); when(prevAct.getLocation()).thenReturn(loc("i")); + when(prevAct.getIndex()).thenReturn(1); TourActivity nextAct = mock(TourActivity.class); when(nextAct.getLocation()).thenReturn(loc("j")); + when(nextAct.getIndex()).thenReturn(1); TourActivity newAct = mock(TourActivity.class); when(newAct.getLocation()).thenReturn(loc("k")); - + when(newAct.getIndex()).thenReturn(1); + when(vehicle.isReturnToDepot()).thenReturn(true); double costs = calc.getCosts(jic, prevAct, nextAct, newAct, 0.0); @@ -102,9 +112,11 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenInsertingActBetweenLastActAndEnd_itCalcsMarginalTpCosts(){ TourActivity prevAct = mock(TourActivity.class); when(prevAct.getLocation()).thenReturn(loc("i")); + when(prevAct.getIndex()).thenReturn(1); End nextAct = End.newInstance("j", 0.0, 0.0); TourActivity newAct = mock(TourActivity.class); when(newAct.getLocation()).thenReturn(loc("k")); + when(newAct.getIndex()).thenReturn(1); when(vehicle.isReturnToDepot()).thenReturn(true); @@ -116,10 +128,13 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenInsertingActBetweenTwoRouteActsAndRouteIsOpen_itCalcsMarginalTpCosts(){ TourActivity prevAct = mock(TourActivity.class); when(prevAct.getLocation()).thenReturn(loc("i")); + when(prevAct.getIndex()).thenReturn(1); TourActivity nextAct = mock(TourActivity.class); when(nextAct.getLocation()).thenReturn(loc("j")); + when(nextAct.getIndex()).thenReturn(1); TourActivity newAct = mock(TourActivity.class); when(newAct.getLocation()).thenReturn(loc("k")); + when(newAct.getIndex()).thenReturn(1); when(vehicle.isReturnToDepot()).thenReturn(false); @@ -131,9 +146,11 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenInsertingActBetweenLastActAndEndAndRouteIsOpen_itCalculatesTpCostsFromPrevToNewAct(){ TourActivity prevAct = mock(TourActivity.class); when(prevAct.getLocation()).thenReturn(loc("i")); + when(prevAct.getIndex()).thenReturn(1); End nextAct = End.newInstance("j", 0.0, 0.0); TourActivity newAct = mock(TourActivity.class); when(newAct.getLocation()).thenReturn(loc("k")); + when(newAct.getIndex()).thenReturn(1); when(vehicle.isReturnToDepot()).thenReturn(false); @@ -147,35 +164,48 @@ public class TestLocalActivityInsertionCostsCalculator { VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0, 0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(60, 0)).build(); - Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build(); - ServiceActivity prevAct = ServiceActivity.newInstance(prevS); - ServiceActivity newAct = ServiceActivity.newInstance(newS); - ServiceActivity nextAct = ServiceActivity.newInstance(nextS); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,80)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).build(); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(), new StateManager(mock(VehicleRoutingProblem.class))); calc.setSolutionCompletenessRatio(1.); - calc.setVariableStartTimeFactor(.8); - double c = calc.getCosts(context,prevAct,nextAct,newAct,0); - assertEquals(40.,c,0.01); + + double c = calc.getCosts(context,prevAct,nextAct,newAct,10); + assertEquals(50.,c,0.01); + + /* + new: dist = 90 & wait = 0 + old: dist = 30 & wait = 10 + c = new - old = 90 - 40 = 50 + */ } @Test public void whenAddingNewBetweenStartAndAct_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build(); Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30, 0)) .setTimeWindow(TimeWindow.newInstance(40, 50)).build(); - Start prevAct = new Start(Location.newInstance(0,0),0,100); - ServiceActivity newAct = ServiceActivity.newInstance(newS); - ServiceActivity nextAct = ServiceActivity.newInstance(nextS); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(nextS).build(); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addJob(nextS).addVehicle(v).build(); + + Start prevAct = new Start(Location.newInstance(0,0),0,100); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(nextS).build(); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(mock(VehicleRoutingProblem.class)) ); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp)); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,0); assertEquals(-10.,c,0.01); @@ -185,18 +215,21 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenAddingNewBetweenStartAndAct2_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build(); Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)) .setTimeWindow(TimeWindow.newInstance(140,150)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addJob(nextS).addVehicle(v2).build(); + Start prevAct = new Start(Location.newInstance(0,0),0,100); -// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); - ServiceActivity newAct = ServiceActivity.newInstance(newS); - ServiceActivity nextAct = ServiceActivity.newInstance(nextS); - VehicleRoute route = VehicleRoute.Builder.newInstance(v2).addService(nextS).build(); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v2).setJobActivityFactory(vrp.getJobActivityFactory()).addService(nextS).build(); JobInsertionContext context = new JobInsertionContext(route,newS,v2,null,0.); - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(), null); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(), new StateManager(vrp)); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,0); assertEquals(-10.,c,0.01); @@ -205,21 +238,19 @@ public class TestLocalActivityInsertionCostsCalculator { @Test public void whenAddingNewInEmptyRoute_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).setTimeWindow(TimeWindow.newInstance(100, 150)).build(); -// Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build(); + + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addVehicle(v).build(); + Start prevAct = new Start(Location.newInstance(0,0),0,100); -// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); - ServiceActivity newAct = ServiceActivity.newInstance(newS); + TourActivity newAct = vrp.getActivities(newS).get(0); End nextAct = new End(Location.newInstance(0,0),0,100); -// ServiceActivity nextAct = ServiceActivity.newInstance(nextS); -// ServiceActivity nextAct = ServiceActivity.newInstance(nextS); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).build(); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).build(); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp) ); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,0); assertEquals(110.,c,0.01); @@ -229,20 +260,21 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenAddingNewBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10, 0)).build(); Service newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(20, 0)).build(); Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build(); - ServiceActivity prevAct = ServiceActivity.newInstance(prevS); - ServiceActivity newAct = ServiceActivity.newInstance(newS); - ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).build(); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp) ); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,10); assertEquals(-10.,c,0.01); @@ -252,20 +284,21 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenAddingNewWithTWBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100, 120)).setLocation(Location.newInstance(20, 0)).build(); Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build(); - ServiceActivity prevAct = ServiceActivity.newInstance(prevS); - ServiceActivity newAct = ServiceActivity.newInstance(newS); - ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).build(); + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).build(); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),new StateManager(vrp) ); calc.setSolutionCompletenessRatio(0.5); double c = calc.getCosts(context,prevAct,nextAct,newAct,10); assertEquals(35.,c,0.01); @@ -275,7 +308,7 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenAddingNewWithTWBetweenTwoActs2_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); // VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); @@ -284,33 +317,39 @@ public class TestLocalActivityInsertionCostsCalculator { Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(400,500)).build(); - ServiceActivity prevAct = ServiceActivity.newInstance(prevS); - ServiceActivity newAct = ServiceActivity.newInstance(newS); - ServiceActivity nextAct = ServiceActivity.newInstance(nextS); + VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(afterNextS).addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build(); + + TourActivity prevAct = vrp.getActivities(prevS).get(0); + TourActivity newAct = vrp.getActivities(newS).get(0); + TourActivity nextAct = vrp.getActivities(nextS).get(0); + + VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).build(); + + StateManager stateManager = getStateManager(vrp,route); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(prevS).addService(nextS).addService(afterNextS).build(); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),null ); + LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(-90.,c,0.01); - //360 - //270 + assertEquals(-10.,c,0.01); + // + //old: dist: 0, waiting: 10 + 350 = 360 + //new: dist: 0, waiting: 80 + 270 = 350 } @Test public void whenAddingNewWithTWBetweenTwoActs3_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); // VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); - Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100,120)).setLocation(Location.newInstance(20, 0)).build(); - Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build(); + Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(100, 120)).setLocation(Location.newInstance(20, 0)).build(); + Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30, 0)).setTimeWindow(TimeWindow.newInstance(40, 500)).build(); - Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80,500)).build(); - Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); + Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(80, 500)).build(); + Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(100, 500)).build(); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) .addJob(afterNextS).addJob(afterAfterNextS).build(); @@ -321,7 +360,7 @@ public class TestLocalActivityInsertionCostsCalculator { VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); - StateManager stateManager = getStateManager(vrp,route); + StateManager stateManager = getStateManager(vrp, route); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); @@ -340,7 +379,7 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenAddingNewWithTWBetweenTwoActs4_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(false).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); // VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); @@ -382,7 +421,7 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenAddingNewWithTWBetweenTwoActs4WithVarStart_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); // VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); @@ -407,13 +446,15 @@ public class TestLocalActivityInsertionCostsCalculator { LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(0.,c,0.01); + assertEquals(30.,c,0.01); /* activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings */ /* old = 10 + 30 + 10 = 50 - new = 80 + 0 - 10 - min{80,40} = 30 + new = 80 + new - old = 80 - 40 = 40 + */ } @@ -421,7 +462,7 @@ public class TestLocalActivityInsertionCostsCalculator { public void whenAddingNewWithTWBetweenTwoActs3WithVarStart_itShouldCalcInsertionCostsCorrectly(){ VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); + VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).build(); // VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); @@ -446,148 +487,26 @@ public class TestLocalActivityInsertionCostsCalculator { LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); calc.setSolutionCompletenessRatio(1.); double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(0.,c,0.01); + assertEquals(-10.,c,0.01); /* activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings */ /* - old = s:40,act1:50,act2:60,act3:70,act4:90 --> w=10 - new = s:30,act1:40,act2:50,act3:70,act4:80,act5:90 --> w=10 => -10 + old = 10 + 40 = 50 + new = 30 + 10 = 40 */ } - @Test - public void whenAddingNewWithTWBetweenTwoActs2WithVarStart_itShouldCalcInsertionCostsCorrectly(){ - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); - Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); - Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(10,20)).setLocation(Location.newInstance(20, 0)).build(); - Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,70)).build(); - Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(50,100)).build(); - Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); - VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) - .addJob(afterNextS).addJob(afterAfterNextS).build(); - - TourActivity prevAct = vrp.getActivities(prevS).get(0); - TourActivity newAct = vrp.getActivities(newS).get(0); - TourActivity nextAct = vrp.getActivities(nextS).get(0); - - VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); - JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - - StateManager stateManager = getStateManager(vrp, route); - - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); - calc.setSolutionCompletenessRatio(1.); - double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(30.,c,0.01); - /* - activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings - */ - /* - old = s:40,act1:50,act2:60,70,act3:(70,80),act4:90 --> w=10 - new = s:0,act1:10,act2:20,act3:(40,50),act4:50,act5:60 --> w=40 => 20 - */ - } - - @Test - public void whenAddingNewWithTWBetweenTwoActs1WithVarStart_itShouldCalcInsertionCostsCorrectly(){ - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); - - Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); - Service newS = Service.Builder.newInstance("new").setServiceTime(10).setTimeWindow(TimeWindow.newInstance(10,20)).setLocation(Location.newInstance(20, 0)).build(); - Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,70)).build(); - - Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(50,100)).build(); - Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)).setTimeWindow(TimeWindow.newInstance(100,500)).build(); - - VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) - .addJob(afterNextS).addJob(afterAfterNextS).build(); - - TourActivity prevAct = vrp.getActivities(prevS).get(0); - TourActivity newAct = vrp.getActivities(newS).get(0); - TourActivity nextAct = vrp.getActivities(nextS).get(0); - - VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); - JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - - StateManager stateManager = getStateManager(vrp, route); - - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); - calc.setSolutionCompletenessRatio(1.); - double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(30.,c,0.01); - /* - activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings - */ - /* - old = s:40,act1:50,act2:60,70,act3:(70,80),act4:90 --> w=10 - new = s:0,act1:10,act2:20,act3:(40,50),act4:50,act5:60 --> w=40 => 20 - */ - } - - @Test - public void whenAddingNewWithTWBetweenTwoActs5WithVarStart_itShouldCalcInsertionCostsCorrectly(){ - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); - - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); -// VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setHasVariableDepartureTime(true).setType(type).setStartLocation(Location.newInstance(0,0)).build(); - - Service prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build(); - Service newS = Service.Builder.newInstance("new").setServiceTime(10) - .setTimeWindow(TimeWindow.newInstance(0,20)) - .setLocation(Location.newInstance(20, 0)).build(); - Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)) -// .setTimeWindow(TimeWindow.newInstance(40,80)) - .build(); - - Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)) -// .setTimeWindow(TimeWindow.newInstance(50,100)) - .build(); - Service afterAfterNextS = Service.Builder.newInstance("afterAfterNext").setLocation(Location.newInstance(50,0)) - .setTimeWindow(TimeWindow.newInstance(100,500)) - .build(); - - VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS) - .addJob(afterNextS).addJob(afterAfterNextS).build(); - - TourActivity prevAct = vrp.getActivities(prevS).get(0); - TourActivity newAct = vrp.getActivities(newS).get(0); - TourActivity nextAct = vrp.getActivities(nextS).get(0); - - VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()).addService(prevS).addService(nextS).addService(afterNextS).addService(afterAfterNextS).build(); - JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); - - StateManager stateManager = getStateManager(vrp, route); - - LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); - calc.setSolutionCompletenessRatio(1.); - double c = calc.getCosts(context,prevAct,nextAct,newAct,10); - assertEquals(40.,c,0.01); - /* - activity start time delay at next act = start-time-old - start-time-new is always bigger than subsequent waiting time savings - */ - /* - old = s:40,act1:50,act2:60,70,act3:(70,80),act4:90 --> w=10 - new = s:0,act1:10,act2:20,act3:(40,50),act4:50,act5:60 --> w=40 => 20 - */ - } private StateManager getStateManager(VehicleRoutingProblem vrp, VehicleRoute route) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts())); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(),stateManager )); stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList()); return stateManager; } diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java deleted file mode 100644 index 29a6147e..00000000 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java +++ /dev/null @@ -1,130 +0,0 @@ -package jsprit.core.algorithm.state; - -import jsprit.core.problem.Location; -import jsprit.core.problem.VehicleRoutingProblem; -import jsprit.core.problem.job.Service; -import jsprit.core.problem.solution.route.RouteVisitor; -import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.TimeWindow; -import jsprit.core.problem.vehicle.VehicleImpl; -import jsprit.core.util.CostFactory; -import junit.framework.Assert; -import org.junit.Before; -import org.junit.Test; - -import static org.mockito.Mockito.mock; - -/** - * Created by schroeder on 22/07/15. - */ -public class UpdateDepartureTimeTest { - - RouteVisitor revVisitors; - - @Before - public void doBefore(){ - StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class)); - revVisitors = new UpdateDepartureTime(CostFactory.createManhattanCosts(), stateManager); - } - - @Test - public void whenNoTimeWindow_departureTimeShouldBeEarliestStartTime(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance(10,0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - revVisitors.visit(route); - - Assert.assertEquals(0.,route.getDepartureTime()); - } - - @Test - public void whenNoTimeWindow_departureTimeShouldBeEarliestStartTime2(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(10).setStartLocation(Location.newInstance(0, 0)).build(); - Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance(10,0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - revVisitors.visit(route); - - Assert.assertEquals(10.,route.getDepartureTime()); - } - - @Test - public void whenTimeWindowAndNoWaitingTime_departureTimeShouldBeEarliestStartTime1(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(5,20)).setLocation(Location.newInstance(10, 0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - revVisitors.visit(route); - - Assert.assertEquals(0.,route.getDepartureTime()); - } - - @Test - public void whenTimeWindowAndNoWaitingTime_departureTimeShouldBeEarliestStartTime2(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(10).setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(5,20)).setLocation(Location.newInstance(10, 0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - revVisitors.visit(route); - - Assert.assertEquals(10.,route.getDepartureTime()); - } - - @Test - public void whenTimeWindowAndWaitingTime_departureTimeShouldChange(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setEarliestStart(0) - .setHasVariableDepartureTime(true) - .setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(15,20)).setLocation(Location.newInstance(10, 0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - revVisitors.visit(route); - - Assert.assertEquals(5.,route.getDepartureTime()); - } - - @Test - public void whenTimeWindowAndWaitingTime_departureTimeShouldChange2(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(5).setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(18,20)).setLocation(Location.newInstance(10, 0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).build(); - revVisitors.visit(route); - - Assert.assertEquals(8.,route.getDepartureTime()); - } - - @Test - public void whenTimeWindowAndWaitingTime_departureTimeShouldChange3(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s") - .setTimeWindow(TimeWindow.newInstance(15, 20)).setLocation(Location.newInstance(10, 0)).build(); - Service s2 = Service.Builder.newInstance("s2") - .setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance(20, 0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).addService(s2).build(); - revVisitors.visit(route); - - Assert.assertEquals(5.,route.getDepartureTime()); - } - - @Test - public void whenTimeWindowAndWaitingTime_departureTimeShouldChange4(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s") - .setTimeWindow(TimeWindow.newInstance(15, 20)).setLocation(Location.newInstance(10, 0)).build(); - Service s2 = Service.Builder.newInstance("s2") - .setTimeWindow(TimeWindow.newInstance(29,40)).setLocation(Location.newInstance(20, 0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).addService(s2).build(); - revVisitors.visit(route); - - Assert.assertEquals(9.,route.getDepartureTime()); - } - - @Test - public void whenTimeWindowAndWaitingTime_departureTimeShouldChange5(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setHasVariableDepartureTime(true).setEarliestStart(0).setStartLocation(Location.newInstance(0,0)).build(); - Service s = Service.Builder.newInstance("s") - .setTimeWindow(TimeWindow.newInstance(15, 20)).setLocation(Location.newInstance(10, 0)).build(); - Service s2 = Service.Builder.newInstance("s2") - .setTimeWindow(TimeWindow.newInstance(35,40)).setLocation(Location.newInstance(20, 0)).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(s).addService(s2).build(); - revVisitors.visit(route); - - Assert.assertEquals(10.,route.getDepartureTime()); - } -} diff --git a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java b/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java deleted file mode 100644 index 62b7d3b0..00000000 --- a/jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java +++ /dev/null @@ -1,119 +0,0 @@ -package jsprit.core.algorithm.state; - -import jsprit.core.problem.Location; -import jsprit.core.problem.VehicleRoutingProblem; -import jsprit.core.problem.job.Service; -import jsprit.core.problem.solution.route.VehicleRoute; -import jsprit.core.problem.solution.route.activity.TimeWindow; -import jsprit.core.problem.vehicle.VehicleImpl; -import jsprit.core.problem.vehicle.VehicleType; -import jsprit.core.problem.vehicle.VehicleTypeImpl; -import jsprit.core.util.CostFactory; -import junit.framework.Assert; -import org.junit.Test; - -import java.util.Arrays; - -/** - * Created by schroeder on 29/07/15. - */ -public class UpdateTimeSlackTest { - - - @Test - public void test_withoutTW(){ - VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); - VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); - Service service = Service.Builder.newInstance("s").setLocation(Location.newInstance("0,10")).build(); - Service service2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance("10,10")).build(); - Service service3 = Service.Builder.newInstance("s3").setLocation(Location.newInstance("10,0")).build(); - VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) - .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); - - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); - stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); - stateManager.informInsertionStarts(Arrays.asList(route), null); - - double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - Assert.assertEquals(160.,timeSlack_act1); - Assert.assertEquals(160.,timeSlack_act2); - Assert.assertEquals(160.,timeSlack_act3); - } - - @Test - public void test_TW(){ - VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); - VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); - Service service = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance("0,10")).build(); - Service service2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(0, 40)).setLocation(Location.newInstance("10,10")).build(); - Service service3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(80, 120)).setLocation(Location.newInstance("10,0")).build(); - VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) - .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); - - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); - stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); - stateManager.informInsertionStarts(Arrays.asList(route), null); - - double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - Assert.assertEquals(20.,timeSlack_act1); - Assert.assertEquals(20.,timeSlack_act2); - Assert.assertEquals(0.,timeSlack_act3); - } - - @Test - public void test_TW2(){ - VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); - VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); - Service service = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance("0,10")).build(); - Service service2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(0,40)).setLocation(Location.newInstance("10,10")).build(); - Service service3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(40,120)).setLocation(Location.newInstance("10,0")).build(); - VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) - .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); - - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); - stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); - stateManager.informInsertionStarts(Arrays.asList(route), null); - - double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - Assert.assertEquals(20.,timeSlack_act1); - Assert.assertEquals(20.,timeSlack_act2); - Assert.assertEquals(10.,timeSlack_act3); - } - - @Test - public void test_TW3(){ - VehicleType type = VehicleTypeImpl.Builder.newInstance("t").build(); - VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setLatestArrival(200).setStartLocation(Location.newInstance("0,0")).setType(type).build(); - Service service = Service.Builder.newInstance("s").setTimeWindow(TimeWindow.newInstance(10,40)).setLocation(Location.newInstance("0,10")).build(); - Service service2 = Service.Builder.newInstance("s2").setTimeWindow(TimeWindow.newInstance(30,60)).setLocation(Location.newInstance("10,10")).build(); - Service service3 = Service.Builder.newInstance("s3").setTimeWindow(TimeWindow.newInstance(40,120)).setLocation(Location.newInstance("10,0")).build(); - VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service) - .addJob(service2).addJob(service3).setRoutingCost(CostFactory.createManhattanCosts()).build(); - VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(service).addService(service2).addService(service3).build(); - - StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,CostFactory.createManhattanCosts())); - stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,CostFactory.createManhattanCosts())); - stateManager.informInsertionStarts(Arrays.asList(route), null); - - double timeSlack_act1 = stateManager.getActivityState(route.getActivities().get(0),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act2 = stateManager.getActivityState(route.getActivities().get(1),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - double timeSlack_act3 = stateManager.getActivityState(route.getActivities().get(2),route.getVehicle(),InternalStates.TIME_SLACK,Double.class); - Assert.assertEquals(30.,timeSlack_act1); - Assert.assertEquals(20.,timeSlack_act2); - Assert.assertEquals(20.,timeSlack_act3); - } - -} diff --git a/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java b/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java index 229c46d9..102cf0fb 100644 --- a/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java +++ b/jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java @@ -221,15 +221,5 @@ public class VehicleImplTest { assertFalse(v.getSkills().containsSkill("ScrewDriver")); } - @Test - public void whenSettingVariableDeparture_itShouldBeSet(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("loc")).setHasVariableDepartureTime(true).build(); - assertTrue(v.hasVariableDepartureTime()); - } - @Test - public void defaultOfHasVariableDepartureShouldBeFalse(){ - VehicleImpl v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("loc")).build(); - assertFalse(v.hasVariableDepartureTime()); - } } diff --git a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java index 9ad267f1..9ee8f538 100644 --- a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java +++ b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java @@ -5,8 +5,7 @@ import jsprit.analysis.toolbox.Plotter; import jsprit.core.algorithm.VehicleRoutingAlgorithm; import jsprit.core.algorithm.box.Jsprit; import jsprit.core.algorithm.state.StateManager; -import jsprit.core.algorithm.state.UpdateDepartureTime; -import jsprit.core.algorithm.state.UpdateTimeSlack; +import jsprit.core.algorithm.state.UpdateFutureWaitingTimes; import jsprit.core.analysis.SolutionAnalyser; import jsprit.core.problem.Location; import jsprit.core.problem.VehicleRoutingProblem; @@ -38,28 +37,32 @@ public class VariableStartAndWaitingTimeExample { public static void main(String[] args) { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); - VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); - VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type2").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); + VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(3.).setCostPerWaitingTime(2.0).build(); +// VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type2").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); - VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true) - .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type1).setReturnToDepot(true) - .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); - VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type2).setReturnToDepot(true) - .setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); + VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(false) + .setStartLocation(Location.newInstance(0, 0)) +// .setEarliestStart(0).setLatestArrival(400) + .build(); + VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type1).setReturnToDepot(false) + .setStartLocation(Location.newInstance(0, 0)) +// .setEarliestStart(0).setLatestArrival(400) + .build(); +// VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type2).setReturnToDepot(true) +// .setStartLocation(Location.newInstance(0, 0)).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); Random r = RandomNumberGeneration.newInstance(); for(int i=0;i<40;i++){ - Service s = Service.Builder.newInstance("s_"+i).setServiceTime(1) + Service s = Service.Builder.newInstance("s_"+i).setServiceTime(5) // .setTimeWindow(TimeWindow.newInstance(r.nextInt(50),100+r.nextInt(150))) .setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build(); vrpBuilder.addJob(s); } - Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-3, 15)).setTimeWindow(TimeWindow.newInstance(20, 60)).build(); + Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-3, 15)).setTimeWindow(TimeWindow.newInstance(290, 600)).build(); // Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(5,15)).setTimeWindow(TimeWindow.newInstance(100, 160)).build(); - Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(200, 250)).build(); - Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10, 10)).setTimeWindow(TimeWindow.newInstance(300, 310)).build(); - vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addVehicle(v4).addVehicle(v2).addVehicle(v3); + Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(0, 250)).build(); + Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10, 10)).setTimeWindow(TimeWindow.newInstance(300, 600)).build(); + vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addVehicle(v2).addVehicle(v3); vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); final VehicleRoutingProblem vrp = vrpBuilder.build(); @@ -67,8 +70,7 @@ public class VariableStartAndWaitingTimeExample { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); - stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts())); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) diff --git a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java index 06ef61b4..fe29c99f 100644 --- a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java +++ b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java @@ -5,8 +5,7 @@ import jsprit.analysis.toolbox.Plotter; import jsprit.core.algorithm.VehicleRoutingAlgorithm; import jsprit.core.algorithm.box.Jsprit; import jsprit.core.algorithm.state.StateManager; -import jsprit.core.algorithm.state.UpdateDepartureTime; -import jsprit.core.algorithm.state.UpdateTimeSlack; +import jsprit.core.algorithm.state.UpdateFutureWaitingTimes; import jsprit.core.problem.Location; import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.constraint.ConstraintManager; @@ -32,11 +31,11 @@ public class VariableStartAndWaitingTimeExample2 { public static void main(String[] args) { - VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.5).setCostPerWaitingTime(1.0).build(); + VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(1.5).setCostPerWaitingTime(1.).build(); // VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(1.5).setCostPerWaitingTime(.0).build(); VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true) - .setHasVariableDepartureTime(false).setStartLocation(Location.newInstance(0, 0)).build(); + .setStartLocation(Location.newInstance(0, 0)).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); @@ -45,7 +44,7 @@ public class VariableStartAndWaitingTimeExample2 { Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(0, 10)).build(); Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(1, 12)).build(); Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(4, 10)).build(); - Service s5 = Service.Builder.newInstance("s14").setLocation(Location.newInstance(6, 5)).setTimeWindow(TimeWindow.newInstance(100,220)).build(); + Service s5 = Service.Builder.newInstance("s14").setLocation(Location.newInstance(6, 5)).setTimeWindow(TimeWindow.newInstance(110,220)).build(); vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addJob(s4).addJob(s5).addVehicle(v2); vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); final VehicleRoutingProblem vrp = vrpBuilder.build(); @@ -54,8 +53,7 @@ public class VariableStartAndWaitingTimeExample2 { @Override public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { StateManager stateManager = new StateManager(vrp); - stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); - stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts())); + stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts())); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); return Jsprit.Builder.newInstance(vrp) From d6e17f03ea346b97be5917be7e8b105455a7e79d Mon Sep 17 00:00:00 2001 From: oblonski Date: Tue, 4 Aug 2015 15:30:32 +0200 Subject: [PATCH 7/7] mod example --- .../VariableStartAndWaitingTimeExample.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java index 9ee8f538..7e9c80ae 100644 --- a/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java +++ b/jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java @@ -37,16 +37,16 @@ public class VariableStartAndWaitingTimeExample { public static void main(String[] args) { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); - VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(3.).setCostPerWaitingTime(2.0).build(); + VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); // VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type2").setCostPerDistance(4.).setCostPerWaitingTime(2.0).build(); VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(false) .setStartLocation(Location.newInstance(0, 0)) -// .setEarliestStart(0).setLatestArrival(400) + .setEarliestStart(0).setLatestArrival(220) .build(); VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type1).setReturnToDepot(false) - .setStartLocation(Location.newInstance(0, 0)) -// .setEarliestStart(0).setLatestArrival(400) + .setStartLocation(Location.newInstance(0, 10)) + .setEarliestStart(200).setLatestArrival(450) .build(); // VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type2).setReturnToDepot(true) // .setStartLocation(Location.newInstance(0, 0)).build(); @@ -54,15 +54,15 @@ public class VariableStartAndWaitingTimeExample { Random r = RandomNumberGeneration.newInstance(); for(int i=0;i<40;i++){ Service s = Service.Builder.newInstance("s_"+i).setServiceTime(5) -// .setTimeWindow(TimeWindow.newInstance(r.nextInt(50),100+r.nextInt(150))) +// .setTimeWindow(TimeWindow.newInstance(0,100*(1+r.nextInt(3)))) .setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build(); vrpBuilder.addJob(s); } Service s1 = Service.Builder.newInstance("s12").setLocation(Location.newInstance(-3, 15)).setTimeWindow(TimeWindow.newInstance(290, 600)).build(); -// Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(5,15)).setTimeWindow(TimeWindow.newInstance(100, 160)).build(); - Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(0, 250)).build(); + Service s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(0,20)).setTimeWindow(TimeWindow.newInstance(290, 340)).build(); + Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(-1, 15)).setTimeWindow(TimeWindow.newInstance(300, 350)).build(); Service s3 = Service.Builder.newInstance("s11").setLocation(Location.newInstance(10, 10)).setTimeWindow(TimeWindow.newInstance(300, 600)).build(); - vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addVehicle(v2).addVehicle(v3); + vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addJob(s4).addVehicle(v2).addVehicle(v3); vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); final VehicleRoutingProblem vrp = vrpBuilder.build();