trans/graphhopper-jsprit
1
0
Fork 0
mirror of https://github.com/graphhopper/jsprit.git synced 2020-01-24 07:45:05 +01:00
Code Issues Releases Wiki Activity

separate waiting time feature from variable start times

Browse source
This commit is contained in:
oblonski 2015-08-03 22:31:55 +02:00
parent 70d6ae1797
commit c8eb1dd7b4
14 changed files with 148 additions and 1002 deletions
Download patch file Download diff file Expand all files Collapse all files

66
jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java
View file

@ -23,7 +23,6 @@ import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.misc.JobInsertionContext;
import jsprit.core.problem.solution.route.activity.End; 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.activity.TourActivity;
import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter; import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
@ -45,12 +44,10 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal
private VehicleRoutingActivityCosts activityCosts; private VehicleRoutingActivityCosts activityCosts;
private double activityCostsWeight = 0.75; private double activityCostsWeight = 1.;
private double solutionCompletenessRatio = 1.; private double solutionCompletenessRatio = 1.;
private double variableStartTimeFactor = 1.;
private RouteAndActivityStateGetter stateManager; private RouteAndActivityStateGetter stateManager;
public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, RouteAndActivityStateGetter stateManager) { public LocalActivityInsertionCostsCalculator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, RouteAndActivityStateGetter stateManager) {
@ -60,10 +57,6 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal
this.stateManager = stateManager; this.stateManager = stateManager;
} }
public void setVariableStartTimeFactor(double variableStartTimeFactor) {
this.variableStartTimeFactor = variableStartTimeFactor;
}
@Override @Override
public double getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) { 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 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; 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_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 endTime_nextAct_new = CalculationUtils.getActivityEndTime(nextAct_arrTime, nextAct);
double act_costs_nextAct = activityCosts.getActivityCost(nextAct, nextAct_arrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); 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 totalCosts = tp_costs_prevAct_newAct + tp_costs_newAct_nextAct + solutionCompletenessRatio * activityCostsWeight * (act_costs_newAct + act_costs_nextAct);
double oldCosts = 0.; 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 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 endTime_nextAct_old = CalculationUtils.getActivityEndTime(arrTime_nextAct,nextAct);
double actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct, 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; 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);
else if(hasVariableDeparture(iFacts.getRoute().getVehicle())){ if (futureWaiting == null) futureWaiting = 0.;
actCost_nextAct = activityCosts.getActivityCost(nextAct, arrTime_nextAct + slack_time_prev, iFacts.getRoute().getDriver(), iFacts.getRoute().getVehicle()); double waitingTime_savings_timeUnit = Math.min(futureWaiting, endTimeDelay_nextAct);
Double earliestWithoutWaiting = stateManager.getActivityState(nextAct,iFacts.getRoute().getVehicle(),InternalStates.EARLIEST_WITHOUT_WAITING,Double.class); double waitingTime_savings = waitingTime_savings_timeUnit * iFacts.getRoute().getVehicle().getType().getVehicleCostParams().perWaitingTimeUnit;
if(earliestWithoutWaiting != null){ oldCosts += solutionCompletenessRatio * activityCostsWeight * waitingTime_savings;
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;
}
oldCosts += tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct; oldCosts += tp_costs_prevAct_nextAct + solutionCompletenessRatio * activityCostsWeight * actCost_nextAct;
} }
return totalCosts - oldCosts; return totalCosts - oldCosts;
@ -144,20 +107,7 @@ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCal
return nextAct instanceof End; 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) { public void setSolutionCompletenessRatio(double solutionCompletenessRatio) {
// this.solutionCompletenessRatio = 1.;
this.solutionCompletenessRatio = solutionCompletenessRatio; this.solutionCompletenessRatio = solutionCompletenessRatio;
} }
} }

109
jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateDepartureTime.java
View file

@ -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 <http://www.gnu.org/licenses/>.
******************************************************************************/
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<TourActivity> revIterator = route.getTourActivities().reverseActivityIterator();
while(revIterator.hasNext()){
visit(revIterator.next());
}
finish();
}
}

81
jsprit-core/src/main/java/jsprit/core/algorithm/state/UpdateTimeSlack.java
View file

@ -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 <http://www.gnu.org/licenses/>.
******************************************************************************/
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.
*
* <p>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() {}
}

1
jsprit-core/src/main/java/jsprit/core/problem/vehicle/Vehicle.java
View file

@ -73,5 +73,4 @@ public interface Vehicle extends HasId, HasIndex {
public abstract Skills getSkills(); public abstract Skills getSkills();
public boolean hasVariableDepartureTime();
} }

17
jsprit-core/src/main/java/jsprit/core/problem/vehicle/VehicleImpl.java
View file

@ -92,10 +92,7 @@ public class VehicleImpl extends AbstractVehicle{
return null; return null;
} }
@Override
public boolean hasVariableDepartureTime() {
return false;
}
} }
/** /**
@ -130,7 +127,6 @@ public class VehicleImpl extends AbstractVehicle{
private Location endLocation; private Location endLocation;
private boolean hasVariableDepartureTime = false;
private Builder(String id) { private Builder(String id) {
super(); super();
@ -150,10 +146,6 @@ public class VehicleImpl extends AbstractVehicle{
return this; return this;
} }
public Builder setHasVariableDepartureTime(boolean hasVariableDepartureTime){
this.hasVariableDepartureTime = hasVariableDepartureTime;
return this;
}
/** /**
* Sets the flag whether the vehicle must return to depot or not. * 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 Location startLocation;
private final boolean hasVariableDepartureTime;
private VehicleImpl(Builder builder){ private VehicleImpl(Builder builder){
id = builder.id; id = builder.id;
type = builder.type; type = builder.type;
@ -297,7 +287,6 @@ public class VehicleImpl extends AbstractVehicle{
skills = builder.skills; skills = builder.skills;
endLocation = builder.endLocation; endLocation = builder.endLocation;
startLocation = builder.startLocation; startLocation = builder.startLocation;
hasVariableDepartureTime = builder.hasVariableDepartureTime;
setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(),startLocation.getId(),endLocation.getId(),earliestDeparture,latestArrival,skills, returnToDepot)); setVehicleIdentifier(new VehicleTypeKey(type.getTypeId(),startLocation.getId(),endLocation.getId(),earliestDeparture,latestArrival,skills, returnToDepot));
} }
@ -356,10 +345,6 @@ public class VehicleImpl extends AbstractVehicle{
return skills; return skills;
} }
@Override
public boolean hasVariableDepartureTime() {
return hasVariableDepartureTime;
}
/* (non-Javadoc) /* (non-Javadoc)
* @see java.lang.Object#hashCode() * @see java.lang.Object#hashCode()

258
jsprit-core/src/test/java/jsprit/core/algorithm/VariableDepartureAndWaitingTime_IT.java
View file

@ -2,7 +2,6 @@ package jsprit.core.algorithm;
import jsprit.core.algorithm.box.Jsprit; import jsprit.core.algorithm.box.Jsprit;
import jsprit.core.algorithm.state.StateManager; import jsprit.core.algorithm.state.StateManager;
import jsprit.core.algorithm.state.UpdateDepartureTime;
import jsprit.core.analysis.SolutionAnalyser; import jsprit.core.analysis.SolutionAnalyser;
import jsprit.core.problem.Location; import jsprit.core.problem.Location;
import jsprit.core.problem.VehicleRoutingProblem; 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.job.Service;
import jsprit.core.problem.solution.SolutionCostCalculator; import jsprit.core.problem.solution.SolutionCostCalculator;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution; 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.TimeWindow;
import jsprit.core.problem.solution.route.activity.TourActivity; import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl; 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.CostFactory;
import jsprit.core.util.RandomNumberGeneration;
import jsprit.core.util.Solutions; import jsprit.core.util.Solutions;
import junit.framework.Assert; import junit.framework.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import java.util.Random;
/** /**
* Created by schroeder on 22/07/15. * Created by schroeder on 22/07/15.
*/ */
@ -56,7 +49,6 @@ public class VariableDepartureAndWaitingTime_IT {
@Override @Override
public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) {
StateManager stateManager = new StateManager(vrp); StateManager stateManager = new StateManager(vrp);
stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(),stateManager ));
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
return Jsprit.Builder.newInstance(vrp) return Jsprit.Builder.newInstance(vrp)
@ -111,256 +103,6 @@ public class VariableDepartureAndWaitingTime_IT {
Assert.assertEquals(40.+1000.,solution.getCost()); 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());
}
} }

2
jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ServiceInsertionAndLoadConstraintsTest.java
View file

@ -95,7 +95,7 @@ public class ServiceInsertionAndLoadConstraintsTest {
routingCosts = CostFactory.createManhattanCosts(); routingCosts = CostFactory.createManhattanCosts();
VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build(); 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(); 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); createInsertionCalculator(hardRouteLevelConstraint);
vehicleRoutingProblem = mock(VehicleRoutingProblem.class); vehicleRoutingProblem = mock(VehicleRoutingProblem.class);
} }

2
jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java
View file

@ -94,7 +94,7 @@ public class ShipmentInsertionCalculatorTest {
routingCosts = CostFactory.createManhattanCosts(); routingCosts = CostFactory.createManhattanCosts();
VehicleType type = VehicleTypeImpl.Builder.newInstance("t").addCapacityDimension(0, 2).setCostPerDistance(1).build(); 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(); 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); createInsertionCalculator(hardRouteLevelConstraint);
vehicleRoutingProblem = mock(VehicleRoutingProblem.class); vehicleRoutingProblem = mock(VehicleRoutingProblem.class);
} }

303
jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestLocalActivityInsertionCostsCalculator.java
View file

@ -16,7 +16,10 @@
******************************************************************************/ ******************************************************************************/
package jsprit.core.algorithm.recreate; 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.Location;
import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.cost.VehicleRoutingActivityCosts; 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.job.Service;
import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.misc.JobInsertionContext;
import jsprit.core.problem.solution.route.VehicleRoute; 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.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl; import jsprit.core.problem.vehicle.VehicleImpl;
import jsprit.core.problem.vehicle.VehicleTypeImpl; import jsprit.core.problem.vehicle.VehicleTypeImpl;
@ -66,6 +72,7 @@ public class TestLocalActivityInsertionCostsCalculator {
jic = mock(JobInsertionContext.class); jic = mock(JobInsertionContext.class);
when(jic.getRoute()).thenReturn(route); when(jic.getRoute()).thenReturn(route);
when(jic.getNewVehicle()).thenReturn(vehicle); when(jic.getNewVehicle()).thenReturn(vehicle);
when(vehicle.getType()).thenReturn(VehicleTypeImpl.Builder.newInstance("type").build());
tpCosts = mock(VehicleRoutingTransportCosts.class); tpCosts = mock(VehicleRoutingTransportCosts.class);
when(tpCosts.getTransportCost(loc("i"), loc("j"), 0.0, null, vehicle)).thenReturn(2.0); 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); when(tpCosts.getTransportTime(loc("k"), loc("j"), 0.0, null, vehicle)).thenReturn(0.0);
actCosts = mock(VehicleRoutingActivityCosts.class); actCosts = mock(VehicleRoutingActivityCosts.class);
calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts, null); calc = new LocalActivityInsertionCostsCalculator(tpCosts, actCosts, mock(StateManager.class));
} }
private Location loc(String i) { private Location loc(String i) {
@ -87,10 +94,13 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenInsertingActBetweenTwoRouteActs_itCalcsMarginalTpCosts(){ public void whenInsertingActBetweenTwoRouteActs_itCalcsMarginalTpCosts(){
TourActivity prevAct = mock(TourActivity.class); TourActivity prevAct = mock(TourActivity.class);
when(prevAct.getLocation()).thenReturn(loc("i")); when(prevAct.getLocation()).thenReturn(loc("i"));
when(prevAct.getIndex()).thenReturn(1);
TourActivity nextAct = mock(TourActivity.class); TourActivity nextAct = mock(TourActivity.class);
when(nextAct.getLocation()).thenReturn(loc("j")); when(nextAct.getLocation()).thenReturn(loc("j"));
when(nextAct.getIndex()).thenReturn(1);
TourActivity newAct = mock(TourActivity.class); TourActivity newAct = mock(TourActivity.class);
when(newAct.getLocation()).thenReturn(loc("k")); when(newAct.getLocation()).thenReturn(loc("k"));
when(newAct.getIndex()).thenReturn(1);
when(vehicle.isReturnToDepot()).thenReturn(true); when(vehicle.isReturnToDepot()).thenReturn(true);
@ -102,9 +112,11 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenInsertingActBetweenLastActAndEnd_itCalcsMarginalTpCosts(){ public void whenInsertingActBetweenLastActAndEnd_itCalcsMarginalTpCosts(){
TourActivity prevAct = mock(TourActivity.class); TourActivity prevAct = mock(TourActivity.class);
when(prevAct.getLocation()).thenReturn(loc("i")); when(prevAct.getLocation()).thenReturn(loc("i"));
when(prevAct.getIndex()).thenReturn(1);
End nextAct = End.newInstance("j", 0.0, 0.0); End nextAct = End.newInstance("j", 0.0, 0.0);
TourActivity newAct = mock(TourActivity.class); TourActivity newAct = mock(TourActivity.class);
when(newAct.getLocation()).thenReturn(loc("k")); when(newAct.getLocation()).thenReturn(loc("k"));
when(newAct.getIndex()).thenReturn(1);
when(vehicle.isReturnToDepot()).thenReturn(true); when(vehicle.isReturnToDepot()).thenReturn(true);
@ -116,10 +128,13 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenInsertingActBetweenTwoRouteActsAndRouteIsOpen_itCalcsMarginalTpCosts(){ public void whenInsertingActBetweenTwoRouteActsAndRouteIsOpen_itCalcsMarginalTpCosts(){
TourActivity prevAct = mock(TourActivity.class); TourActivity prevAct = mock(TourActivity.class);
when(prevAct.getLocation()).thenReturn(loc("i")); when(prevAct.getLocation()).thenReturn(loc("i"));
when(prevAct.getIndex()).thenReturn(1);
TourActivity nextAct = mock(TourActivity.class); TourActivity nextAct = mock(TourActivity.class);
when(nextAct.getLocation()).thenReturn(loc("j")); when(nextAct.getLocation()).thenReturn(loc("j"));
when(nextAct.getIndex()).thenReturn(1);
TourActivity newAct = mock(TourActivity.class); TourActivity newAct = mock(TourActivity.class);
when(newAct.getLocation()).thenReturn(loc("k")); when(newAct.getLocation()).thenReturn(loc("k"));
when(newAct.getIndex()).thenReturn(1);
when(vehicle.isReturnToDepot()).thenReturn(false); when(vehicle.isReturnToDepot()).thenReturn(false);
@ -131,9 +146,11 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenInsertingActBetweenLastActAndEndAndRouteIsOpen_itCalculatesTpCostsFromPrevToNewAct(){ public void whenInsertingActBetweenLastActAndEndAndRouteIsOpen_itCalculatesTpCostsFromPrevToNewAct(){
TourActivity prevAct = mock(TourActivity.class); TourActivity prevAct = mock(TourActivity.class);
when(prevAct.getLocation()).thenReturn(loc("i")); when(prevAct.getLocation()).thenReturn(loc("i"));
when(prevAct.getIndex()).thenReturn(1);
End nextAct = End.newInstance("j", 0.0, 0.0); End nextAct = End.newInstance("j", 0.0, 0.0);
TourActivity newAct = mock(TourActivity.class); TourActivity newAct = mock(TourActivity.class);
when(newAct.getLocation()).thenReturn(loc("k")); when(newAct.getLocation()).thenReturn(loc("k"));
when(newAct.getIndex()).thenReturn(1);
when(vehicle.isReturnToDepot()).thenReturn(false); 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(); 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 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 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(); Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,80)).build();
ServiceActivity prevAct = ServiceActivity.newInstance(prevS);
ServiceActivity newAct = ServiceActivity.newInstance(newS); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
ServiceActivity nextAct = ServiceActivity.newInstance(nextS);
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.); 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(mock(VehicleRoutingProblem.class)));
calc.setSolutionCompletenessRatio(1.); calc.setSolutionCompletenessRatio(1.);
calc.setVariableStartTimeFactor(.8);
double c = calc.getCosts(context,prevAct,nextAct,newAct,0); double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
assertEquals(40.,c,0.01); assertEquals(50.,c,0.01);
/*
new: dist = 90 & wait = 0
old: dist = 30 & wait = 10
c = new - old = 90 - 40 = 50
*/
} }
@Test @Test
public void whenAddingNewBetweenStartAndAct_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewBetweenStartAndAct_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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 newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build();
Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30, 0)) Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30, 0))
.setTimeWindow(TimeWindow.newInstance(40, 50)).build(); .setTimeWindow(TimeWindow.newInstance(40, 50)).build();
Start prevAct = new Start(Location.newInstance(0,0),0,100);
ServiceActivity newAct = ServiceActivity.newInstance(newS); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addJob(nextS).addVehicle(v).build();
ServiceActivity nextAct = ServiceActivity.newInstance(nextS);
VehicleRoute route = VehicleRoute.Builder.newInstance(v).addService(nextS).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.); 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.); calc.setSolutionCompletenessRatio(1.);
double c = calc.getCosts(context,prevAct,nextAct,newAct,0); double c = calc.getCosts(context,prevAct,nextAct,newAct,0);
assertEquals(-10.,c,0.01); assertEquals(-10.,c,0.01);
@ -185,18 +215,21 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenAddingNewBetweenStartAndAct2_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewBetweenStartAndAct2_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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 newS = Service.Builder.newInstance("new").setServiceTime(10).setLocation(Location.newInstance(10, 0)).build();
Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)) Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0))
.setTimeWindow(TimeWindow.newInstance(140,150)).build(); .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); Start prevAct = new Start(Location.newInstance(0,0),0,100);
// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); TourActivity newAct = vrp.getActivities(newS).get(0);
ServiceActivity newAct = ServiceActivity.newInstance(newS); TourActivity nextAct = vrp.getActivities(nextS).get(0);
ServiceActivity nextAct = ServiceActivity.newInstance(nextS);
VehicleRoute route = VehicleRoute.Builder.newInstance(v2).addService(nextS).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v2).setJobActivityFactory(vrp.getJobActivityFactory()).addService(nextS).build();
JobInsertionContext context = new JobInsertionContext(route,newS,v2,null,0.); 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.); calc.setSolutionCompletenessRatio(1.);
double c = calc.getCosts(context,prevAct,nextAct,newAct,0); double c = calc.getCosts(context,prevAct,nextAct,newAct,0);
assertEquals(-10.,c,0.01); assertEquals(-10.,c,0.01);
@ -205,21 +238,19 @@ public class TestLocalActivityInsertionCostsCalculator {
@Test @Test
public void whenAddingNewInEmptyRoute_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewInEmptyRoute_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build();
VehicleImpl v = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance(0,0)).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();
VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(newS).addVehicle(v).build();
Start prevAct = new Start(Location.newInstance(0,0),0,100); Start prevAct = new Start(Location.newInstance(0,0),0,100);
// ServiceActivity prevAct = ServiceActivity.newInstance(prevS); TourActivity newAct = vrp.getActivities(newS).get(0);
ServiceActivity newAct = ServiceActivity.newInstance(newS);
End nextAct = new End(Location.newInstance(0,0),0,100); 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).setJobActivityFactory(vrp.getJobActivityFactory()).build();
VehicleRoute route = VehicleRoute.Builder.newInstance(v).build();
JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.); 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.); calc.setSolutionCompletenessRatio(1.);
double c = calc.getCosts(context,prevAct,nextAct,newAct,0); double c = calc.getCosts(context,prevAct,nextAct,newAct,0);
assertEquals(110.,c,0.01); assertEquals(110.,c,0.01);
@ -229,20 +260,21 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenAddingNewBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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 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 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(); Service nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,50)).build();
ServiceActivity prevAct = ServiceActivity.newInstance(prevS); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
ServiceActivity newAct = ServiceActivity.newInstance(newS);
ServiceActivity nextAct = ServiceActivity.newInstance(nextS);
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.); 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.); calc.setSolutionCompletenessRatio(1.);
double c = calc.getCosts(context,prevAct,nextAct,newAct,10); double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
assertEquals(-10.,c,0.01); assertEquals(-10.,c,0.01);
@ -252,20 +284,21 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenAddingNewWithTWBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewWithTWBetweenTwoActs_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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 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 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 nextS = Service.Builder.newInstance("next").setLocation(Location.newInstance(30,0)).setTimeWindow(TimeWindow.newInstance(40,500)).build();
ServiceActivity prevAct = ServiceActivity.newInstance(prevS); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
ServiceActivity newAct = ServiceActivity.newInstance(newS);
ServiceActivity nextAct = ServiceActivity.newInstance(nextS);
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.); 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); calc.setSolutionCompletenessRatio(0.5);
double c = calc.getCosts(context,prevAct,nextAct,newAct,10); double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
assertEquals(35.,c,0.01); assertEquals(35.,c,0.01);
@ -275,7 +308,7 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenAddingNewWithTWBetweenTwoActs2_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewWithTWBetweenTwoActs2_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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(); // 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 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(); Service afterNextS = Service.Builder.newInstance("afterNext").setLocation(Location.newInstance(40,0)).setTimeWindow(TimeWindow.newInstance(400,500)).build();
ServiceActivity prevAct = ServiceActivity.newInstance(prevS); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(afterNextS).addJob(prevS).addJob(newS).addJob(nextS).addVehicle(v).build();
ServiceActivity newAct = ServiceActivity.newInstance(newS);
ServiceActivity nextAct = ServiceActivity.newInstance(nextS); 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.); 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.); calc.setSolutionCompletenessRatio(1.);
double c = calc.getCosts(context,prevAct,nextAct,newAct,10); double c = calc.getCosts(context,prevAct,nextAct,newAct,10);
assertEquals(-90.,c,0.01); assertEquals(-10.,c,0.01);
//360 //
//270 //old: dist: 0, waiting: 10 + 350 = 360
//new: dist: 0, waiting: 80 + 270 = 350
} }
@Test @Test
public void whenAddingNewWithTWBetweenTwoActs3_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewWithTWBetweenTwoActs3_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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(); // 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 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 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 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 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 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) VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(v).addJob(prevS).addJob(newS).addJob(nextS)
.addJob(afterNextS).addJob(afterAfterNextS).build(); .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(); 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.); JobInsertionContext context = new JobInsertionContext(route,newS,v,null,0.);
LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager); LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
@ -340,7 +379,7 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenAddingNewWithTWBetweenTwoActs4_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewWithTWBetweenTwoActs4_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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(); // 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 prevS = Service.Builder.newInstance("prev").setLocation(Location.newInstance(10,0)).build();
@ -382,7 +421,7 @@ public class TestLocalActivityInsertionCostsCalculator {
public void whenAddingNewWithTWBetweenTwoActs4WithVarStart_itShouldCalcInsertionCostsCorrectly(){ public void whenAddingNewWithTWBetweenTwoActs4WithVarStart_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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(); // 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 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); LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
calc.setSolutionCompletenessRatio(1.); calc.setSolutionCompletenessRatio(1.);
double c = calc.getCosts(context,prevAct,nextAct,newAct,10); 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 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 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(){ public void whenAddingNewWithTWBetweenTwoActs3WithVarStart_itShouldCalcInsertionCostsCorrectly(){
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").setCostPerWaitingTime(1.).build(); 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(); // 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 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); LocalActivityInsertionCostsCalculator calc = new LocalActivityInsertionCostsCalculator(CostFactory.createEuclideanCosts(),new WaitingTimeCosts(),stateManager);
calc.setSolutionCompletenessRatio(1.); calc.setSolutionCompletenessRatio(1.);
double c = calc.getCosts(context,prevAct,nextAct,newAct,10); 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 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 old = 10 + 40 = 50
new = s:30,act1:40,act2:50,act3:70,act4:80,act5:90 --> w=10 => -10 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) { private StateManager getStateManager(VehicleRoutingProblem vrp, VehicleRoute route) {
StateManager stateManager = new StateManager(vrp); StateManager stateManager = new StateManager(vrp);
stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts()));
stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts()));
stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateVehicleDependentPracticalTimeWindows(stateManager,vrp.getTransportCosts()));
stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts()));
stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(),stateManager ));
stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList<Job>()); stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList<Job>());
return stateManager; return stateManager;
} }

130
jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateDepartureTimeTest.java
View file

@ -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());
}
}

119
jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateTimeSlackTest.java
View file

@ -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);
}
}

10
jsprit-core/src/test/java/jsprit/core/problem/vehicle/VehicleImplTest.java
View file

@ -221,15 +221,5 @@ public class VehicleImplTest {
assertFalse(v.getSkills().containsSkill("ScrewDriver")); 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());
}
} }

36
jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample.java
View file

@ -5,8 +5,7 @@ import jsprit.analysis.toolbox.Plotter;
import jsprit.core.algorithm.VehicleRoutingAlgorithm; import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.box.Jsprit; import jsprit.core.algorithm.box.Jsprit;
import jsprit.core.algorithm.state.StateManager; import jsprit.core.algorithm.state.StateManager;
import jsprit.core.algorithm.state.UpdateDepartureTime; import jsprit.core.algorithm.state.UpdateFutureWaitingTimes;
import jsprit.core.algorithm.state.UpdateTimeSlack;
import jsprit.core.analysis.SolutionAnalyser; import jsprit.core.analysis.SolutionAnalyser;
import jsprit.core.problem.Location; import jsprit.core.problem.Location;
import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
@ -38,28 +37,32 @@ public class VariableStartAndWaitingTimeExample {
public static void main(String[] args) { public static void main(String[] args) {
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(4.).setCostPerWaitingTime(2.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 type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(3.).setCostPerWaitingTime(2.0).build();
VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type2").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) VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(false)
.setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); .setStartLocation(Location.newInstance(0, 0))
VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type1).setReturnToDepot(true) // .setEarliestStart(0).setLatestArrival(400)
.setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); .build();
VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setType(type2).setReturnToDepot(true) VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setType(type1).setReturnToDepot(false)
.setHasVariableDepartureTime(true).setStartLocation(Location.newInstance(0, 0)).build(); .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(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
Random r = RandomNumberGeneration.newInstance(); Random r = RandomNumberGeneration.newInstance();
for(int i=0;i<40;i++){ 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))) // .setTimeWindow(TimeWindow.newInstance(r.nextInt(50),100+r.nextInt(150)))
.setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build(); .setLocation(Location.newInstance(1 - r.nextInt(5), 10 + r.nextInt(10))).build();
vrpBuilder.addJob(s); 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 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 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, 310)).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(v4).addVehicle(v2).addVehicle(v3); vrpBuilder.addJob(s1).addJob(s2).addJob(s3).addVehicle(v2).addVehicle(v3);
vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE);
final VehicleRoutingProblem vrp = vrpBuilder.build(); final VehicleRoutingProblem vrp = vrpBuilder.build();
@ -67,8 +70,7 @@ public class VariableStartAndWaitingTimeExample {
@Override @Override
public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) {
StateManager stateManager = new StateManager(vrp); StateManager stateManager = new StateManager(vrp);
stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts()));
stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts()));
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
return Jsprit.Builder.newInstance(vrp) return Jsprit.Builder.newInstance(vrp)

12
jsprit-examples/src/main/java/jsprit/examples/VariableStartAndWaitingTimeExample2.java
View file

@ -5,8 +5,7 @@ import jsprit.analysis.toolbox.Plotter;
import jsprit.core.algorithm.VehicleRoutingAlgorithm; import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.box.Jsprit; import jsprit.core.algorithm.box.Jsprit;
import jsprit.core.algorithm.state.StateManager; import jsprit.core.algorithm.state.StateManager;
import jsprit.core.algorithm.state.UpdateDepartureTime; import jsprit.core.algorithm.state.UpdateFutureWaitingTimes;
import jsprit.core.algorithm.state.UpdateTimeSlack;
import jsprit.core.problem.Location; import jsprit.core.problem.Location;
import jsprit.core.problem.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.constraint.ConstraintManager; import jsprit.core.problem.constraint.ConstraintManager;
@ -32,11 +31,11 @@ public class VariableStartAndWaitingTimeExample2 {
public static void main(String[] args) { 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(); // VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").setCostPerDistance(1.5).setCostPerWaitingTime(.0).build();
VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setType(type).setReturnToDepot(true) 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(); 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 s4 = Service.Builder.newInstance("s13").setLocation(Location.newInstance(0, 10)).build();
Service s2 = Service.Builder.newInstance("s10").setLocation(Location.newInstance(1, 12)).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 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.addJob(s1).addJob(s2).addJob(s3).addJob(s4).addJob(s5).addVehicle(v2);
vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE); vrpBuilder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE);
final VehicleRoutingProblem vrp = vrpBuilder.build(); final VehicleRoutingProblem vrp = vrpBuilder.build();
@ -54,8 +53,7 @@ public class VariableStartAndWaitingTimeExample2 {
@Override @Override
public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) { public VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp) {
StateManager stateManager = new StateManager(vrp); StateManager stateManager = new StateManager(vrp);
stateManager.addStateUpdater(new UpdateDepartureTime(vrp.getTransportCosts(), stateManager)); stateManager.addStateUpdater(new UpdateFutureWaitingTimes(stateManager,vrp.getTransportCosts()));
stateManager.addStateUpdater(new UpdateTimeSlack(stateManager,vrp.getTransportCosts()));
ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager); ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
return Jsprit.Builder.newInstance(vrp) return Jsprit.Builder.newInstance(vrp)