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

prepare for release v0.1.0

Browse source
This commit is contained in:
Stefan Schroeder 2013-11-22 16:54:15 +01:00
parent 77d38de461
commit a85b0fc395
304 changed files with 4035 additions and 64795 deletions
Download patch file Download diff file Expand all files Collapse all files

90
jsprit-analysis/src/main/java/analysis/SolutionPrinter.java
View file

@ -1,90 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package analysis;
import basics.VehicleRoutingProblemSolution;
import basics.route.DefaultVehicleRouteCostCalculator;
import basics.route.VehicleRoute;
/**
* Printer to print the details of a vehicle-routing-problem solution.
*
* @author stefan schroeder
*
*/
public class SolutionPrinter {
/**
* Enum to indicate verbose-level.
*
* <p> Print.CONCISE and Print.VERBOSE are available.
*
* @author stefan schroeder
*
*/
public enum Print {
CONCISE,VERBOSE
}
/**
* Prints costs and #vehicles to stdout (System.out.println).
*
* @param solution
*/
public static void print(VehicleRoutingProblemSolution solution){
System.out.println("[costs="+solution.getCost() + "]");
System.out.println("[#vehicles="+solution.getRoutes().size() + "]");
}
/**
* Prints the details of the solution according to a print-level, i.e. Print.CONCISE or PRINT.VERBOSE.
*
* <p>CONCISE prints total-costs and #vehicles.
* <p>VERBOSE prints the route-details additionally. If the DefaultVehicleRouteCostCalculator (which is the standard-calculator)
* is used in VehicleRoute, then route-costs are differentiated further between transport, activity, vehicle, driver and other-costs.
*
* @param solution
* @param level
*
* @deprecated is not going to work anymore
*/
@Deprecated
public static void print(VehicleRoutingProblemSolution solution, Print level){
if(level.equals(Print.CONCISE)){
print(solution);
}
else{
print(solution);
System.out.println("routes");
int routeCount = 1;
for(VehicleRoute route : solution.getRoutes()){
System.out.println("[route="+routeCount+"][departureTime="+route.getStart().getEndTime()+"[total=" + route.getCost() + "]");
if(route.getVehicleRouteCostCalculator() instanceof DefaultVehicleRouteCostCalculator){
DefaultVehicleRouteCostCalculator defaultCalc = (DefaultVehicleRouteCostCalculator) route.getVehicleRouteCostCalculator();
System.out.println("[transport=" + defaultCalc.getTpCosts() + "][activity=" + defaultCalc.getActCosts() +
"][vehicle=" + defaultCalc.getVehicleCosts() + "][driver=" + defaultCalc.getDriverCosts() + "][other=" + defaultCalc.getOther() + "]");
}
routeCount++;
}
}
}
}

19
jsprit-analysis/src/main/java/analysis/AlgorithmSearchProgressChartListener.java → jsprit-analysis/src/main/java/jsprit/analysis/toolbox/AlgorithmSearchProgressChartListener.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package analysis; package jsprit.analysis.toolbox;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
@ -22,24 +22,24 @@ import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.listener.AlgorithmEndsListener;
import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.algorithm.listener.IterationEndsListener;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.jfree.chart.ChartFactory; import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtilities; import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart; import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.NumberAxis; import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.NumberTickUnit;
import org.jfree.chart.plot.PlotOrientation; import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot; import org.jfree.chart.plot.XYPlot;
import org.jfree.data.Range; import org.jfree.data.Range;
import org.jfree.data.xy.XYSeries; import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection; import org.jfree.data.xy.XYSeriesCollection;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.algo.AlgorithmEndsListener;
import basics.algo.AlgorithmStartsListener;
import basics.algo.IterationEndsListener;
/** /**
@ -77,6 +77,9 @@ public class AlgorithmSearchProgressChartListener implements IterationEndsListen
public AlgorithmSearchProgressChartListener(String pngFileName) { public AlgorithmSearchProgressChartListener(String pngFileName) {
super(); super();
this.filename = pngFileName; this.filename = pngFileName;
if(!this.filename.endsWith("png")){
this.filename += ".png";
}
} }

23
jsprit-analysis/src/main/java/analysis/ConcurrentBenchmarker.java → jsprit-analysis/src/main/java/jsprit/analysis/toolbox/ConcurrentBenchmarker.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package analysis; package jsprit.analysis.toolbox;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -25,20 +25,21 @@ import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.Future; import java.util.concurrent.Future;
import jsprit.analysis.util.BenchmarkWriter;
import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.VehicleRoutingAlgorithmFactory;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms;
import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.Priority;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.util.BenchmarkInstance;
import jsprit.core.util.BenchmarkResult;
import jsprit.core.util.Solutions;
import org.apache.commons.math.stat.descriptive.DescriptiveStatistics; import org.apache.commons.math.stat.descriptive.DescriptiveStatistics;
import org.apache.log4j.Level; import org.apache.log4j.Level;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.BenchmarkInstance;
import util.BenchmarkResult;
import util.BenchmarkWriter;
import util.Solutions;
import algorithms.VehicleRoutingAlgorithms;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.algo.VehicleRoutingAlgorithmFactory;
import basics.algo.VehicleRoutingAlgorithmListeners.Priority;
public class ConcurrentBenchmarker { public class ConcurrentBenchmarker {

35
jsprit-analysis/src/main/java/analysis/Plotter.java → jsprit-analysis/src/main/java/jsprit/analysis/toolbox/Plotter.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package analysis; package jsprit.analysis.toolbox;
import java.awt.BasicStroke; import java.awt.BasicStroke;
import java.awt.Color; import java.awt.Color;
@ -25,6 +25,19 @@ import java.util.Collection;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.job.Delivery;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Pickup;
import jsprit.core.problem.job.Service;
import jsprit.core.problem.job.Shipment;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.util.Coordinate;
import jsprit.core.util.Locations;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.jfree.chart.ChartUtilities; import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart; import org.jfree.chart.JFreeChart;
@ -43,18 +56,6 @@ import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection; import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.ui.RectangleEdge; import org.jfree.ui.RectangleEdge;
import util.Coordinate;
import util.Locations;
import basics.Delivery;
import basics.Job;
import basics.Pickup;
import basics.Service;
import basics.Shipment;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.route.TourActivity;
import basics.route.Vehicle;
import basics.route.VehicleRoute;
public class Plotter { public class Plotter {
@ -80,8 +81,6 @@ public class Plotter {
private VehicleRoutingProblem vrp; private VehicleRoutingProblem vrp;
private VehicleRoutingProblemSolution solution;
private boolean plotSolutionAsWell = false; private boolean plotSolutionAsWell = false;
private boolean plotShipments = true; private boolean plotShipments = true;
@ -116,11 +115,13 @@ public class Plotter {
} }
public void plot(String pngFileName, String plotTitle){ public void plot(String pngFileName, String plotTitle){
String filename = pngFileName;
if(!pngFileName.endsWith(".png")) filename += ".png";
if(plotSolutionAsWell){ if(plotSolutionAsWell){
plotSolutionAsPNG(vrp, routes, pngFileName, plotTitle); plotSolutionAsPNG(vrp, routes, filename, plotTitle);
} }
else{ else{
plotVrpAsPNG(vrp, pngFileName, plotTitle); plotVrpAsPNG(vrp, filename, plotTitle);
} }
} }

48
jsprit-analysis/src/main/java/analysis/SolutionPlotter.java → jsprit-analysis/src/main/java/jsprit/analysis/toolbox/SolutionPlotter.java
View file

@ -14,11 +14,9 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package analysis; package jsprit.analysis.toolbox;
import java.awt.BasicStroke;
import java.awt.Color; import java.awt.Color;
import java.awt.geom.Ellipse2D;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.util.Collection; import java.util.Collection;
@ -27,31 +25,29 @@ import java.util.HashSet;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.job.Delivery;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Pickup;
import jsprit.core.problem.job.Service;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.util.Coordinate;
import jsprit.core.util.Locations;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.jfree.chart.ChartUtilities; import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart; import org.jfree.chart.JFreeChart;
import org.jfree.chart.annotations.XYShapeAnnotation;
import org.jfree.chart.axis.NumberAxis; import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.labels.XYItemLabelGenerator;
import org.jfree.chart.plot.XYPlot; import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYItemRenderer; import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer; import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.data.xy.XYDataItem; import org.jfree.data.xy.XYDataItem;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries; import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection; import org.jfree.data.xy.XYSeriesCollection;
import util.Coordinate;
import util.Locations;
import basics.Delivery;
import basics.Job;
import basics.Pickup;
import basics.Service;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.route.TourActivity;
import basics.route.Vehicle;
import basics.route.VehicleRoute;
/** /**
@ -82,7 +78,9 @@ public class SolutionPlotter {
* @see VehicleRoutingProblem, VehicleRoutingProblemSolution * @see VehicleRoutingProblem, VehicleRoutingProblemSolution
*/ */
public static void plotVrpAsPNG(VehicleRoutingProblem vrp, String pngFile, String title){ public static void plotVrpAsPNG(VehicleRoutingProblem vrp, String pngFile, String title){
log.info("plot routes to " + pngFile); String filename = pngFile;
if(!pngFile.endsWith(".png")) filename += ".png";
log.info("plot routes to " + filename);
XYSeriesCollection problem; XYSeriesCollection problem;
Map<XYDataItem,String> labels = new HashMap<XYDataItem, String>(); Map<XYDataItem,String> labels = new HashMap<XYDataItem, String>();
try { try {
@ -93,7 +91,7 @@ public class SolutionPlotter {
} }
XYPlot plot = createPlot(problem, labels); XYPlot plot = createPlot(problem, labels);
JFreeChart chart = new JFreeChart(title, plot); JFreeChart chart = new JFreeChart(title, plot);
save(chart,pngFile); save(chart,filename);
} }
/** /**
@ -106,7 +104,9 @@ public class SolutionPlotter {
* @see VehicleRoute * @see VehicleRoute
*/ */
public static void plotRoutesAsPNG(Collection<VehicleRoute> routes, Locations locations, String pngFile, String title) { public static void plotRoutesAsPNG(Collection<VehicleRoute> routes, Locations locations, String pngFile, String title) {
log.info("plot routes to " + pngFile); String filename = pngFile;
if(!pngFile.endsWith(".png")) filename += ".png";
log.info("plot routes to " + filename);
XYSeriesCollection problem; XYSeriesCollection problem;
Map<XYDataItem,String> labels = new HashMap<XYDataItem, String>(); Map<XYDataItem,String> labels = new HashMap<XYDataItem, String>();
try { try {
@ -118,7 +118,7 @@ public class SolutionPlotter {
XYSeriesCollection solutionColl = makeSolutionSeries(routes,locations); XYSeriesCollection solutionColl = makeSolutionSeries(routes,locations);
XYPlot plot = createPlot(problem, solutionColl, labels); XYPlot plot = createPlot(problem, solutionColl, labels);
JFreeChart chart = new JFreeChart(title, plot); JFreeChart chart = new JFreeChart(title, plot);
save(chart,pngFile); save(chart,filename);
} }
/** /**
@ -133,7 +133,9 @@ public class SolutionPlotter {
* @see VehicleRoutingProblem, VehicleRoutingProblemSolution * @see VehicleRoutingProblem, VehicleRoutingProblemSolution
*/ */
public static void plotSolutionAsPNG(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution, String pngFile, String title){ public static void plotSolutionAsPNG(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution, String pngFile, String title){
log.info("plot solution to " + pngFile); String filename = pngFile;
if(!pngFile.endsWith(".png")) filename += ".png";
log.info("plot solution to " + filename);
XYSeriesCollection problem; XYSeriesCollection problem;
XYSeriesCollection solutionColl; XYSeriesCollection solutionColl;
Map<XYDataItem,String> labels = new HashMap<XYDataItem, String>(); Map<XYDataItem,String> labels = new HashMap<XYDataItem, String>();
@ -146,7 +148,7 @@ public class SolutionPlotter {
} }
XYPlot plot = createPlot(problem, solutionColl, labels); XYPlot plot = createPlot(problem, solutionColl, labels);
JFreeChart chart = new JFreeChart(title, plot); JFreeChart chart = new JFreeChart(title, plot);
save(chart,pngFile); save(chart,filename);
} }

88
jsprit-analysis/src/main/java/jsprit/analysis/toolbox/SolutionPrinter.java Normal file
View file

@ -0,0 +1,88 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package jsprit.analysis.toolbox;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
/**
* Printer to print the details of a vehicle-routing-problem solution.
*
* @author stefan schroeder
*
*/
public class SolutionPrinter {
/**
* Enum to indicate verbose-level.
*
* <p> Print.CONCISE and Print.VERBOSE are available.
*
* @author stefan schroeder
*
*/
public enum Print {
CONCISE,VERBOSE
}
/**
* Prints costs and #vehicles to stdout (System.out.println).
*
* @param solution
*/
public static void print(VehicleRoutingProblemSolution solution){
System.out.println("[costs="+solution.getCost() + "]");
System.out.println("[#vehicles="+solution.getRoutes().size() + "]");
}
// /**
// * Prints the details of the solution according to a print-level, i.e. Print.CONCISE or PRINT.VERBOSE.
// *
// * <p>CONCISE prints total-costs and #vehicles.
// * <p>VERBOSE prints the route-details additionally. If the DefaultVehicleRouteCostCalculator (which is the standard-calculator)
// * is used in VehicleRoute, then route-costs are differentiated further between transport, activity, vehicle, driver and other-costs.
// *
// * @param solution
// * @param level
// *
// * @deprecated is not going to work anymore
// */
// @Deprecated
// public static void print(VehicleRoutingProblemSolution solution, Print level){
// if(level.equals(Print.CONCISE)){
// print(solution);
// }
// else{
// print(solution);
// System.out.println("routes");
// int routeCount = 1;
// for(VehicleRoute route : solution.getRoutes()){
// System.out.println("[route="+routeCount+"][departureTime="+route.getStart().getEndTime()+"[total=" + route.getCost() + "]");
// if(route.getVehicleRouteCostCalculator() instanceof DefaultVehicleRouteCostCalculator){
// DefaultVehicleRouteCostCalculator defaultCalc = (DefaultVehicleRouteCostCalculator) route.getVehicleRouteCostCalculator();
// System.out.println("[transport=" + defaultCalc.getTpCosts() + "][activity=" + defaultCalc.getActCosts() +
// "][vehicle=" + defaultCalc.getVehicleCosts() + "][driver=" + defaultCalc.getDriverCosts() + "][other=" + defaultCalc.getOther() + "]");
// }
// routeCount++;
// }
// }
//
//
// }
}

13
jsprit-analysis/src/main/java/analysis/StopWatch.java → jsprit-analysis/src/main/java/jsprit/analysis/toolbox/StopWatch.java
View file

@ -14,17 +14,18 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package analysis; package jsprit.analysis.toolbox;
import java.util.Collection; import java.util.Collection;
import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.listener.AlgorithmEndsListener;
import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.algo.AlgorithmEndsListener;
import basics.algo.AlgorithmStartsListener;
public class StopWatch implements AlgorithmStartsListener, AlgorithmEndsListener{ public class StopWatch implements AlgorithmStartsListener, AlgorithmEndsListener{

4
jsprit-analysis/src/main/java/util/BenchmarkWriter.java → jsprit-analysis/src/main/java/jsprit/analysis/util/BenchmarkWriter.java
View file

@ -14,10 +14,12 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package util; package jsprit.analysis.util;
import java.util.Collection; import java.util.Collection;
import jsprit.core.util.BenchmarkResult;
public interface BenchmarkWriter { public interface BenchmarkWriter {
public void write(Collection<BenchmarkResult> results); public void write(Collection<BenchmarkResult> results);
} }

4
jsprit-analysis/src/main/java/util/HtmlBenchmarkTableWriter.java → jsprit-analysis/src/main/java/jsprit/analysis/util/HtmlBenchmarkTableWriter.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package util; package jsprit.analysis.util;
import java.io.BufferedWriter; import java.io.BufferedWriter;
import java.io.File; import java.io.File;
@ -22,6 +22,8 @@ import java.io.FileWriter;
import java.io.IOException; import java.io.IOException;
import java.util.Collection; import java.util.Collection;
import jsprit.core.util.BenchmarkResult;
import org.jfree.chart.renderer.xy.DeviationRenderer; import org.jfree.chart.renderer.xy.DeviationRenderer;
public class HtmlBenchmarkTableWriter implements BenchmarkWriter{ public class HtmlBenchmarkTableWriter implements BenchmarkWriter{

19
jsprit-core/src/main/java/algorithms/BestInsertionStrategyFactory.java
View file

@ -1,19 +0,0 @@
package algorithms;
import basics.VehicleRoutingProblem;
public class BestInsertionStrategyFactory implements InsertionStrategyFactory{
private JobInsertionCostsCalculator jobInsertionCalculator;
public BestInsertionStrategyFactory(JobInsertionCostsCalculator jobInsertionCalculator) {
super();
this.jobInsertionCalculator = jobInsertionCalculator;
}
@Override
public InsertionStrategy createStrategy(VehicleRoutingProblem vrp) {
return new BestInsertion(jobInsertionCalculator);
}
}

15
jsprit-core/src/main/java/algorithms/ConcurrentVehicleRoutingAlgorithmWrapper.java
View file

@ -1,15 +0,0 @@
package algorithms;
public class ConcurrentVehicleRoutingAlgorithmWrapper {
private int nuOfThreads;
public ConcurrentVehicleRoutingAlgorithmWrapper(int nuOfThreads) {
super();
this.nuOfThreads = nuOfThreads;
}
}

53
jsprit-core/src/main/java/algorithms/FindCheaperVehicle.java
View file

@ -1,53 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package algorithms;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import basics.Job;
import basics.algo.InsertionStartsListener;
import basics.route.VehicleRoute;
class FindCheaperVehicle implements InsertionStartsListener{
FindCheaperVehicleAlgo findCheaperVehicle;
public FindCheaperVehicle(FindCheaperVehicleAlgo findCheaperVehicle) {
super();
this.findCheaperVehicle = findCheaperVehicle;
}
@Override
public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
List<VehicleRoute> newRoutes = new ArrayList<VehicleRoute>();
for(VehicleRoute route : vehicleRoutes){
if(route.isEmpty()) continue;
VehicleRoute cheaperRoute = findCheaperVehicle.runAndGetVehicleRoute(route);
newRoutes.add(cheaperRoute);
}
vehicleRoutes.clear();
vehicleRoutes.addAll(newRoutes);
}
@Override
public String toString() {
return "[name=findCheaperVehicle]";
}
}

110
jsprit-core/src/main/java/algorithms/FindCheaperVehicleAlgo.java
View file

@ -1,110 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package algorithms;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import basics.route.TourActivities;
import basics.route.TourActivity;
import basics.route.Vehicle;
import basics.route.VehicleFleetManager;
import basics.route.VehicleImpl.NoVehicle;
import basics.route.VehicleRoute;
final class FindCheaperVehicleAlgo {
private static Logger log = Logger.getLogger(FindCheaperVehicleAlgo.class);
private VehicleFleetManager fleetManager;
private VehicleRouteUpdater tourStateCalculator;
private AuxilliaryCostCalculator auxilliaryCostCalculator;
private double weightFixCosts = 1.0;
private StateGetter states;
public void setWeightFixCosts(double weightFixCosts) {
this.weightFixCosts = weightFixCosts;
}
public void setStates(StateGetter states) {
this.states = states;
}
public FindCheaperVehicleAlgo(VehicleFleetManager fleetManager, VehicleRouteUpdater tourStateCalculator, AuxilliaryCostCalculator auxilliaryCostCalculator) {
super();
this.fleetManager = fleetManager;
this.tourStateCalculator = tourStateCalculator;
this.auxilliaryCostCalculator = auxilliaryCostCalculator;
}
public VehicleRoute runAndGetVehicleRoute(VehicleRoute vehicleRoute) {
if(vehicleRoute.getVehicle() instanceof NoVehicle){
return vehicleRoute;
}
if(vehicleRoute.getTourActivities() == null || vehicleRoute.getVehicle() == null){
return vehicleRoute;
}
// Collection<TypeKey> availableVehicleTypes = fleetManager.getAvailableVehicleTypes(new TypeKey(vehicleRoute.getVehicle().getType(),vehicleRoute.getVehicle().getLocationId()));
double bestSaving = 0.0;
Vehicle bestVehicle = null;
List<TourActivity> path = new ArrayList<TourActivity>();
path.add(vehicleRoute.getStart());
path.addAll(vehicleRoute.getTourActivities().getActivities());
path.add(vehicleRoute.getEnd());
for(Vehicle vehicle : fleetManager.getAvailableVehicles(vehicleRoute.getVehicle().getType().getTypeId(), vehicleRoute.getVehicle().getLocationId())){
// Vehicle vehicle = fleetManager.getEmptyVehicle(vehicleType);
if(vehicle.getType().getTypeId().equals(vehicleRoute.getVehicle().getType().getTypeId())){
continue;
}
if(states.getRouteState(vehicleRoute,StateFactory.LOAD).toDouble() <= vehicle.getCapacity()){
double fixCostSaving = vehicleRoute.getVehicle().getType().getVehicleCostParams().fix - vehicle.getType().getVehicleCostParams().fix;
double departureTime = vehicleRoute.getStart().getEndTime();
double newCost = auxilliaryCostCalculator.costOfPath(path, departureTime, vehicleRoute.getDriver(), vehicle);
double varCostSaving = states.getRouteState(vehicleRoute, StateFactory.COSTS).toDouble() - newCost;
double totalCostSaving = varCostSaving + weightFixCosts*fixCostSaving;
if(totalCostSaving > bestSaving){
bestSaving = totalCostSaving;
bestVehicle = vehicle;
}
}
}
if(bestVehicle != null){
try{
fleetManager.unlock(vehicleRoute.getVehicle());
fleetManager.lock(bestVehicle);
}
catch(IllegalStateException e){
throw new IllegalStateException(e);
}
TourActivities newTour = TourActivities.copyOf(vehicleRoute.getTourActivities());
tourStateCalculator.iterate(vehicleRoute);
return VehicleRoute.newInstance(newTour,vehicleRoute.getDriver(),bestVehicle);
}
return vehicleRoute;
}
}

220
jsprit-core/src/main/java/algorithms/Gendreau.java
View file

@ -1,220 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package algorithms;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
import org.apache.log4j.Logger;
import util.RandomNumberGeneration;
import basics.Job;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.algo.InsertionListener;
import basics.algo.RuinListener;
import basics.algo.SearchStrategyModule;
import basics.algo.SearchStrategyModuleListener;
import basics.route.TourActivity;
import basics.route.TourActivity.JobActivity;
import basics.route.VehicleFleetManager;
import basics.route.VehicleRoute;
public final class Gendreau implements SearchStrategyModule{
private final static Logger log = Logger.getLogger(Gendreau.class);
private final static String NAME = "gendreauPostOpt";
private final RuinStrategy ruin;
private final VehicleRoutingProblem vrp;
private final InsertionStrategy insertionStrategy;
private VehicleFleetManager fleetManager;
private Random random = RandomNumberGeneration.getRandom();
private int nOfIterations = 10;
private double shareOfJobsToRuin = 0.15;
public void setShareOfJobsToRuin(double shareOfJobsToRuin) {
this.shareOfJobsToRuin = shareOfJobsToRuin;
}
public Gendreau(VehicleRoutingProblem vrp, RuinStrategy ruin, InsertionStrategy insertionStrategy, VehicleFleetManager vehicleFleetManager) {
super();
InsertionListeners insertionListeners = new InsertionListeners();
insertionListeners.addAllListeners(insertionStrategy.getListeners());
new Inserter(insertionListeners);
this.ruin = ruin;
this.vrp = vrp;
this.insertionStrategy = insertionStrategy;
this.fleetManager = vehicleFleetManager;
}
@Override
public String toString() {
return "[name=gendreau][iterations="+nOfIterations+"][share2ruin="+shareOfJobsToRuin+"]";
}
public void setRandom(Random random) {
this.random = random;
}
public void setNuOfIterations(int nOfIterations) {
this.nOfIterations = nOfIterations;
}
// public void setFleetManager(VehicleFleetManager vehicleFleetManager) {
// this.fleetManager = vehicleFleetManager;
//
// }
@Override
public VehicleRoutingProblemSolution runAndGetSolution(VehicleRoutingProblemSolution vrpSolution) {
// log.info("run gendreau postopt");
VehicleRoutingProblemSolution bestSolution = vrpSolution;
int itersWithoutImprovement = 0;
for(int i=0;i<nOfIterations;i++){
List<VehicleRoute> copiedRoutes = copyRoutes(bestSolution.getRoutes());
iniFleet(copiedRoutes);
VehicleRoute route2split = pickRouteThatHasAtLeastTwoJobs(copiedRoutes);
if(route2split == null) continue;
List<Job> jobsInRoute = getJobs(route2split);
Set<Job> unassignedJobs = new HashSet<Job>();
unassignedJobs.addAll(jobsInRoute);
copiedRoutes.remove(route2split);
Collections.shuffle(jobsInRoute,random);
Job targetJob = jobsInRoute.get(0);
int nOfJobs2BeRemovedAdditionally = (int) (shareOfJobsToRuin*(double)vrp.getJobs().size());
Collection<Job> unassignedJobsList = ruin.ruin(copiedRoutes, targetJob, nOfJobs2BeRemovedAdditionally);
unassignedJobs.addAll(unassignedJobsList);
VehicleRoute emptyRoute1 = VehicleRoute.emptyRoute();
copiedRoutes.add(emptyRoute1);
insertionStrategy.insertJobs(Arrays.asList(emptyRoute1), Arrays.asList(targetJob));
unassignedJobs.remove(targetJob);
VehicleRoute emptyRoute2 = VehicleRoute.emptyRoute();
copiedRoutes.add(emptyRoute2);
Job job2 = jobsInRoute.get(1);
insertionStrategy.insertJobs(Arrays.asList(emptyRoute2), Arrays.asList(job2));
unassignedJobs.remove(job2);
insertionStrategy.insertJobs(copiedRoutes, unassignedJobs);
double cost = getCost(copiedRoutes);
if(cost < bestSolution.getCost()){
// log.info("BING - new: " + cost + " old: " + bestSolution.getCost());
bestSolution = new VehicleRoutingProblemSolution(copiedRoutes, cost);
itersWithoutImprovement=0;
}
else{
itersWithoutImprovement++;
if(itersWithoutImprovement > 200){
// log.info("BREAK i="+i);
break;
}
}
}
return bestSolution;
}
private List<VehicleRoute> copyRoutes(Collection<VehicleRoute> routes) {
List<VehicleRoute> routeList = new ArrayList<VehicleRoute>();
for(VehicleRoute r : routes){
routeList.add(VehicleRoute.copyOf(r));
}
return routeList;
}
private void iniFleet(Collection<VehicleRoute> routes) {
fleetManager.unlockAll();
for(VehicleRoute route : routes){
if(!route.isEmpty()){
fleetManager.lock(route.getVehicle());
}
}
}
private double getCost(Collection<VehicleRoute> routes) {
double c = 0.0;
for(VehicleRoute r : routes){
c+=r.getCost();
}
return c;
}
private List<Job> getJobs(VehicleRoute route2split) {
Set<Job> jobs = new HashSet<Job>();
for(TourActivity act : route2split.getTourActivities().getActivities()){
if(act instanceof JobActivity){
jobs.add(((JobActivity) act).getJob());
}
}
return new ArrayList<Job>(jobs);
}
private VehicleRoute pickRouteThatHasAtLeastTwoJobs(Collection<VehicleRoute> routeList) {
List<VehicleRoute> routes = new ArrayList<VehicleRoute>();
for(VehicleRoute r : routeList){
if(getJobs(r).size() > 1){
routes.add(r);
}
}
if(routes.isEmpty()) return null;
Collections.shuffle(routes,random);
return routes.get(0);
}
@Override
public String getName() {
return NAME;
}
@Override
public void addModuleListener(SearchStrategyModuleListener moduleListener) {
if(moduleListener instanceof InsertionListener){
InsertionListener iListener = (InsertionListener) moduleListener;
if(!insertionStrategy.getListeners().contains(iListener)){
insertionStrategy.addListener(iListener);
}
}
if(moduleListener instanceof RuinListener){
RuinListener rListener = (RuinListener) moduleListener;
if(!ruin.getListeners().contains(rListener)){
ruin.addListener(rListener);
}
}
}
}

15
jsprit-core/src/main/java/algorithms/HardActivityStateLevelConstraint.java
View file

@ -1,15 +0,0 @@
package algorithms;
import basics.route.TourActivity;
public interface HardActivityStateLevelConstraint {
static enum ConstraintsStatus {
NOT_FULFILLED_BREAK, NOT_FULFILLED, FULFILLED;
}
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime);
}

8
jsprit-core/src/main/java/algorithms/HardRouteStateLevelConstraint.java
View file

@ -1,8 +0,0 @@
package algorithms;
public interface HardRouteStateLevelConstraint {
public boolean fulfilled(InsertionContext insertionContext);
}

57
jsprit-core/src/main/java/algorithms/JobDistanceBeeline.java
View file

@ -1,57 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package algorithms;
import util.CrowFlyCosts;
import util.Locations;
import basics.Job;
import basics.Service;
class JobDistanceBeeline implements JobDistance {
private Locations locations;
public JobDistanceBeeline(Locations locations) {
super();
this.locations = locations;
}
@Override
public double getDistance(Job i, Job j) {
double avgCost = 0.0;
if (i instanceof Service && j instanceof Service) {
if (i.equals(j)) {
avgCost = 0.0;
} else {
Service s_i = (Service) i;
Service s_j = (Service) j;
avgCost = calcDist(s_i.getLocationId(), s_j.getLocationId());
}
} else {
throw new UnsupportedOperationException(
"currently, this class just works with shipments and services.");
}
return avgCost;
}
private double calcDist(String from, String to) {
return new CrowFlyCosts(locations).getTransportCost(from, to, 0.0,null, null);
}
}

59
jsprit-core/src/main/java/algorithms/ScoredJob.java
View file

@ -1,59 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package algorithms;
import basics.Job;
import basics.route.VehicleRoute;
class ScoredJob {
private final Job job;
private final double score;
private final InsertionData insertionData;
private final VehicleRoute route;
public ScoredJob(final Job job, final double score, final InsertionData insertionData, final VehicleRoute route) {
super();
this.job = job;
this.score = score;
this.insertionData = insertionData;
this.route = route;
}
public InsertionData getInsertionData() {
return insertionData;
}
public VehicleRoute getRoute() {
return route;
}
public Job getJob() {
return job;
}
public double getScore() {
return score;
}
}

16
jsprit-core/src/main/java/algorithms/ShipmentPickupsFirstConstraint.java
View file

@ -1,16 +0,0 @@
package algorithms;
import basics.route.DeliverShipment;
import basics.route.PickupShipment;
import basics.route.TourActivity;
public class ShipmentPickupsFirstConstraint implements HardActivityStateLevelConstraint {
@Override
public ConstraintsStatus fulfilled(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) {
if(newAct instanceof DeliverShipment && nextAct instanceof PickupShipment){ return ConstraintsStatus.NOT_FULFILLED; }
if(newAct instanceof PickupShipment && prevAct instanceof DeliverShipment){ return ConstraintsStatus.NOT_FULFILLED_BREAK; }
return ConstraintsStatus.FULFILLED;
}
}

5
jsprit-core/src/main/java/algorithms/StateUpdater.java
View file

@ -1,5 +0,0 @@
package algorithms;
public interface StateUpdater {
}

37
jsprit-core/src/main/java/algorithms/UpdateEarliestStartTime.java
View file

@ -1,37 +0,0 @@
package algorithms;
import util.ActivityTimeTracker;
import algorithms.StateManager.StateImpl;
import basics.costs.VehicleRoutingTransportCosts;
import basics.route.ActivityVisitor;
import basics.route.TourActivity;
import basics.route.VehicleRoute;
class UpdateEarliestStartTime implements ActivityVisitor,StateUpdater{
private StateManager states;
private ActivityTimeTracker timeTracker;
public UpdateEarliestStartTime(StateManager states, VehicleRoutingTransportCosts transportCosts) {
super();
this.states = states;
timeTracker = new ActivityTimeTracker(transportCosts);
}
@Override
public void begin(VehicleRoute route) {
timeTracker.begin(route);
}
@Override
public void visit(TourActivity activity) {
timeTracker.visit(activity);
states.putActivityState(activity, StateFactory.EARLIEST_OPERATION_START_TIME, new StateImpl(Math.max(timeTracker.getActArrTime(), activity.getTheoreticalEarliestOperationStartTime())));
}
@Override
public void finish() {}
}

33
jsprit-core/src/main/java/algorithms/VehicleRouteUpdater.java
View file

@ -1,33 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package algorithms;
import basics.route.VehicleRoute;
/**
* Updater that updates a vehicleRoute, e.g. the total costs or the time-windows.
*
* @author stefan schroeder
*
*/
interface VehicleRouteUpdater {
public void iterate(VehicleRoute vehicleRoute);
}

41
jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithmFactoryImpl.java
View file

@ -1,41 +0,0 @@
package algorithms;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.algo.SearchStrategyManager;
import basics.algo.VehicleRoutingAlgorithmFactory;
import basics.route.VehicleFleetManager;
public class VehicleRoutingAlgorithmFactoryImpl implements VehicleRoutingAlgorithmFactory{
private SearchStrategyManager searchStrategyManager;
private StateManager stateManager;
private VehicleFleetManager fleetManager;
public VehicleRoutingAlgorithmFactoryImpl(SearchStrategyManager searchStrategyManager,
StateManager stateManager, VehicleFleetManager fleetManager) {
super();
this.searchStrategyManager = searchStrategyManager;
this.stateManager = stateManager;
this.fleetManager = fleetManager;
}
@Override
public VehicleRoutingAlgorithm createAlgorithm(VehicleRoutingProblem vrp) {
this.stateManager.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), this.stateManager));
//<<<<<<< HEAD
// this.stateManager.addActivityVisitor(new UpdateMaxLoad(this.stateManager));
this.stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts()));
//=======
//// this.stateManager.addActivityVisitor(new UpdateMaxLoad_(this.stateManager));
//>>>>>>> refs/heads/pickupAndDelivery
VehicleRoutingAlgorithm algorithm = new VehicleRoutingAlgorithm(vrp, searchStrategyManager);
algorithm.getAlgorithmListeners().addListener(stateManager);
algorithm.getSearchStrategyManager().addSearchStrategyModuleListener(stateManager);
algorithm.getSearchStrategyManager().addSearchStrategyModuleListener(new RemoveEmptyVehicles(fleetManager));
return algorithm;
}
}

42
jsprit-core/src/main/java/basics/algo/InsertionListeners.java
View file

@ -1,42 +0,0 @@
package basics.algo;
import java.util.ArrayList;
import java.util.Collection;
import basics.Job;
import basics.route.VehicleRoute;
public class InsertionListeners {
private Collection<InsertionStartsListener> startListeners = new ArrayList<InsertionStartsListener>();
private Collection<JobInsertedListener> jobInsertedListeners = new ArrayList<JobInsertedListener>();
private Collection<InsertionEndsListener> endListeners = new ArrayList<InsertionEndsListener>();
public void addListener(InsertionListener insertionListener){
if(insertionListener instanceof InsertionStartsListener) startListeners.add((InsertionStartsListener) insertionListener);
if(insertionListener instanceof JobInsertedListener) jobInsertedListeners.add((JobInsertedListener) insertionListener);
if(insertionListener instanceof InsertionEndsListener) endListeners.add((InsertionEndsListener) insertionListener);
// else throw new IllegalStateException("cannot add this type of insertionListener");
}
public void removeListener(InsertionListener insertionListener){
if(insertionListener instanceof InsertionStartsListener) startListeners.remove((InsertionStartsListener) insertionListener);
if(insertionListener instanceof JobInsertedListener) jobInsertedListeners.remove((JobInsertedListener) insertionListener);
if(insertionListener instanceof InsertionEndsListener) endListeners.remove((InsertionEndsListener) insertionListener);
// else throw new IllegalStateException("cannot remove this type of insertionListener");
}
public void insertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs){
for(InsertionStartsListener l : startListeners) l.informInsertionStarts(vehicleRoutes, unassignedJobs);
}
public void jobInserted(Job job2insert, VehicleRoute inRoute, double additionalCosts, double additionalTime){
for(JobInsertedListener l : jobInsertedListeners) l.informJobInserted(job2insert, inRoute, additionalCosts, additionalTime);
}
public void insertionEnds(Collection<VehicleRoute> vehicleRoutes){
for(InsertionEndsListener l : endListeners){ l.informInsertionEnds(vehicleRoutes); }
}
}

42
jsprit-core/src/main/java/basics/costs/DefaultVehicleRoutingActivityCosts.java
View file

@ -1,42 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package basics.costs;
import basics.route.Driver;
import basics.route.TourActivity;
import basics.route.Vehicle;
/**
* DefaultActivityCosts = 0.0, i.e. activities do not induce costs at all.
*
* @author schroeder
*
*/
public class DefaultVehicleRoutingActivityCosts implements VehicleRoutingActivityCosts{
@Override
public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) {
return 0;
}
@Override
public String toString() {
return "[name=defaultActivityCosts]";
}
}

128
jsprit-core/src/main/java/basics/route/DefaultVehicleRouteCostCalculator.java
View file

@ -1,128 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package basics.route;
public class DefaultVehicleRouteCostCalculator implements VehicleRouteCostCalculator {
private double tpCosts = 0.0;
private double actCosts = 0.0;
private double vehicleCosts = 0.0;
private double driverCosts = 0.0;
private double other = 0.0;
public DefaultVehicleRouteCostCalculator(){}
private DefaultVehicleRouteCostCalculator(DefaultVehicleRouteCostCalculator costCalc){
this.tpCosts=costCalc.getTpCosts();
this.actCosts = costCalc.getActCosts();
this.driverCosts = costCalc.getDriverCosts();
this.other = costCalc.getOther();
this.vehicleCosts = costCalc.getVehicleCosts();
}
public void addTransportCost(double tpCost) {
this.tpCosts+=tpCost;
}
public void addActivityCost(double actCost){
this.actCosts+=actCost;
}
public void price(Vehicle vehicle){
if(vehicle != null){
VehicleType type = vehicle.getType();
if(type != null){
this.vehicleCosts = type.getVehicleCostParams().fix;
}
}
}
public void price(Driver driver){
}
@Override
public void finish() {
// TODO Auto-generated method stub
}
@Override
public void reset() {
tpCosts = 0.0;
actCosts = 0.0;
vehicleCosts = 0.0;
driverCosts = 0.0;
other = 0.0;
}
@Override
public void addOtherCost(double cost) {
this.other = cost;
}
@Override
public double getCosts() {
return tpCosts + actCosts + vehicleCosts + driverCosts + other;
}
/**
* @return the tpCosts
*/
public double getTpCosts() {
return tpCosts;
}
/**
* @return the actCosts
*/
public double getActCosts() {
return actCosts;
}
/**
* @return the vehicleCosts
*/
public double getVehicleCosts() {
return vehicleCosts;
}
/**
* @return the driverCosts
*/
public double getDriverCosts() {
return driverCosts;
}
/**
* @return the other
*/
public double getOther() {
return other;
}
@Override
public VehicleRouteCostCalculator duplicate() {
return new DefaultVehicleRouteCostCalculator(this);
}
}

209
jsprit-core/src/main/java/basics/route/VehicleRoute.java
View file

@ -1,209 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package basics.route;
import basics.route.VehicleImpl.NoVehicle;
public class VehicleRoute {
public static VehicleRoute copyOf(VehicleRoute route) {
return new VehicleRoute(route);
}
public static VehicleRoute newInstance(TourActivities tour, Driver driver, Vehicle vehicle) {
return new VehicleRoute(tour,driver,vehicle);
}
public static VehicleRoute emptyRoute() {
return new VehicleRoute(TourActivities.emptyTour(), DriverImpl.noDriver(), VehicleImpl.noVehicle());
}
public static class Builder {
public static Builder newInstance(Start start, End end){
return new Builder(start,end);
}
private Start start;
private End end;
private Vehicle vehicle = VehicleImpl.noVehicle();
private Driver driver = DriverImpl.noDriver();
private TourActivities tour;
private Builder(Start start, End end) {
super();
this.start = start;
this.end = end;
this.tour = TourActivities.emptyTour();
}
public Builder setVehicle(Vehicle vehicle){
this.vehicle = vehicle;
return this;
}
public Builder setDriver(Driver driver){
this.driver = driver;
return this;
}
public Builder addActivity(TourActivity act){
if(act instanceof Start || act instanceof End){
throw new IllegalStateException("tourActivity should be of type Delivery or Pickup, but is of type " + act.getName());
}
tour.addActivity(act);
return this;
}
public VehicleRoute build(){
return new VehicleRoute(this);
}
}
private TourActivities tourActivities;
private Vehicle vehicle;
private Driver driver;
private Start start;
private End end;
@Deprecated
private VehicleRouteCostCalculator costCalculator = new DefaultVehicleRouteCostCalculator();
@Deprecated
public VehicleRouteCostCalculator getVehicleRouteCostCalculator(){
return costCalculator;
}
private VehicleRoute(VehicleRoute route){
this.start = Start.copyOf(route.getStart());
this.end = End.copyOf(route.getEnd());
this.tourActivities = TourActivities.copyOf(route.getTourActivities());
this.vehicle = route.getVehicle();
this.driver = route.getDriver();
this.costCalculator = route.getVehicleRouteCostCalculator().duplicate();
}
private VehicleRoute(TourActivities tour, Driver driver, Vehicle vehicle) {
super();
verify(tour, driver, vehicle);
this.tourActivities = tour;
this.vehicle = vehicle;
this.driver = driver;
setStartAndEnd(vehicle, vehicle.getEarliestDeparture());
}
private VehicleRoute(Builder builder){
this.tourActivities = builder.tour;
this.vehicle = builder.vehicle;
this.driver = builder.driver;
this.start = builder.start;
this.end = builder.end;
}
private void verify(TourActivities tour, Driver driver, Vehicle vehicle) {
if(tour == null || driver == null || vehicle == null) throw new IllegalStateException("null is not allowed for tour, driver or vehicle. use emptyRoute. use Tour.emptyTour, DriverImpl.noDriver() and VehicleImpl.noVehicle() instead." +
"\n\tor make it easier and use VehicleRoute.emptyRoute()");
if(!tour.isEmpty() && vehicle instanceof NoVehicle){
throw new IllegalStateException("if tour is not empty. there must be a vehicle for this tour, but there is no vehicle.");
}
}
public TourActivities getTourActivities() {
return tourActivities;
}
public Vehicle getVehicle() {
return vehicle;
}
public Driver getDriver() {
return driver;
}
public void setVehicle(Vehicle vehicle, double vehicleDepTime){
this.vehicle = vehicle;
setStartAndEnd(vehicle, vehicleDepTime);
}
public void setDepartureTime(double vehicleDepTime){
if(start == null) throw new IllegalStateException("cannot set departureTime without having a vehicle on this route. use setVehicle(vehicle,departureTime) instead.");
start.setEndTime(vehicleDepTime);
}
public double getDepartureTime(){
if(start == null) throw new IllegalStateException("cannot get departureTime without having a vehicle on this route. use setVehicle(vehicle,departureTime) instead.");
return start.getEndTime();
}
private void setStartAndEnd(Vehicle vehicle, double vehicleDepTime) {
if(!(vehicle instanceof NoVehicle)){
if(start == null && end == null){
start = Start.newInstance(vehicle.getLocationId(), vehicle.getEarliestDeparture(), vehicle.getLatestArrival());
end = End.newInstance(vehicle.getLocationId(), vehicle.getEarliestDeparture(), vehicle.getLatestArrival());
}
start.setEndTime(vehicleDepTime);
start.setTheoreticalEarliestOperationStartTime(vehicle.getEarliestDeparture());
start.setTheoreticalLatestOperationStartTime(vehicle.getLatestArrival());
start.setLocationId(vehicle.getLocationId());
end.setLocationId(vehicle.getLocationId());
end.setTheoreticalEarliestOperationStartTime(vehicle.getEarliestDeparture());
end.setTheoreticalLatestOperationStartTime(vehicle.getLatestArrival());
}
}
public boolean isEmpty() {
return tourActivities.isEmpty();
}
public Start getStart() {
return start;
}
public End getEnd() {
return end;
}
@Override
public String toString() {
return "[start="+start+"][end=" + end + "][departureTime=" + start.getEndTime() + "][vehicle=" + vehicle + "][driver=" + driver + "][nuOfActs="+tourActivities.getActivities().size()+"]";
}
@Deprecated
public void setVehicleRouteCostCalculator(VehicleRouteCostCalculator costAccumulator){
this.costCalculator = costAccumulator;
}
@Deprecated
public double getCost() {
if(tourActivities.isEmpty()){
return 0.0;
}
return costCalculator.getCosts();
}
}

151
jsprit-core/src/main/java/basics/route/VehicleRouteBuilder.java
View file

@ -1,151 +0,0 @@
package basics.route;
import java.util.HashSet;
import java.util.Set;
import basics.Service;
import basics.Shipment;
/**
* Builds a {@link VehicleRoute}.
*
* @author schroeder
*
*/
public class VehicleRouteBuilder {
private Vehicle vehicle;
private Driver driver;
private Start start;
private TourActivities tourActivities = new TourActivities();
private TourActivityFactory serviceActivityFactory = new DefaultTourActivityFactory();
private TourShipmentActivityFactory shipmentActivityFactory = new DefaultShipmentActivityFactory();
private Set<Shipment> openShipments = new HashSet<Shipment>();
public void setServiceActivityFactory(TourActivityFactory serviceActivityFactory) {
this.serviceActivityFactory = serviceActivityFactory;
}
public void setShipmentActivityFactory(TourShipmentActivityFactory shipmentActivityFactory) {
this.shipmentActivityFactory = shipmentActivityFactory;
}
/**
* Constructs the route-builder.
* @param vehicle
* @param driver
*/
public VehicleRouteBuilder(Vehicle vehicle, Driver driver) {
super();
this.vehicle = vehicle;
this.driver = driver;
start = Start.newInstance(vehicle.getLocationId(), vehicle.getEarliestDeparture(), vehicle.getLatestArrival());
start.setEndTime(vehicle.getEarliestDeparture());
End.newInstance(vehicle.getLocationId(), vehicle.getEarliestDeparture(), vehicle.getLatestArrival());
}
/**
* Sets the departure-time of the route.
*
* @param departureTime
* @return
*/
public VehicleRouteBuilder setDepartureTime(double departureTime){
start.setEndTime(departureTime);
return this;
}
public VehicleRouteBuilder addService(Service service){
addService(service,0.0,0.0);
return this;
}
public VehicleRouteBuilder addService(Service service, double arrTime, double endTime){
TourActivity act = serviceActivityFactory.createActivity(service);
act.setArrTime(arrTime);
act.setEndTime(endTime);
tourActivities.addActivity(act);
return this;
}
/**
* Adds a the pickup of the specified shipment.
*
* @param shipment
* @throws IllegalStateException if method has already been called with the specified shipment.
* @return
*/
public VehicleRouteBuilder addPickup(Shipment shipment){
addPickup(shipment,0.0,0.0);
return this;
}
/**
* Adds a the pickup of the specified shipment at specified arrival and end-time.
*
* @param shipment
* @throws IllegalStateException if method has already been called with the specified shipment.
* @return
*/
public VehicleRouteBuilder addPickup(Shipment shipment, double arrTime, double endTime){
if(openShipments.contains(shipment)) throw new IllegalStateException("shipment has already been added. cannot add it twice.");
TourActivity act = shipmentActivityFactory.createPickup(shipment);
act.setArrTime(arrTime);
act.setEndTime(endTime);
tourActivities.addActivity(act);
openShipments.add(shipment);
return this;
}
/**
* Adds a the delivery of the specified shipment.
*
* @param shipment
* @throws IllegalStateException if specified shipment has not been picked up yet (i.e. method addPickup(shipment) has not been called yet).
* @return
*/
public VehicleRouteBuilder addDelivery(Shipment shipment){
addDelivery(shipment,0.0,0.0);
return this;
}
/**
* Adds a the delivery of the specified shipment at a specified arrival and endTime.
*
* @param shipment
* @throws IllegalStateException if specified shipment has not been picked up yet (i.e. method addPickup(shipment) has not been called yet).
* @return
*/
public VehicleRouteBuilder addDelivery(Shipment shipment, double arrTime, double endTime){
if(openShipments.contains(shipment)){
TourActivity act = shipmentActivityFactory.createDelivery(shipment);
act.setArrTime(arrTime);
act.setEndTime(endTime);
tourActivities.addActivity(act);
openShipments.remove(shipment);
}
else{ throw new IllegalStateException("cannot deliver shipment. shipment " + shipment + " needs to be picked up first."); }
return this;
}
/**
* Builds the route.
*
* @return {@link VehicleRoute}
* @throws IllegalStateException if there are still shipments that have been picked up though but not delivery.
*/
public VehicleRoute build(){
if(!openShipments.isEmpty()){
throw new IllegalStateException("there are still shipments that have not been delivered yet.");
}
VehicleRoute route = VehicleRoute.newInstance(tourActivities, driver, vehicle);
return route;
}
}

40
jsprit-core/src/main/java/basics/route/VehicleRouteCostCalculator.java
View file

@ -1,40 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package basics.route;
@Deprecated
public interface VehicleRouteCostCalculator {
public void addTransportCost(double cost);
public void addActivityCost(double cost);
public void addOtherCost(double cost);
public void price(Vehicle vehicle);
public void price(Driver driver);
public double getCosts();
public void finish();
public void reset();
public VehicleRouteCostCalculator duplicate();
}

54
jsprit-core/src/main/java/jsprit/core/algorithm/FindCheaperVehicle.java Normal file
View file

@ -0,0 +1,54 @@
///*******************************************************************************
// * Copyright (C) 2013 Stefan Schroeder
// *
// * This library is free software; you can redistribute it and/or
// * modify it under the terms of the GNU Lesser General Public
// * License as published by the Free Software Foundation; either
// * version 3.0 of the License, or (at your option) any later version.
// *
// * This library is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// * Lesser General Public License for more details.
// *
// * You should have received a copy of the GNU Lesser General Public
// * License along with this library. If not, see <http://www.gnu.org/licenses/>.
// ******************************************************************************/
//package jsprit.core.algorithm;
//
//import java.util.ArrayList;
//import java.util.Collection;
//import java.util.List;
//
//import jsprit.core.algorithm.recreate.listener.InsertionStartsListener;
//import jsprit.core.problem.job.Job;
//import jsprit.core.problem.solution.route.VehicleRoute;
//
//
//class FindCheaperVehicle implements InsertionStartsListener{
//
// FindCheaperVehicleAlgo findCheaperVehicle;
//
// public FindCheaperVehicle(FindCheaperVehicleAlgo findCheaperVehicle) {
// super();
// this.findCheaperVehicle = findCheaperVehicle;
// }
//
// @Override
// public void informInsertionStarts(Collection<VehicleRoute> vehicleRoutes, Collection<Job> unassignedJobs) {
// List<VehicleRoute> newRoutes = new ArrayList<VehicleRoute>();
// for(VehicleRoute route : vehicleRoutes){
// if(route.isEmpty()) continue;
// VehicleRoute cheaperRoute = findCheaperVehicle.runAndGetVehicleRoute(route);
// newRoutes.add(cheaperRoute);
// }
// vehicleRoutes.clear();
// vehicleRoutes.addAll(newRoutes);
// }
//
// @Override
// public String toString() {
// return "[name=findCheaperVehicle]";
// }
//
//}

114
jsprit-core/src/main/java/jsprit/core/algorithm/FindCheaperVehicleAlgo.java Normal file
View file

@ -0,0 +1,114 @@
///*******************************************************************************
// * Copyright (C) 2013 Stefan Schroeder
// *
// * This library is free software; you can redistribute it and/or
// * modify it under the terms of the GNU Lesser General Public
// * License as published by the Free Software Foundation; either
// * version 3.0 of the License, or (at your option) any later version.
// *
// * This library is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// * Lesser General Public License for more details.
// *
// * You should have received a copy of the GNU Lesser General Public
// * License along with this library. If not, see <http://www.gnu.org/licenses/>.
// ******************************************************************************/
//package jsprit.core.algorithm;
//
//import java.util.ArrayList;
//import java.util.List;
//
//import jsprit.core.algorithm.recreate.AuxilliaryCostCalculator;
//import jsprit.core.algorithm.state.StateFactory;
//import jsprit.core.algorithm.state.StateGetter;
//import jsprit.core.problem.solution.route.VehicleRoute;
//import jsprit.core.problem.solution.route.activity.TourActivities;
//import jsprit.core.problem.solution.route.activity.TourActivity;
//import jsprit.core.problem.vehicle.Vehicle;
//import jsprit.core.problem.vehicle.VehicleFleetManager;
//import jsprit.core.problem.vehicle.VehicleImpl.NoVehicle;
//
//import org.apache.log4j.Logger;
//
//
//
//
//final class FindCheaperVehicleAlgo {
//
// private static Logger log = Logger.getLogger(FindCheaperVehicleAlgo.class);
//
// private VehicleFleetManager fleetManager;
//
// private VehicleRouteUpdater tourStateCalculator;
//
// private AuxilliaryCostCalculator auxilliaryCostCalculator;
//
// private double weightFixCosts = 1.0;
//
// private StateGetter states;
//
// public void setWeightFixCosts(double weightFixCosts) {
// this.weightFixCosts = weightFixCosts;
// }
//
// public void setStates(StateGetter states) {
// this.states = states;
// }
//
// public FindCheaperVehicleAlgo(VehicleFleetManager fleetManager, VehicleRouteUpdater tourStateCalculator, AuxilliaryCostCalculator auxilliaryCostCalculator) {
// super();
// this.fleetManager = fleetManager;
// this.tourStateCalculator = tourStateCalculator;
// this.auxilliaryCostCalculator = auxilliaryCostCalculator;
// }
//
//
// public VehicleRoute runAndGetVehicleRoute(VehicleRoute vehicleRoute) {
// if(vehicleRoute.getVehicle() instanceof NoVehicle){
// return vehicleRoute;
// }
// if(vehicleRoute.getTourActivities() == null || vehicleRoute.getVehicle() == null){
// return vehicleRoute;
// }
//// Collection<TypeKey> availableVehicleTypes = fleetManager.getAvailableVehicleTypes(new TypeKey(vehicleRoute.getVehicle().getType(),vehicleRoute.getVehicle().getLocationId()));
// double bestSaving = 0.0;
// Vehicle bestVehicle = null;
// List<TourActivity> path = new ArrayList<TourActivity>();
// path.add(vehicleRoute.getStart());
// path.addAll(vehicleRoute.getTourActivities().getActivities());
// path.add(vehicleRoute.getEnd());
//
// for(Vehicle vehicle : fleetManager.getAvailableVehicles(vehicleRoute.getVehicle().getType().getTypeId(), vehicleRoute.getVehicle().getLocationId())){
//// Vehicle vehicle = fleetManager.getEmptyVehicle(vehicleType);
// if(vehicle.getType().getTypeId().equals(vehicleRoute.getVehicle().getType().getTypeId())){
// continue;
// }
// if(states.getRouteState(vehicleRoute,StateFactory.LOAD).toDouble() <= vehicle.getCapacity()){
// double fixCostSaving = vehicleRoute.getVehicle().getType().getVehicleCostParams().fix - vehicle.getType().getVehicleCostParams().fix;
// double departureTime = vehicleRoute.getStart().getEndTime();
// double newCost = auxilliaryCostCalculator.costOfPath(path, departureTime, vehicleRoute.getDriver(), vehicle);
// double varCostSaving = states.getRouteState(vehicleRoute, StateFactory.COSTS).toDouble() - newCost;
// double totalCostSaving = varCostSaving + weightFixCosts*fixCostSaving;
// if(totalCostSaving > bestSaving){
// bestSaving = totalCostSaving;
// bestVehicle = vehicle;
// }
// }
// }
// if(bestVehicle != null){
// try{
// fleetManager.unlock(vehicleRoute.getVehicle());
// fleetManager.lock(bestVehicle);
// }
// catch(IllegalStateException e){
// throw new IllegalStateException(e);
// }
// TourActivities newTour = TourActivities.copyOf(vehicleRoute.getTourActivities());
// tourStateCalculator.iterate(vehicleRoute);
// return VehicleRoute.newInstance(newTour,vehicleRoute.getDriver(),bestVehicle);
// }
// return vehicleRoute;
// }
//
//}

15
jsprit-core/src/main/java/algorithms/InsertionInitialSolutionFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/InsertionInitialSolutionFactory.java
View file

@ -30,18 +30,21 @@
* * * *
* *********************************************************************** */ * *********************************************************************** */
package algorithms; package jsprit.core.algorithm;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import jsprit.core.algorithm.recreate.InsertionStrategy;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.InitialSolutionFactory;
import jsprit.core.problem.solution.SolutionCostCalculator;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.problem.solution.route.VehicleRoute;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import basics.Job;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.algo.SolutionCostCalculator;
import basics.route.VehicleRoute;

26
jsprit-core/src/main/java/algorithms/NeighborhoodThresholdInitialiser.java → jsprit-core/src/main/java/jsprit/core/algorithm/NeighborhoodThresholdInitialiser.java
View file

@ -14,26 +14,26 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm;
import java.util.Collection; import java.util.Collection;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms;
import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.util.CrowFlyCosts;
import jsprit.core.util.EuclideanDistanceCalculator;
import jsprit.core.util.Locations;
import jsprit.core.util.NeighborhoodImpl;
import jsprit.core.util.Solutions;
import org.apache.commons.math.stat.descriptive.moment.Mean; import org.apache.commons.math.stat.descriptive.moment.Mean;
import org.apache.commons.math.stat.descriptive.moment.StandardDeviation; import org.apache.commons.math.stat.descriptive.moment.StandardDeviation;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.CrowFlyCosts;
import util.EuclideanDistanceCalculator;
import util.Locations;
import util.NeighborhoodImpl;
import util.Solutions;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.algo.AlgorithmStartsListener;
import basics.algo.VehicleRoutingAlgorithmFactory;
import basics.route.TourActivity;
import basics.route.VehicleRoute;
class NeighborhoodThresholdInitialiser implements AlgorithmStartsListener{ class NeighborhoodThresholdInitialiser implements AlgorithmStartsListener{

11
jsprit-core/src/main/java/algorithms/RemoveEmptyVehicles.java → jsprit-core/src/main/java/jsprit/core/algorithm/RemoveEmptyVehicles.java
View file

@ -14,22 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import java.util.List; import java.util.List;
import org.apache.log4j.Logger; import jsprit.core.algorithm.recreate.listener.InsertionEndsListener;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.vehicle.VehicleFleetManager;
import basics.algo.InsertionEndsListener;
import basics.route.VehicleFleetManager;
import basics.route.VehicleRoute;
public class RemoveEmptyVehicles implements InsertionEndsListener{ public class RemoveEmptyVehicles implements InsertionEndsListener{
private static Logger log = Logger.getLogger(RemoveEmptyVehicles.class);
private VehicleFleetManager fleetManager; private VehicleFleetManager fleetManager;
public RemoveEmptyVehicles(VehicleFleetManager fleetManager) { public RemoveEmptyVehicles(VehicleFleetManager fleetManager) {

24
jsprit-core/src/main/java/algorithms/ResetAndIniFleetManager.java → jsprit-core/src/main/java/jsprit/core/algorithm/ResetAndIniFleetManager.java
View file

@ -14,25 +14,22 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import org.apache.log4j.Logger; import jsprit.core.algorithm.recreate.listener.InsertionStartsListener;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.vehicle.VehicleFleetManager;
import basics.Job;
import basics.algo.InsertionStartsListener;
import basics.route.VehicleFleetManager;
import basics.route.VehicleRoute;
class ResetAndIniFleetManager implements InsertionStartsListener{ public class ResetAndIniFleetManager implements InsertionStartsListener{
private static Logger log = Logger.getLogger(ResetAndIniFleetManager.class);
private VehicleFleetManager vehicleFleetManager; private VehicleFleetManager vehicleFleetManager;
ResetAndIniFleetManager(VehicleFleetManager vehicleFleetManager) { public ResetAndIniFleetManager(VehicleFleetManager vehicleFleetManager) {
super(); super();
this.vehicleFleetManager = vehicleFleetManager; this.vehicleFleetManager = vehicleFleetManager;
} }
@ -42,12 +39,7 @@ class ResetAndIniFleetManager implements InsertionStartsListener{
vehicleFleetManager.unlockAll(); vehicleFleetManager.unlockAll();
Collection<VehicleRoute> routes = new ArrayList<VehicleRoute>(vehicleRoutes); Collection<VehicleRoute> routes = new ArrayList<VehicleRoute>(vehicleRoutes);
for(VehicleRoute route : routes){ for(VehicleRoute route : routes){
// if(route.isEmpty()){ vehicleFleetManager.lock(route.getVehicle());
// vehicleRoutes.remove(route);
// }
// else{
vehicleFleetManager.lock(route.getVehicle());
// }
} }
} }

13
jsprit-core/src/main/java/basics/algo/SearchStrategy.java → jsprit-core/src/main/java/jsprit/core/algorithm/SearchStrategy.java
View file

@ -14,18 +14,21 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import jsprit.core.algorithm.acceptor.SolutionAcceptor;
import jsprit.core.algorithm.listener.SearchStrategyModuleListener;
import jsprit.core.algorithm.selector.SolutionSelector;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.SolutionCostCalculator;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import algorithms.acceptors.SolutionAcceptor;
import algorithms.selectors.SolutionSelector;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;

7
jsprit-core/src/main/java/basics/algo/SearchStrategyManager.java → jsprit-core/src/main/java/jsprit/core/algorithm/SearchStrategyManager.java
View file

@ -14,14 +14,17 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Random; import java.util.Random;
import util.RandomNumberGeneration; import jsprit.core.algorithm.listener.SearchStrategyListener;
import jsprit.core.algorithm.listener.SearchStrategyModuleListener;
import jsprit.core.util.RandomNumberGeneration;
public class SearchStrategyManager { public class SearchStrategyManager {

5
jsprit-core/src/main/java/basics/algo/SearchStrategyModule.java → jsprit-core/src/main/java/jsprit/core/algorithm/SearchStrategyModule.java
View file

@ -14,9 +14,10 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm;
import basics.VehicleRoutingProblemSolution; import jsprit.core.algorithm.listener.SearchStrategyModuleListener;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
public interface SearchStrategyModule { public interface SearchStrategyModule {

14
jsprit-core/src/main/java/algorithms/VariablePlusFixedSolutionCostCalculatorFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/VariablePlusFixedSolutionCostCalculatorFactory.java
View file

@ -1,14 +1,16 @@
package algorithms; package jsprit.core.algorithm;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.SolutionCostCalculator;
import basics.algo.SolutionCostCalculator; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
import jsprit.core.problem.solution.route.state.StateFactory;
public class VariablePlusFixedSolutionCostCalculatorFactory { public class VariablePlusFixedSolutionCostCalculatorFactory {
private StateManager stateManager; private RouteAndActivityStateGetter stateManager;
public VariablePlusFixedSolutionCostCalculatorFactory(StateManager stateManager) { public VariablePlusFixedSolutionCostCalculatorFactory(RouteAndActivityStateGetter stateManager) {
super(); super();
this.stateManager = stateManager; this.stateManager = stateManager;
} }

81
jsprit-core/src/main/java/basics/VehicleRoutingAlgorithm.java → jsprit-core/src/main/java/jsprit/core/algorithm/VehicleRoutingAlgorithm.java
View file

@ -14,26 +14,29 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics; package jsprit.core.algorithm;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import jsprit.core.algorithm.SearchStrategy.DiscoveredSolution;
import jsprit.core.algorithm.acceptor.SolutionAcceptor;
import jsprit.core.algorithm.listener.AlgorithmEndsListener;
import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.algorithm.listener.IterationEndsListener;
import jsprit.core.algorithm.listener.IterationStartsListener;
import jsprit.core.algorithm.listener.SearchStrategyListener;
import jsprit.core.algorithm.listener.SearchStrategyModuleListener;
import jsprit.core.algorithm.listener.StrategySelectedListener;
import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListener;
import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners;
import jsprit.core.algorithm.termination.IterationWithoutImprovementTermination;
import jsprit.core.algorithm.termination.PrematureAlgorithmTermination;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.Counter;
import algorithms.acceptors.SolutionAcceptor;
import basics.algo.AlgorithmEndsListener;
import basics.algo.AlgorithmStartsListener;
import basics.algo.IterationEndsListener;
import basics.algo.IterationStartsListener;
import basics.algo.IterationWithoutImprovementBreaker;
import basics.algo.PrematureAlgorithmBreaker;
import basics.algo.SearchStrategy;
import basics.algo.SearchStrategy.DiscoveredSolution;
import basics.algo.SearchStrategyManager;
import basics.algo.VehicleRoutingAlgorithmListener;
import basics.algo.VehicleRoutingAlgorithmListeners;
/** /**
* Algorithm that solves a {@link VehicleRoutingProblem}. * Algorithm that solves a {@link VehicleRoutingProblem}.
@ -43,7 +46,36 @@ import basics.algo.VehicleRoutingAlgorithmListeners;
*/ */
public class VehicleRoutingAlgorithm { public class VehicleRoutingAlgorithm {
private static class Counter {
private final String name;
private long counter = 0;
private long nextCounter = 1;
private static final Logger log = Logger.getLogger(Counter.class);
public Counter(final String name) {
this.name = name;
}
public void incCounter() {
long i = counter++;
long n = nextCounter;
if (i >= n) {
if (nextCounter==n) {
nextCounter=n*2;
log.info(this.name + n);
}
}
}
public void print() {
log.info(this.name + counter);
}
public void reset() {
counter=0;
nextCounter=1;
}
}
public static final int NOBREAK = Integer.MAX_VALUE; public static final int NOBREAK = Integer.MAX_VALUE;
@ -61,7 +93,7 @@ public class VehicleRoutingAlgorithm {
private Collection<VehicleRoutingProblemSolution> initialSolutions; private Collection<VehicleRoutingProblemSolution> initialSolutions;
private PrematureAlgorithmBreaker prematureAlgorithmBreaker = new PrematureAlgorithmBreaker() { private PrematureAlgorithmTermination prematureAlgorithmTermination = new PrematureAlgorithmTermination() {
@Override @Override
public boolean isPrematureBreak(DiscoveredSolution discoveredSolution) { public boolean isPrematureBreak(DiscoveredSolution discoveredSolution) {
@ -100,15 +132,16 @@ public class VehicleRoutingAlgorithm {
* Improvement is what {@link SolutionAcceptor} understands about improvement. Or to put it in other words, the algo breaks prematurely after * Improvement is what {@link SolutionAcceptor} understands about improvement. Or to put it in other words, the algo breaks prematurely after
* the assigned number of iterations without solution-acceptance. * the assigned number of iterations without solution-acceptance.
* *
* * @deprecated use setPrematureAlgorithmTermination(new IterationWithoutImprovementTermination(int nuIterationsWithoutImprovement));
* @param nuIterationsWithoutImprovement * @param nuIterationsWithoutImprovement
*/ */
@Deprecated
public void setPrematureBreak(int nuIterationsWithoutImprovement){ public void setPrematureBreak(int nuIterationsWithoutImprovement){
prematureAlgorithmBreaker = new IterationWithoutImprovementBreaker(nuIterationsWithoutImprovement); prematureAlgorithmTermination = new IterationWithoutImprovementTermination(nuIterationsWithoutImprovement);
} }
public void setPrematureAlgorithmBreaker(PrematureAlgorithmBreaker prematureAlgorithmBreaker){ public void setPrematureAlgorithmTermination(PrematureAlgorithmTermination prematureAlgorithmTermination){
this.prematureAlgorithmBreaker = prematureAlgorithmBreaker; this.prematureAlgorithmTermination = prematureAlgorithmTermination;
} }
/** /**
@ -146,7 +179,7 @@ public class VehicleRoutingAlgorithm {
SearchStrategy strategy = searchStrategyManager.getRandomStrategy(); SearchStrategy strategy = searchStrategyManager.getRandomStrategy();
DiscoveredSolution discoveredSolution = strategy.run(problem, solutions); DiscoveredSolution discoveredSolution = strategy.run(problem, solutions);
selectedStrategy(strategy.getName(),problem, solutions); selectedStrategy(strategy.getName(),problem, solutions);
if(prematureAlgorithmBreaker.isPrematureBreak(discoveredSolution)){ if(prematureAlgorithmTermination.isPrematureBreak(discoveredSolution)){
logger.info("premature break at iteration "+ (i+1)); logger.info("premature break at iteration "+ (i+1));
nuOfIterationsThisAlgoIsRunning = (i+1); nuOfIterationsThisAlgoIsRunning = (i+1);
break; break;
@ -193,6 +226,12 @@ public class VehicleRoutingAlgorithm {
public VehicleRoutingAlgorithmListeners getAlgorithmListeners() { public VehicleRoutingAlgorithmListeners getAlgorithmListeners() {
return algoListeners; return algoListeners;
} }
public void addListener(VehicleRoutingAlgorithmListener l){
algoListeners.addListener(l);
if(l instanceof SearchStrategyListener) searchStrategyManager.addSearchStrategyListener((SearchStrategyListener) l);
if(l instanceof SearchStrategyModuleListener) searchStrategyManager.addSearchStrategyModuleListener((SearchStrategyModuleListener) l);
}
private void iterationEnds(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) { private void iterationEnds(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
algoListeners.iterationEnds(i,problem, solutions); algoListeners.iterationEnds(i,problem, solutions);

5
jsprit-core/src/main/java/basics/algo/VehicleRoutingAlgorithmFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/VehicleRoutingAlgorithmFactory.java
View file

@ -14,10 +14,9 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm;
import basics.VehicleRoutingAlgorithm; import jsprit.core.problem.VehicleRoutingProblem;
import basics.VehicleRoutingProblem;
public interface VehicleRoutingAlgorithmFactory { public interface VehicleRoutingAlgorithmFactory {

5
jsprit-core/src/main/java/algorithms/acceptors/AcceptNewRemoveFirst.java → jsprit-core/src/main/java/jsprit/core/algorithm/acceptor/AcceptNewRemoveFirst.java
View file

@ -14,11 +14,12 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms.acceptors; package jsprit.core.algorithm.acceptor;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
public class AcceptNewRemoveFirst implements SolutionAcceptor{ public class AcceptNewRemoveFirst implements SolutionAcceptor{

158
jsprit-core/src/main/java/jsprit/core/algorithm/acceptor/ExperimentalSchrimpfAcceptance.java Normal file
View file

@ -0,0 +1,158 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package jsprit.core.algorithm.acceptor;
import java.net.URL;
import java.util.Collection;
import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.io.AlgorithmConfig;
import jsprit.core.algorithm.io.AlgorithmConfigXmlReader;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms;
import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.algorithm.listener.IterationEndsListener;
import jsprit.core.algorithm.listener.IterationStartsListener;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.util.Resource;
import jsprit.core.util.Solutions;
import org.apache.commons.math.stat.descriptive.moment.StandardDeviation;
import org.apache.log4j.Logger;
public class ExperimentalSchrimpfAcceptance implements SolutionAcceptor, IterationStartsListener, AlgorithmStartsListener{
private static Logger logger = Logger.getLogger(ExperimentalSchrimpfAcceptance.class);
private final double alpha;
private int nOfTotalIterations = 1000;
private int currentIteration = 0;
private double initialThreshold = 0.0;
private final int nOfRandomWalks;
private final int solutionMemory;
public ExperimentalSchrimpfAcceptance(int solutionMemory, double alpha, int nOfWarmupIterations) {
super();
this.alpha = alpha;
this.nOfRandomWalks = nOfWarmupIterations;
this.solutionMemory = solutionMemory;
logger.info("initialise " + this);
}
@Override
public boolean acceptSolution(Collection<VehicleRoutingProblemSolution> solutions, VehicleRoutingProblemSolution newSolution) {
boolean solutionAccepted = false;
if (solutions.size() < solutionMemory) {
solutions.add(newSolution);
solutionAccepted = true;
} else {
VehicleRoutingProblemSolution worst = null;
double threshold = getThreshold(currentIteration);
for(VehicleRoutingProblemSolution solutionInMemory : solutions){
if(worst == null) worst = solutionInMemory;
else if(solutionInMemory.getCost() > worst.getCost()) worst = solutionInMemory;
}
if(newSolution.getRoutes().size() < worst.getRoutes().size()){
solutions.remove(worst);
solutions.add(newSolution);
solutionAccepted = true;
}
else if(newSolution.getRoutes().size() == worst.getRoutes().size() && newSolution.getCost() < worst.getCost() + threshold){
solutions.remove(worst);
solutions.add(newSolution);
solutionAccepted = true;
}
}
return solutionAccepted;
}
@Override
public String toString() {
return "[name=schrimpfAcceptanceFunction][alpha="+alpha+"][warmup=" + nOfRandomWalks + "]";
}
private double getThreshold(int iteration) {
double scheduleVariable = (double) iteration / (double) nOfTotalIterations;
// logger.debug("iter="+iteration+" totalIter="+nOfTotalIterations+" scheduling="+scheduleVariable);
double currentThreshold = initialThreshold * Math.exp(-Math.log(2) * scheduleVariable / alpha);
return currentThreshold;
}
@Override
public void informAlgorithmStarts(VehicleRoutingProblem problem, VehicleRoutingAlgorithm algorithm, Collection<VehicleRoutingProblemSolution> solutions) {
reset();
logger.info("---------------------------------------------------------------------");
logger.info("prepare schrimpfAcceptanceFunction, i.e. determine initial threshold");
logger.info("start random-walk (see randomWalk.xml)");
double now = System.currentTimeMillis();
this.nOfTotalIterations = algorithm.getNuOfIterations();
/*
* randomWalk to determine standardDev
*/
final double[] results = new double[nOfRandomWalks];
URL resource = Resource.getAsURL("randomWalk.xml");
AlgorithmConfig algorithmConfig = new AlgorithmConfig();
new AlgorithmConfigXmlReader(algorithmConfig).read(resource);
VehicleRoutingAlgorithm vra = VehicleRoutingAlgorithms.createAlgorithm(problem, algorithmConfig);
vra.setNuOfIterations(nOfRandomWalks);
vra.getAlgorithmListeners().addListener(new IterationEndsListener() {
@Override
public void informIterationEnds(int iteration, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
double result = Solutions.getBest(solutions).getCost();
// logger.info("result="+result);
results[iteration-1] = result;
}
});
vra.searchSolutions();
StandardDeviation dev = new StandardDeviation();
double standardDeviation = dev.evaluate(results);
initialThreshold = standardDeviation / 2;
logger.info("warmup done");
logger.info("total time: " + ((System.currentTimeMillis()-now)/1000.0) + "s");
logger.info("initial threshold: " + initialThreshold);
logger.info("---------------------------------------------------------------------");
}
private void reset() {
currentIteration = 0;
}
@Override
public void informIterationStarts(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
currentIteration = i;
}
}

15
jsprit-core/src/main/java/algorithms/acceptors/AcceptNewIfBetterThanWorst.java → jsprit-core/src/main/java/jsprit/core/algorithm/acceptor/GreedyAcceptance.java
View file

@ -14,18 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms.acceptors; package jsprit.core.algorithm.acceptor;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
public class AcceptNewIfBetterThanWorst implements SolutionAcceptor{
public class GreedyAcceptance implements SolutionAcceptor{
private final int solutionMemory; private final int solutionMemory;
public AcceptNewIfBetterThanWorst(int solutionMemory){ public GreedyAcceptance(int solutionMemory){
this.solutionMemory = solutionMemory; this.solutionMemory = solutionMemory;
} }
@ -47,6 +48,12 @@ public class AcceptNewIfBetterThanWorst implements SolutionAcceptor{
if (worstSolution == null) worstSolution = s; if (worstSolution == null) worstSolution = s;
else if (s.getCost() > worstSolution.getCost()) worstSolution = s; else if (s.getCost() > worstSolution.getCost()) worstSolution = s;
} }
// if(newSolution.getRoutes().size() < worstSolution.getRoutes().size()){
// solutions.remove(worstSolution);
// solutions.add(newSolution);
// solutionAccepted = true;
// }
// else
if(newSolution.getCost() < worstSolution.getCost()){ if(newSolution.getCost() < worstSolution.getCost()){
solutions.remove(worstSolution); solutions.remove(worstSolution);
solutions.add(newSolution); solutions.add(newSolution);

73
jsprit-core/src/main/java/jsprit/core/algorithm/acceptor/GreedyAcceptance_minVehFirst.java Normal file
View file

@ -0,0 +1,73 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package jsprit.core.algorithm.acceptor;
import java.util.Collection;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
public class GreedyAcceptance_minVehFirst implements SolutionAcceptor{
private final int solutionMemory;
public GreedyAcceptance_minVehFirst(int solutionMemory){
this.solutionMemory = solutionMemory;
}
/**
* Accepts every solution if solution memory allows. If memory occupied, than accepts new solution only if better than the worst in memory.
* Consequently, the worst solution is removed from solutions, and the new solution added.
*
* <p>Note that this modifies Collection<VehicleRoutingProblemSolution> solutions.
*/
@Override
public boolean acceptSolution(Collection<VehicleRoutingProblemSolution> solutions, VehicleRoutingProblemSolution newSolution) {
boolean solutionAccepted = false;
if (solutions.size() < solutionMemory) {
solutions.add(newSolution);
solutionAccepted = true;
} else {
VehicleRoutingProblemSolution worstSolution = null;
for (VehicleRoutingProblemSolution s : solutions) {
if (worstSolution == null) worstSolution = s;
else if (s.getRoutes().size() > worstSolution.getRoutes().size()) worstSolution = s;
}
if(newSolution.getRoutes().size() < worstSolution.getRoutes().size()){
solutions.remove(worstSolution);
solutions.add(newSolution);
solutionAccepted = true;
}
else if(newSolution.getRoutes().size() == worstSolution.getRoutes().size() && newSolution.getCost() < worstSolution.getCost()){
solutions.remove(worstSolution);
solutions.add(newSolution);
solutionAccepted = true;
}
}
return solutionAccepted;
}
@Override
public String toString() {
return "[name=greedyAcceptance_minVehFirst]";
}
}

25
jsprit-core/src/main/java/algorithms/acceptors/SchrimpfAcceptance.java → jsprit-core/src/main/java/jsprit/core/algorithm/acceptor/SchrimpfAcceptance.java
View file

@ -14,25 +14,26 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms.acceptors; package jsprit.core.algorithm.acceptor;
import java.net.URL; import java.net.URL;
import java.util.Collection; import java.util.Collection;
import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.io.AlgorithmConfig;
import jsprit.core.algorithm.io.AlgorithmConfigXmlReader;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms;
import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.algorithm.listener.IterationEndsListener;
import jsprit.core.algorithm.listener.IterationStartsListener;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.util.Resource;
import jsprit.core.util.Solutions;
import org.apache.commons.math.stat.descriptive.moment.StandardDeviation; import org.apache.commons.math.stat.descriptive.moment.StandardDeviation;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.Resource;
import util.Solutions;
import algorithms.VehicleRoutingAlgorithms;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution;
import basics.algo.AlgorithmStartsListener;
import basics.algo.IterationEndsListener;
import basics.algo.IterationStartsListener;
import basics.io.AlgorithmConfig;
import basics.io.AlgorithmConfigXmlReader;

5
jsprit-core/src/main/java/algorithms/acceptors/SolutionAcceptor.java → jsprit-core/src/main/java/jsprit/core/algorithm/acceptor/SolutionAcceptor.java
View file

@ -14,11 +14,12 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms.acceptors; package jsprit.core.algorithm.acceptor;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
/** /**
* Acceptor that decides whether the newSolution is accepted or not. * Acceptor that decides whether the newSolution is accepted or not.

14
jsprit-core/src/main/java/algorithms/GreedySchrimpfFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/box/GreedySchrimpfFactory.java
View file

@ -14,15 +14,17 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.box;
import java.net.URL; import java.net.URL;
import util.Resource; import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import basics.VehicleRoutingAlgorithm; import jsprit.core.algorithm.io.AlgorithmConfig;
import basics.VehicleRoutingProblem; import jsprit.core.algorithm.io.AlgorithmConfigXmlReader;
import basics.io.AlgorithmConfig; import jsprit.core.algorithm.io.VehicleRoutingAlgorithms;
import basics.io.AlgorithmConfigXmlReader; import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.util.Resource;
/** /**

14
jsprit-core/src/main/java/algorithms/SchrimpfFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/box/SchrimpfFactory.java
View file

@ -14,15 +14,17 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.box;
import java.net.URL; import java.net.URL;
import util.Resource; import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import basics.VehicleRoutingAlgorithm; import jsprit.core.algorithm.io.AlgorithmConfig;
import basics.VehicleRoutingProblem; import jsprit.core.algorithm.io.AlgorithmConfigXmlReader;
import basics.io.AlgorithmConfig; import jsprit.core.algorithm.io.VehicleRoutingAlgorithms;
import basics.io.AlgorithmConfigXmlReader; import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.util.Resource;
/** /**

2
jsprit-core/src/main/java/basics/io/AlgorithmConfig.java → jsprit-core/src/main/java/jsprit/core/algorithm/io/AlgorithmConfig.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.io; package jsprit.core.algorithm.io;
import org.apache.commons.configuration.XMLConfiguration; import org.apache.commons.configuration.XMLConfiguration;

5
jsprit-core/src/main/java/basics/io/AlgorithmConfigXmlReader.java → jsprit-core/src/main/java/jsprit/core/algorithm/io/AlgorithmConfigXmlReader.java
View file

@ -14,19 +14,20 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.io; package jsprit.core.algorithm.io;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.net.URL; import java.net.URL;
import jsprit.core.util.Resource;
import org.apache.commons.configuration.ConfigurationException; import org.apache.commons.configuration.ConfigurationException;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.xml.sax.EntityResolver; import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource; import org.xml.sax.InputSource;
import org.xml.sax.SAXException; import org.xml.sax.SAXException;
import util.Resource;
public class AlgorithmConfigXmlReader { public class AlgorithmConfigXmlReader {

43
jsprit-core/src/main/java/algorithms/InsertionFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/io/InsertionFactory.java
View file

@ -14,19 +14,24 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.io;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
import jsprit.core.algorithm.recreate.BestInsertionBuilder;
import jsprit.core.algorithm.recreate.InsertionStrategy;
import jsprit.core.algorithm.recreate.listener.InsertionListener;
import jsprit.core.algorithm.state.StateManager;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.constraint.ConstraintManager;
import jsprit.core.problem.vehicle.VehicleFleetManager;
import org.apache.commons.configuration.HierarchicalConfiguration; import org.apache.commons.configuration.HierarchicalConfiguration;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import basics.VehicleRoutingProblem;
import basics.algo.InsertionListener;
import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
import basics.route.VehicleFleetManager;
class InsertionFactory { class InsertionFactory {
@ -44,16 +49,17 @@ class InsertionFactory {
List<InsertionListener> insertionListeners = new ArrayList<InsertionListener>(); List<InsertionListener> insertionListeners = new ArrayList<InsertionListener>();
List<PrioritizedVRAListener> algoListeners = new ArrayList<PrioritizedVRAListener>(); List<PrioritizedVRAListener> algoListeners = new ArrayList<PrioritizedVRAListener>();
CalculatorBuilder calcBuilder = new CalculatorBuilder(insertionListeners, algorithmListeners); BestInsertionBuilder iBuilder = new BestInsertionBuilder(vrp, vehicleFleetManager, routeStates, constraintManager);
calcBuilder.setStates(routeStates);
calcBuilder.setVehicleRoutingProblem(vrp); if(executorService != null){
calcBuilder.setVehicleFleetManager(vehicleFleetManager); iBuilder.setConcurrentMode(executorService, nuOfThreads);
calcBuilder.setConstraintManager(constraintManager); }
if(config.containsKey("level")){ if(config.containsKey("level")){
String level = config.getString("level"); String level = config.getString("level");
if(level.equals("local")){ if(level.equals("local")){
calcBuilder.setLocalLevel(); iBuilder.setLocalLevel();
// calcBuilder.setLocalLevel();
} }
else if(level.equals("route")){ else if(level.equals("route")){
int forwardLooking = 0; int forwardLooking = 0;
@ -64,11 +70,12 @@ class InsertionFactory {
else log.warn("parameter route[@forwardLooking] is missing. by default it is 0 which equals to local level"); else log.warn("parameter route[@forwardLooking] is missing. by default it is 0 which equals to local level");
if(mem != null) memory = Integer.parseInt(mem); if(mem != null) memory = Integer.parseInt(mem);
else log.warn("parameter route[@memory] is missing. by default it is 1"); else log.warn("parameter route[@memory] is missing. by default it is 1");
calcBuilder.setRouteLevel(forwardLooking, memory); iBuilder.setRouteLevel(forwardLooking, memory);
// calcBuilder.setRouteLevel(forwardLooking, memory);
} }
else throw new IllegalStateException("level " + level + " is not known. currently it only knows \"local\" or \"route\""); else throw new IllegalStateException("level " + level + " is not known. currently it only knows \"local\" or \"route\"");
} }
else calcBuilder.setLocalLevel(); else iBuilder.setLocalLevel();
if(config.containsKey("considerFixedCosts") || config.containsKey("considerFixedCost")){ if(config.containsKey("considerFixedCosts") || config.containsKey("considerFixedCost")){
String val = config.getString("considerFixedCosts"); String val = config.getString("considerFixedCosts");
@ -79,21 +86,19 @@ class InsertionFactory {
if(weight == null) weight = config.getString("considerFixedCost[@weight]"); if(weight == null) weight = config.getString("considerFixedCost[@weight]");
if(weight != null) fixedCostWeight = Double.parseDouble(weight); if(weight != null) fixedCostWeight = Double.parseDouble(weight);
else log.warn("parameter considerFixedCosts[@weight] is missing. by default, it is 0.5."); else log.warn("parameter considerFixedCosts[@weight] is missing. by default, it is 0.5.");
calcBuilder.considerFixedCosts(fixedCostWeight); iBuilder.considerFixedCosts(fixedCostWeight);
} }
} }
String timeSliceString = config.getString("experimental[@timeSlice]"); String timeSliceString = config.getString("experimental[@timeSlice]");
String neighbors = config.getString("experimental[@neighboringSlices]"); String neighbors = config.getString("experimental[@neighboringSlices]");
if(timeSliceString != null && neighbors != null){ if(timeSliceString != null && neighbors != null){
calcBuilder.experimentalTimeScheduler(Double.parseDouble(timeSliceString),Integer.parseInt(neighbors)); iBuilder.experimentalTimeScheduler(Double.parseDouble(timeSliceString),Integer.parseInt(neighbors));
} }
JobInsertionCostsCalculator jic = calcBuilder.build();
if(insertionName.equals("bestInsertion")){ if(insertionName.equals("bestInsertion")){
insertionStrategy = new BestInsertion(jic); insertionStrategy = iBuilder.build();
} }
else throw new IllegalStateException("currently only 'bestInsertion' is supported");
for(InsertionListener l : insertionListeners) insertionStrategy.addListener(l); for(InsertionListener l : insertionListeners) insertionStrategy.addListener(l);
algorithmListeners.addAll(algoListeners); algorithmListeners.addAll(algoListeners);

269
jsprit-core/src/main/java/algorithms/VehicleRoutingAlgorithms.java → jsprit-core/src/main/java/jsprit/core/algorithm/io/VehicleRoutingAlgorithms.java
View file

@ -14,9 +14,10 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.io;
import java.lang.Thread.UncaughtExceptionHandler;
import java.net.URL; import java.net.URL;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -26,48 +27,68 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import jsprit.core.algorithm.InsertionInitialSolutionFactory;
import jsprit.core.algorithm.RemoveEmptyVehicles;
import jsprit.core.algorithm.ResetAndIniFleetManager;
import jsprit.core.algorithm.SearchStrategy;
import jsprit.core.algorithm.SearchStrategy.DiscoveredSolution;
import jsprit.core.algorithm.SearchStrategyManager;
import jsprit.core.algorithm.SearchStrategyModule;
import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.acceptor.AcceptNewRemoveFirst;
import jsprit.core.algorithm.acceptor.ExperimentalSchrimpfAcceptance;
import jsprit.core.algorithm.acceptor.GreedyAcceptance;
import jsprit.core.algorithm.acceptor.GreedyAcceptance_minVehFirst;
import jsprit.core.algorithm.acceptor.SchrimpfAcceptance;
import jsprit.core.algorithm.acceptor.SolutionAcceptor;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.AbstractKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.AcceptorKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.InsertionStrategyKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.RuinStrategyKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.SelectorKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.StrategyModuleKey;
import jsprit.core.algorithm.listener.AlgorithmEndsListener;
import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.Priority;
import jsprit.core.algorithm.module.RuinAndRecreateModule;
import jsprit.core.algorithm.recreate.InsertionStrategy;
import jsprit.core.algorithm.recreate.VehicleSwitched;
import jsprit.core.algorithm.recreate.listener.InsertionListener;
import jsprit.core.algorithm.ruin.RadialRuinStrategyFactory;
import jsprit.core.algorithm.ruin.RandomRuinStrategyFactory;
import jsprit.core.algorithm.ruin.RuinStrategy;
import jsprit.core.algorithm.ruin.distance.AvgServiceAndShipmentDistance;
import jsprit.core.algorithm.ruin.distance.JobDistance;
import jsprit.core.algorithm.selector.SelectBest;
import jsprit.core.algorithm.selector.SelectRandomly;
import jsprit.core.algorithm.selector.SolutionSelector;
import jsprit.core.algorithm.state.StateManager;
import jsprit.core.algorithm.state.UpdateActivityTimes;
import jsprit.core.algorithm.state.UpdateVariableCosts;
import jsprit.core.algorithm.termination.IterationWithoutImprovementTermination;
import jsprit.core.algorithm.termination.PrematureAlgorithmTermination;
import jsprit.core.algorithm.termination.TimeTermination;
import jsprit.core.algorithm.termination.VariationCoefficientTermination;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.VehicleRoutingProblem.FleetSize;
import jsprit.core.problem.constraint.ConstraintManager;
import jsprit.core.problem.solution.SolutionCostCalculator;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.FiniteFleetManagerFactory;
import jsprit.core.problem.vehicle.InfiniteFleetManagerFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleFleetManager;
import jsprit.core.util.SolutionVerifier;
import org.apache.commons.configuration.HierarchicalConfiguration; import org.apache.commons.configuration.HierarchicalConfiguration;
import org.apache.commons.configuration.XMLConfiguration; import org.apache.commons.configuration.XMLConfiguration;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import algorithms.VehicleRoutingAlgorithms.TypedMap.AbstractKey;
import algorithms.VehicleRoutingAlgorithms.TypedMap.AcceptorKey;
import algorithms.VehicleRoutingAlgorithms.TypedMap.InsertionStrategyKey;
import algorithms.VehicleRoutingAlgorithms.TypedMap.RuinStrategyKey;
import algorithms.VehicleRoutingAlgorithms.TypedMap.SelectorKey;
import algorithms.VehicleRoutingAlgorithms.TypedMap.StrategyModuleKey;
import algorithms.acceptors.AcceptNewIfBetterThanWorst;
import algorithms.acceptors.AcceptNewRemoveFirst;
import algorithms.acceptors.SchrimpfAcceptance;
import algorithms.acceptors.SolutionAcceptor;
import algorithms.selectors.SelectBest;
import algorithms.selectors.SelectRandomly;
import algorithms.selectors.SolutionSelector;
import basics.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem;
import basics.VehicleRoutingProblem.FleetSize;
import basics.VehicleRoutingProblemSolution;
import basics.algo.AlgorithmStartsListener;
import basics.algo.InsertionListener;
import basics.algo.IterationWithoutImprovementBreaker;
import basics.algo.PrematureAlgorithmBreaker;
import basics.algo.SearchStrategy;
import basics.algo.SearchStrategy.DiscoveredSolution;
import basics.algo.SearchStrategyManager;
import basics.algo.SearchStrategyModule;
import basics.algo.SolutionCostCalculator;
import basics.algo.TimeBreaker;
import basics.algo.VariationCoefficientBreaker;
import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
import basics.algo.VehicleRoutingAlgorithmListeners.Priority;
import basics.io.AlgorithmConfig;
import basics.io.AlgorithmConfigXmlReader;
import basics.route.FiniteFleetManagerFactory;
import basics.route.InfiniteFleetManagerFactory;
import basics.route.Vehicle;
import basics.route.VehicleFleetManager;
import basics.route.VehicleRoute;
@ -371,12 +392,12 @@ public class VehicleRoutingAlgorithms {
* @return {@link VehicleRoutingAlgorithm} * @return {@link VehicleRoutingAlgorithm}
*/ */
public static VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp, final AlgorithmConfig algorithmConfig){ public static VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp, final AlgorithmConfig algorithmConfig){
return createAlgo(vrp,algorithmConfig.getXMLConfiguration(),null,0); return createAlgo(vrp,algorithmConfig.getXMLConfiguration(),0);
} }
@Deprecated @Deprecated
public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, final XMLConfiguration config){ public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, final XMLConfiguration config){
return createAlgo(vrp,config,null,0); return createAlgo(vrp,config,0);
} }
/** /**
@ -390,7 +411,7 @@ public class VehicleRoutingAlgorithms {
AlgorithmConfig algorithmConfig = new AlgorithmConfig(); AlgorithmConfig algorithmConfig = new AlgorithmConfig();
AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig); AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
xmlReader.read(configURL); xmlReader.read(configURL);
return createAlgo(vrp,algorithmConfig.getXMLConfiguration(),null,0); return createAlgo(vrp,algorithmConfig.getXMLConfiguration(),0);
} }
/** /**
@ -404,26 +425,18 @@ public class VehicleRoutingAlgorithms {
AlgorithmConfig algorithmConfig = new AlgorithmConfig(); AlgorithmConfig algorithmConfig = new AlgorithmConfig();
AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig); AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
xmlReader.read(configFileName); xmlReader.read(configFileName);
return createAlgo(vrp,algorithmConfig.getXMLConfiguration(),null, 0); return createAlgo(vrp,algorithmConfig.getXMLConfiguration(),0);
} }
/** public static VehicleRoutingAlgorithm readAndCreateAlgorithm(VehicleRoutingProblem vrp, int nThreads, String configFileName) {
* Read and creates {@link VehicleRoutingAlgorithm} from config-file.
*
* @param vrp
* @param configFileName
* @param nuOfThreads TODO
* @param {@link ExecutorService}
* @return {@link VehicleRoutingAlgorithm}
*/
private static VehicleRoutingAlgorithm readAndCreateConcurrentAlgorithm(final VehicleRoutingProblem vrp, final String configFileName, final ExecutorService executorService, int nuOfThreads){
AlgorithmConfig algorithmConfig = new AlgorithmConfig(); AlgorithmConfig algorithmConfig = new AlgorithmConfig();
AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig); AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
xmlReader.read(configFileName); xmlReader.read(configFileName);
return createAlgo(vrp,algorithmConfig.getXMLConfiguration(), executorService, nuOfThreads); return createAlgo(vrp,algorithmConfig.getXMLConfiguration(),nThreads);
} }
private static VehicleRoutingAlgorithm createAlgo(final VehicleRoutingProblem vrp, XMLConfiguration config, ExecutorService executorService, int nuOfThreads){ private static VehicleRoutingAlgorithm createAlgo(final VehicleRoutingProblem vrp, XMLConfiguration config, int nuOfThreads){
// map to store constructed modules // map to store constructed modules
TypedMap definedClasses = new TypedMap(); TypedMap definedClasses = new TypedMap();
@ -434,11 +447,46 @@ public class VehicleRoutingAlgorithms {
// insertion listeners // insertion listeners
List<InsertionListener> insertionListeners = new ArrayList<InsertionListener>(); List<InsertionListener> insertionListeners = new ArrayList<InsertionListener>();
//threading
final ExecutorService executorService;
if(nuOfThreads > 0){
log.info("setup executor-service with " + nuOfThreads + " threads");
executorService = Executors.newFixedThreadPool(nuOfThreads);
algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, new AlgorithmEndsListener() {
@Override
public void informAlgorithmEnds(VehicleRoutingProblem problem,Collection<VehicleRoutingProblemSolution> solutions) {
log.info("shutdown executor-service");
executorService.shutdown();
}
}));
Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread arg0, Throwable arg1) {
System.err.println(arg1.toString());
System.exit(0);
}
});
Runtime.getRuntime().addShutdownHook(new Thread(){
public void run(){
if(!executorService.isShutdown()){
System.err.println("shutdowHook shuts down executorService");
executorService.shutdown();
}
}
});
}
else executorService = null;
//create fleetmanager //create fleetmanager
final VehicleFleetManager vehicleFleetManager = createFleetManager(vrp); final VehicleFleetManager vehicleFleetManager = createFleetManager(vrp);
//create state-manager //create state-manager
final StateManager stateManager = new StateManager(); final StateManager stateManager = new StateManager(vrp);
stateManager.updateLoadStates();
stateManager.updateTimeWindowStates();
/* /*
* define constraints * define constraints
@ -486,8 +534,8 @@ public class VehicleRoutingAlgorithms {
// UpdateLoads loadUpdater = new UpdateLoads(stateManager); // UpdateLoads loadUpdater = new UpdateLoads(stateManager);
// stateManager.addListener(loadUpdater); // stateManager.addListener(loadUpdater);
// stateManager.addActivityVisitor(loadUpdater); // stateManager.addActivityVisitor(loadUpdater);
stateManager.addActivityVisitor(new UpdateActivityTimes(vrp.getTransportCosts())); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts()));
stateManager.addActivityVisitor(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager)); stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
// stateManager.addActivityVisitor(new UpdateOccuredDeliveries(stateManager)); // stateManager.addActivityVisitor(new UpdateOccuredDeliveries(stateManager));
// stateManager.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts())); // stateManager.addActivityVisitor(new TimeWindowUpdater(stateManager, vrp.getTransportCosts()));
@ -501,8 +549,8 @@ public class VehicleRoutingAlgorithms {
metaAlgorithm.getSearchStrategyManager().addSearchStrategyModuleListener(new VehicleSwitched(vehicleFleetManager)); metaAlgorithm.getSearchStrategyManager().addSearchStrategyModuleListener(new VehicleSwitched(vehicleFleetManager));
//define prematureBreak //define prematureBreak
PrematureAlgorithmBreaker prematureAlgoBreaker = getPrematureBreaker(config,algorithmListeners); PrematureAlgorithmTermination prematureAlgoBreaker = getPrematureBreaker(config,algorithmListeners);
metaAlgorithm.setPrematureAlgorithmBreaker(prematureAlgoBreaker); metaAlgorithm.setPrematureAlgorithmTermination(prematureAlgoBreaker);
//misc //misc
algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, new SolutionVerifier())); algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, new SolutionVerifier()));
@ -546,11 +594,11 @@ public class VehicleRoutingAlgorithms {
"makes sure your config file contains one of these options"); "makes sure your config file contains one of these options");
} }
private static PrematureAlgorithmBreaker getPrematureBreaker(XMLConfiguration config, Set<PrioritizedVRAListener> algorithmListeners) { private static PrematureAlgorithmTermination getPrematureBreaker(XMLConfiguration config, Set<PrioritizedVRAListener> algorithmListeners) {
String basedOn = config.getString("prematureBreak[@basedOn]"); String basedOn = config.getString("prematureBreak[@basedOn]");
if(basedOn == null){ if(basedOn == null){
log.info("set default prematureBreak, i.e. no premature break at all."); log.info("set default prematureBreak, i.e. no premature break at all.");
return new PrematureAlgorithmBreaker() { return new PrematureAlgorithmTermination() {
@Override @Override
public boolean isPrematureBreak(DiscoveredSolution discoveredSolution) { public boolean isPrematureBreak(DiscoveredSolution discoveredSolution) {
@ -563,14 +611,14 @@ public class VehicleRoutingAlgorithms {
String iter = config.getString("prematureBreak.iterations"); String iter = config.getString("prematureBreak.iterations");
if(iter == null) throw new IllegalStateException("prematureBreak.iterations is missing"); if(iter == null) throw new IllegalStateException("prematureBreak.iterations is missing");
int iterations = Integer.valueOf(iter); int iterations = Integer.valueOf(iter);
return new IterationWithoutImprovementBreaker(iterations); return new IterationWithoutImprovementTermination(iterations);
} }
if(basedOn.equals("time")){ if(basedOn.equals("time")){
log.info("set prematureBreak based on time"); log.info("set prematureBreak based on time");
String timeString = config.getString("prematureBreak.time"); String timeString = config.getString("prematureBreak.time");
if(timeString == null) throw new IllegalStateException("prematureBreak.time is missing"); if(timeString == null) throw new IllegalStateException("prematureBreak.time is missing");
double time = Double.valueOf(timeString); double time = Double.valueOf(timeString);
TimeBreaker timeBreaker = new TimeBreaker(time); TimeTermination timeBreaker = new TimeTermination(time);
algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, timeBreaker)); algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, timeBreaker));
return timeBreaker; return timeBreaker;
} }
@ -582,7 +630,7 @@ public class VehicleRoutingAlgorithms {
if(iterationsString == null) throw new IllegalStateException("prematureBreak.iterations is missing"); if(iterationsString == null) throw new IllegalStateException("prematureBreak.iterations is missing");
double threshold = Double.valueOf(thresholdString); double threshold = Double.valueOf(thresholdString);
int iterations = Integer.valueOf(iterationsString); int iterations = Integer.valueOf(iterationsString);
VariationCoefficientBreaker variationCoefficientBreaker = new VariationCoefficientBreaker(iterations, threshold); VariationCoefficientTermination variationCoefficientBreaker = new VariationCoefficientTermination(iterations, threshold);
algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, variationCoefficientBreaker)); algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, variationCoefficientBreaker));
return variationCoefficientBreaker; return variationCoefficientBreaker;
} }
@ -687,7 +735,7 @@ public class VehicleRoutingAlgorithms {
SolutionAcceptor definedAcceptor = typedMap.get(acceptorKey); SolutionAcceptor definedAcceptor = typedMap.get(acceptorKey);
if(definedAcceptor != null) return definedAcceptor; if(definedAcceptor != null) return definedAcceptor;
if(acceptorName.equals("acceptNewRemoveWorst")){ if(acceptorName.equals("acceptNewRemoveWorst")){
AcceptNewIfBetterThanWorst acceptor = new AcceptNewIfBetterThanWorst(solutionMemory); GreedyAcceptance acceptor = new GreedyAcceptance(solutionMemory);
typedMap.put(acceptorKey, acceptor); typedMap.put(acceptorKey, acceptor);
return acceptor; return acceptor;
} }
@ -696,6 +744,16 @@ public class VehicleRoutingAlgorithms {
typedMap.put(acceptorKey, acceptor); typedMap.put(acceptorKey, acceptor);
return acceptor; return acceptor;
} }
if(acceptorName.equals("greedyAcceptance")){
GreedyAcceptance acceptor = new GreedyAcceptance(solutionMemory);
typedMap.put(acceptorKey, acceptor);
return acceptor;
}
if(acceptorName.equals("greedyAcceptance_minVehFirst")){
GreedyAcceptance_minVehFirst acceptor = new GreedyAcceptance_minVehFirst(solutionMemory);
typedMap.put(acceptorKey, acceptor);
return acceptor;
}
if(acceptorName.equals("schrimpfAcceptance")){ if(acceptorName.equals("schrimpfAcceptance")){
int iterOfSchrimpf = strategyConfig.getInt("acceptor.warmup"); int iterOfSchrimpf = strategyConfig.getInt("acceptor.warmup");
double alpha = strategyConfig.getDouble("acceptor.alpha"); double alpha = strategyConfig.getDouble("acceptor.alpha");
@ -704,6 +762,14 @@ public class VehicleRoutingAlgorithms {
typedMap.put(acceptorKey, schrimpf); typedMap.put(acceptorKey, schrimpf);
return schrimpf; return schrimpf;
} }
if(acceptorName.equals("experimentalSchrimpfAcceptance")){
int iterOfSchrimpf = strategyConfig.getInt("acceptor.warmup");
double alpha = strategyConfig.getDouble("acceptor.alpha");
ExperimentalSchrimpfAcceptance schrimpf = new ExperimentalSchrimpfAcceptance(solutionMemory, alpha, iterOfSchrimpf);
algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, schrimpf));
typedMap.put(acceptorKey, schrimpf);
return schrimpf;
}
else{ else{
throw new IllegalStateException("solution acceptor " + acceptorName + " is not known"); throw new IllegalStateException("solution acceptor " + acceptorName + " is not known");
} }
@ -735,7 +801,7 @@ public class VehicleRoutingAlgorithms {
} }
else if(ruin_name.equals("radialRuin")){ else if(ruin_name.equals("radialRuin")){
String ruin_distance = moduleConfig.getString("ruin.distance"); String ruin_distance = moduleConfig.getString("ruin.distance");
JobDistance jobDistance = new AvgJobDistance(vrp.getTransportCosts()); JobDistance jobDistance = new AvgServiceAndShipmentDistance(vrp.getTransportCosts());
// if(ruin_distance == null) jobDistance // if(ruin_distance == null) jobDistance
// else { // else {
// if(ruin_distance.equals("euclidean")){ // if(ruin_distance.equals("euclidean")){
@ -768,39 +834,40 @@ public class VehicleRoutingAlgorithms {
return rrModule; return rrModule;
} }
if(moduleName.equals("gendreau")){ if(moduleName.equals("gendreau")){
int iterations = moduleConfig.getInt("iterations"); throw new UnsupportedOperationException("gendreau is not supported yet");
double share = moduleConfig.getDouble("share"); // int iterations = moduleConfig.getInt("iterations");
String ruinName = moduleConfig.getString("ruin[@name]"); // double share = moduleConfig.getDouble("share");
if(ruinName == null) throw new IllegalStateException("gendreau.ruin[@name] is missing. set it to \"radialRuin\" or \"randomRuin\""); // String ruinName = moduleConfig.getString("ruin[@name]");
String ruinId = moduleConfig.getString("ruin[@id]"); // if(ruinName == null) throw new IllegalStateException("gendreau.ruin[@name] is missing. set it to \"radialRuin\" or \"randomRuin\"");
if(ruinId == null) ruinId = "noId"; // String ruinId = moduleConfig.getString("ruin[@id]");
ModKey ruinKey = makeKey(ruinName,ruinId); // if(ruinId == null) ruinId = "noId";
RuinStrategyKey stratKey = new RuinStrategyKey(ruinKey); // ModKey ruinKey = makeKey(ruinName,ruinId);
RuinStrategy ruin = definedClasses.get(stratKey); // RuinStrategyKey stratKey = new RuinStrategyKey(ruinKey);
if(ruin == null){ // RuinStrategy ruin = definedClasses.get(stratKey);
ruin = new RuinRadial(vrp, 0.3, new AvgJobDistance(vrp.getTransportCosts())); // if(ruin == null){
definedClasses.put(stratKey, ruin); // ruin = new RadialRuinStrategyFactory(0.3, new AvgJobDistance(vrp.getTransportCosts())).createStrategy(vrp);
} // definedClasses.put(stratKey, ruin);
// }
String insertionName = moduleConfig.getString("insertion[@name]"); //
if(insertionName == null) throw new IllegalStateException("gendreau.insertion[@name] is missing. set it to \"regretInsertion\" or \"bestInsertion\""); // String insertionName = moduleConfig.getString("insertion[@name]");
String insertionId = moduleConfig.getString("insertion[@id]"); // if(insertionName == null) throw new IllegalStateException("gendreau.insertion[@name] is missing. set it to \"regretInsertion\" or \"bestInsertion\"");
if(insertionId == null) insertionId = "noId"; // String insertionId = moduleConfig.getString("insertion[@id]");
ModKey insertionKey = makeKey(insertionName,insertionId); // if(insertionId == null) insertionId = "noId";
InsertionStrategyKey insertionStrategyKey = new InsertionStrategyKey(insertionKey); // ModKey insertionKey = makeKey(insertionName,insertionId);
InsertionStrategy insertion = definedClasses.get(insertionStrategyKey); // InsertionStrategyKey insertionStrategyKey = new InsertionStrategyKey(insertionKey);
if(insertion == null){ // InsertionStrategy insertion = definedClasses.get(insertionStrategyKey);
List<HierarchicalConfiguration> insertionConfigs = moduleConfig.configurationsAt("insertion"); // if(insertion == null){
if(insertionConfigs.size() != 1) throw new IllegalStateException("this should be 1"); // List<HierarchicalConfiguration> insertionConfigs = moduleConfig.configurationsAt("insertion");
List<PrioritizedVRAListener> prioListeners = new ArrayList<PrioritizedVRAListener>(); // if(insertionConfigs.size() != 1) throw new IllegalStateException("this should be 1");
insertion = createInsertionStrategy(insertionConfigs.get(0), vrp, vehicleFleetManager, routeStates, prioListeners, executorService, nuOfThreads, constraintManager); // List<PrioritizedVRAListener> prioListeners = new ArrayList<PrioritizedVRAListener>();
algorithmListeners.addAll(prioListeners); // insertion = createInsertionStrategy(insertionConfigs.get(0), vrp, vehicleFleetManager, routeStates, prioListeners, executorService, nuOfThreads, constraintManager);
} // algorithmListeners.addAll(prioListeners);
Gendreau gendreau = new Gendreau(vrp, ruin, insertion, vehicleFleetManager); // }
gendreau.setShareOfJobsToRuin(share); // Gendreau gendreau = new Gendreau(vrp, ruin, insertion, vehicleFleetManager);
gendreau.setNuOfIterations(iterations); // gendreau.setShareOfJobsToRuin(share);
definedClasses.put(strategyModuleKey, gendreau); // gendreau.setNuOfIterations(iterations);
return gendreau; // definedClasses.put(strategyModuleKey, gendreau);
// return gendreau;
} }
throw new NullPointerException("no module found with moduleName=" + moduleName + throw new NullPointerException("no module found with moduleName=" + moduleName +
"\n\tcheck config whether the correct names are used" + "\n\tcheck config whether the correct names are used" +
@ -815,7 +882,7 @@ public class VehicleRoutingAlgorithms {
RuinStrategyKey stratKey = new RuinStrategyKey(modKey); RuinStrategyKey stratKey = new RuinStrategyKey(modKey);
RuinStrategy ruin = definedClasses.get(stratKey); RuinStrategy ruin = definedClasses.get(stratKey);
if(ruin == null){ if(ruin == null){
ruin = new RuinRadial(vrp, shareToRuin, jobDistance); ruin = new RadialRuinStrategyFactory(shareToRuin, jobDistance).createStrategy(vrp);
definedClasses.put(stratKey, ruin); definedClasses.put(stratKey, ruin);
} }
return ruin; return ruin;
@ -825,7 +892,7 @@ public class VehicleRoutingAlgorithms {
RuinStrategyKey stratKey = new RuinStrategyKey(modKey); RuinStrategyKey stratKey = new RuinStrategyKey(modKey);
RuinStrategy ruin = definedClasses.get(stratKey); RuinStrategy ruin = definedClasses.get(stratKey);
if(ruin == null){ if(ruin == null){
ruin = new RuinRandom(vrp, shareToRuin); ruin = new RandomRuinStrategyFactory(shareToRuin).createStrategy(vrp);
definedClasses.put(stratKey, ruin); definedClasses.put(stratKey, ruin);
} }
return ruin; return ruin;

7
jsprit-core/src/main/java/basics/algo/AlgorithmEndsListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/AlgorithmEndsListener.java
View file

@ -14,12 +14,13 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;

9
jsprit-core/src/main/java/basics/algo/AlgorithmStartsListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/AlgorithmStartsListener.java
View file

@ -14,13 +14,14 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingAlgorithm; import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;

7
jsprit-core/src/main/java/basics/algo/IterationEndsListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/IterationEndsListener.java
View file

@ -14,12 +14,13 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;

7
jsprit-core/src/main/java/basics/algo/IterationStartsListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/IterationStartsListener.java
View file

@ -14,12 +14,13 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;

2
jsprit-core/src/main/java/basics/algo/SearchStrategyListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/SearchStrategyListener.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
public interface SearchStrategyListener extends VehicleRoutingAlgorithmListener{ public interface SearchStrategyListener extends VehicleRoutingAlgorithmListener{

2
jsprit-core/src/main/java/basics/algo/SearchStrategyModuleListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/SearchStrategyModuleListener.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
public interface SearchStrategyModuleListener extends VehicleRoutingAlgorithmListener{ public interface SearchStrategyModuleListener extends VehicleRoutingAlgorithmListener{

7
jsprit-core/src/main/java/basics/algo/StrategySelectedListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/StrategySelectedListener.java
View file

@ -14,12 +14,13 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
import java.util.Collection; import java.util.Collection;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;

2
jsprit-core/src/main/java/basics/algo/VehicleRoutingAlgorithmListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/VehicleRoutingAlgorithmListener.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
public interface VehicleRoutingAlgorithmListener { public interface VehicleRoutingAlgorithmListener {

9
jsprit-core/src/main/java/basics/algo/VehicleRoutingAlgorithmListeners.java → jsprit-core/src/main/java/jsprit/core/algorithm/listener/VehicleRoutingAlgorithmListeners.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.listener;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -23,9 +23,10 @@ import java.util.Comparator;
import java.util.List; import java.util.List;
import java.util.TreeSet; import java.util.TreeSet;
import basics.VehicleRoutingAlgorithm; import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
import basics.VehicleRoutingProblemSolution; import jsprit.core.problem.solution.VehicleRoutingProblemSolution;

224
jsprit-core/src/main/java/jsprit/core/algorithm/module/Gendreau.java Normal file
View file

@ -0,0 +1,224 @@
///*******************************************************************************
// * Copyright (C) 2013 Stefan Schroeder
// *
// * This library is free software; you can redistribute it and/or
// * modify it under the terms of the GNU Lesser General Public
// * License as published by the Free Software Foundation; either
// * version 3.0 of the License, or (at your option) any later version.
// *
// * This library is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// * Lesser General Public License for more details.
// *
// * You should have received a copy of the GNU Lesser General Public
// * License along with this library. If not, see <http://www.gnu.org/licenses/>.
// ******************************************************************************/
//package jsprit.core.algorithm.module;
//
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.Collection;
//import java.util.Collections;
//import java.util.HashSet;
//import java.util.List;
//import java.util.Random;
//import java.util.Set;
//
//import jsprit.core.algorithm.SearchStrategyModule;
//import jsprit.core.algorithm.listener.SearchStrategyModuleListener;
//import jsprit.core.algorithm.recreate.InsertionStrategy;
//import jsprit.core.algorithm.recreate.listener.InsertionListener;
//import jsprit.core.algorithm.recreate.listener.InsertionListeners;
//import jsprit.core.algorithm.ruin.RuinStrategy;
//import jsprit.core.algorithm.ruin.listener.RuinListener;
//import jsprit.core.problem.Job;
//import jsprit.core.problem.VehicleRoutingProblem;
//import jsprit.core.problem.VehicleRoutingProblemSolution;
//import jsprit.core.problem.route.TourActivity;
//import jsprit.core.problem.route.TourActivity.JobActivity;
//import jsprit.core.problem.route.VehicleFleetManager;
//import jsprit.core.problem.route.VehicleRoute;
//import jsprit.core.util.RandomNumberGeneration;
//
//import org.apache.log4j.Logger;
//
//
//final class Gendreau implements SearchStrategyModule{
//
// private final static Logger log = Logger.getLogger(Gendreau.class);
//
// private final static String NAME = "gendreauPostOpt";
//
// private final RuinStrategy ruin;
//
// private final VehicleRoutingProblem vrp;
//
// private final InsertionStrategy insertionStrategy;
//
// private VehicleFleetManager fleetManager;
//
// private Random random = RandomNumberGeneration.getRandom();
//
// private int nOfIterations = 10;
//
// private double shareOfJobsToRuin = 0.15;
//
// public void setShareOfJobsToRuin(double shareOfJobsToRuin) {
// this.shareOfJobsToRuin = shareOfJobsToRuin;
// }
//
// public Gendreau(VehicleRoutingProblem vrp, RuinStrategy ruin, InsertionStrategy insertionStrategy, VehicleFleetManager vehicleFleetManager) {
// super();
// InsertionListeners insertionListeners = new InsertionListeners();
// insertionListeners.addAllListeners(insertionStrategy.getListeners());
// new Inserter(insertionListeners);
// this.ruin = ruin;
// this.vrp = vrp;
// this.insertionStrategy = insertionStrategy;
// this.fleetManager = vehicleFleetManager;
// }
//
// @Override
// public String toString() {
// return "[name=gendreau][iterations="+nOfIterations+"][share2ruin="+shareOfJobsToRuin+"]";
// }
//
// public void setRandom(Random random) {
// this.random = random;
// }
//
//
// public void setNuOfIterations(int nOfIterations) {
// this.nOfIterations = nOfIterations;
// }
//
//// public void setFleetManager(VehicleFleetManager vehicleFleetManager) {
//// this.fleetManager = vehicleFleetManager;
////
//// }
//
// @Override
// public VehicleRoutingProblemSolution runAndGetSolution(VehicleRoutingProblemSolution vrpSolution) {
//// log.info("run gendreau postopt");
// VehicleRoutingProblemSolution bestSolution = vrpSolution;
// int itersWithoutImprovement = 0;
//
// for(int i=0;i<nOfIterations;i++){
// List<VehicleRoute> copiedRoutes = copyRoutes(bestSolution.getRoutes());
// iniFleet(copiedRoutes);
//
// VehicleRoute route2split = pickRouteThatHasAtLeastTwoJobs(copiedRoutes);
// if(route2split == null) continue;
// List<Job> jobsInRoute = getJobs(route2split);
// Set<Job> unassignedJobs = new HashSet<Job>();
// unassignedJobs.addAll(jobsInRoute);
// copiedRoutes.remove(route2split);
//
// Collections.shuffle(jobsInRoute,random);
// Job targetJob = jobsInRoute.get(0);
// int nOfJobs2BeRemovedAdditionally = (int) (shareOfJobsToRuin*(double)vrp.getJobs().size());
// Collection<Job> unassignedJobsList = ruin.ruin(copiedRoutes, targetJob, nOfJobs2BeRemovedAdditionally);
// unassignedJobs.addAll(unassignedJobsList);
//
// VehicleRoute emptyRoute1 = VehicleRoute.emptyRoute();
// copiedRoutes.add(emptyRoute1);
// insertionStrategy.insertJobs(Arrays.asList(emptyRoute1), Arrays.asList(targetJob));
//
// unassignedJobs.remove(targetJob);
//
// VehicleRoute emptyRoute2 = VehicleRoute.emptyRoute();
// copiedRoutes.add(emptyRoute2);
// Job job2 = jobsInRoute.get(1);
// insertionStrategy.insertJobs(Arrays.asList(emptyRoute2), Arrays.asList(job2));
//
// unassignedJobs.remove(job2);
//
// insertionStrategy.insertJobs(copiedRoutes, unassignedJobs);
// double cost = getCost(copiedRoutes);
//
// if(cost < bestSolution.getCost()){
//// log.info("BING - new: " + cost + " old: " + bestSolution.getCost());
// bestSolution = new VehicleRoutingProblemSolution(copiedRoutes, cost);
// itersWithoutImprovement=0;
// }
// else{
// itersWithoutImprovement++;
// if(itersWithoutImprovement > 200){
//// log.info("BREAK i="+i);
// break;
// }
// }
// }
// return bestSolution;
// }
//
// private List<VehicleRoute> copyRoutes(Collection<VehicleRoute> routes) {
// List<VehicleRoute> routeList = new ArrayList<VehicleRoute>();
// for(VehicleRoute r : routes){
// routeList.add(VehicleRoute.copyOf(r));
// }
// return routeList;
// }
//
// private void iniFleet(Collection<VehicleRoute> routes) {
// fleetManager.unlockAll();
// for(VehicleRoute route : routes){
// if(!route.isEmpty()){
// fleetManager.lock(route.getVehicle());
// }
// }
// }
//
// private double getCost(Collection<VehicleRoute> routes) {
// double c = 0.0;
// for(VehicleRoute r : routes){
// c+=r.getCost();
// }
// return c;
// }
//
// private List<Job> getJobs(VehicleRoute route2split) {
// Set<Job> jobs = new HashSet<Job>();
// for(TourActivity act : route2split.getTourActivities().getActivities()){
// if(act instanceof JobActivity){
// jobs.add(((JobActivity) act).getJob());
// }
// }
// return new ArrayList<Job>(jobs);
// }
//
// private VehicleRoute pickRouteThatHasAtLeastTwoJobs(Collection<VehicleRoute> routeList) {
// List<VehicleRoute> routes = new ArrayList<VehicleRoute>();
// for(VehicleRoute r : routeList){
// if(getJobs(r).size() > 1){
// routes.add(r);
// }
// }
// if(routes.isEmpty()) return null;
// Collections.shuffle(routes,random);
// return routes.get(0);
// }
//
// @Override
// public String getName() {
// return NAME;
// }
//
// @Override
// public void addModuleListener(SearchStrategyModuleListener moduleListener) {
// if(moduleListener instanceof InsertionListener){
// InsertionListener iListener = (InsertionListener) moduleListener;
// if(!insertionStrategy.getListeners().contains(iListener)){
// insertionStrategy.addListener(iListener);
// }
// }
// if(moduleListener instanceof RuinListener){
// RuinListener rListener = (RuinListener) moduleListener;
// if(!ruin.getListeners().contains(rListener)){
// ruin.addListener(rListener);
// }
// }
//
// }
//}

17
jsprit-core/src/main/java/algorithms/RuinAndRecreateModule.java → jsprit-core/src/main/java/jsprit/core/algorithm/module/RuinAndRecreateModule.java
View file

@ -14,16 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.module;
import java.util.Collection; import java.util.Collection;
import basics.Job; import jsprit.core.algorithm.SearchStrategyModule;
import basics.VehicleRoutingProblemSolution; import jsprit.core.algorithm.listener.SearchStrategyModuleListener;
import basics.algo.InsertionListener; import jsprit.core.algorithm.recreate.InsertionStrategy;
import basics.algo.RuinListener; import jsprit.core.algorithm.recreate.listener.InsertionListener;
import basics.algo.SearchStrategyModule; import jsprit.core.algorithm.ruin.RuinStrategy;
import basics.algo.SearchStrategyModuleListener; import jsprit.core.algorithm.ruin.listener.RuinListener;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
public class RuinAndRecreateModule implements SearchStrategyModule{ public class RuinAndRecreateModule implements SearchStrategyModule{

7
jsprit-core/src/main/java/algorithms/ActivityInsertionCostsCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ActivityInsertionCostsCalculator.java
View file

@ -18,9 +18,10 @@
* Contributors: * Contributors:
* Stefan Schroeder - initial API and implementation * Stefan Schroeder - initial API and implementation
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import basics.route.TourActivity; import jsprit.core.problem.misc.JobInsertionContext;
import jsprit.core.problem.solution.route.activity.TourActivity;
public interface ActivityInsertionCostsCalculator { public interface ActivityInsertionCostsCalculator {
@ -50,6 +51,6 @@ public interface ActivityInsertionCostsCalculator {
} }
public ActivityInsertionCosts getCosts(InsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct); public ActivityInsertionCosts getCosts(JobInsertionContext iContext, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct);
} }

13
jsprit-core/src/main/java/algorithms/AuxilliaryCostCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/AuxilliaryCostCalculator.java
View file

@ -14,16 +14,17 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
import basics.costs.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
import basics.costs.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import basics.route.Driver; import jsprit.core.problem.driver.Driver;
import basics.route.TourActivity; import jsprit.core.problem.solution.route.activity.TourActivity;
import basics.route.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
final class AuxilliaryCostCalculator { final class AuxilliaryCostCalculator {

18
jsprit-core/src/main/java/algorithms/BestInsertion.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/BestInsertion.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -22,15 +22,17 @@ import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Random; import java.util.Random;
import jsprit.core.algorithm.recreate.InsertionData.NoInsertionFound;
import jsprit.core.algorithm.recreate.listener.InsertionListener;
import jsprit.core.algorithm.recreate.listener.InsertionListeners;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.util.RandomNumberGeneration;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.RandomNumberGeneration;
import algorithms.InsertionData.NoInsertionFound;
import basics.Job;
import basics.algo.InsertionListener;
import basics.route.Driver;
import basics.route.Vehicle;
import basics.route.VehicleRoute;

34
jsprit-core/src/main/java/algorithms/BestInsertionBuilder.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/BestInsertionBuilder.java
View file

@ -1,13 +1,16 @@
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import basics.VehicleRoutingProblem; import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
import basics.algo.InsertionListener; import jsprit.core.algorithm.recreate.listener.InsertionListener;
import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener; import jsprit.core.algorithm.state.StateManager;
import basics.route.VehicleFleetManager; import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.constraint.ConstraintManager;
import jsprit.core.problem.vehicle.VehicleFleetManager;
public class BestInsertionBuilder { public class BestInsertionBuilder {
@ -34,6 +37,12 @@ public class BestInsertionBuilder {
private ExecutorService executor; private ExecutorService executor;
private int nuOfThreads; private int nuOfThreads;
private double timeSlice;
private int nNeighbors;
private boolean timeScheduling=false;
public BestInsertionBuilder(VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, StateManager stateManager, ConstraintManager constraintManager) { public BestInsertionBuilder(VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, StateManager stateManager, ConstraintManager constraintManager) {
super(); super();
@ -92,6 +101,9 @@ public class BestInsertionBuilder {
if(considerFixedCosts) { if(considerFixedCosts) {
calcBuilder.considerFixedCosts(weightOfFixedCosts); calcBuilder.considerFixedCosts(weightOfFixedCosts);
} }
if(timeScheduling){
calcBuilder.experimentalTimeScheduler(timeSlice, nNeighbors);
}
JobInsertionCostsCalculator jobInsertions = calcBuilder.build(); JobInsertionCostsCalculator jobInsertions = calcBuilder.build();
InsertionStrategy bestInsertion; InsertionStrategy bestInsertion;
if(executor == null){ if(executor == null){
@ -107,6 +119,18 @@ public class BestInsertionBuilder {
return bestInsertion; return bestInsertion;
} }
/**
* @deprecated this is experimental and can disappear.
* @param parseDouble
* @param parseInt
*/
@Deprecated
public void experimentalTimeScheduler(double timeSlice, int nNeighbors) {
this.timeSlice=timeSlice;
this.nNeighbors=nNeighbors;
timeScheduling=true;
}

20
jsprit-core/src/main/java/algorithms/BestInsertionConcurrent.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/BestInsertionConcurrent.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -27,15 +27,17 @@ import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future; import java.util.concurrent.Future;
import jsprit.core.algorithm.recreate.InsertionData.NoInsertionFound;
import jsprit.core.algorithm.recreate.listener.InsertionListener;
import jsprit.core.algorithm.recreate.listener.InsertionListeners;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.util.RandomNumberGeneration;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.RandomNumberGeneration;
import algorithms.InsertionData.NoInsertionFound;
import basics.Job;
import basics.algo.InsertionListener;
import basics.route.Driver;
import basics.route.Vehicle;
import basics.route.VehicleRoute;
@ -170,7 +172,7 @@ final class BestInsertionConcurrent implements InsertionStrategy{
bestInsertion = new Insertion(newRoute,newIData); bestInsertion = new Insertion(newRoute,newIData);
bestInsertionCost = newIData.getInsertionCost(); bestInsertionCost = newIData.getInsertionCost();
vehicleRoutes.add(newRoute); vehicleRoutes.add(newRoute);
batches.get(0).routes.add(newRoute); batches.get(random.nextInt(batches.size())).routes.add(newRoute);
} }
} }

11
jsprit-core/src/main/java/algorithms/CalculatesServiceInsertionWithTimeScheduling.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/CalculatesServiceInsertionWithTimeScheduling.java
View file

@ -14,18 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Random; import java.util.Random;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.vehicle.Vehicle;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import basics.Job;
import basics.route.Driver;
import basics.route.Vehicle;
import basics.route.VehicleRoute;
class CalculatesServiceInsertionWithTimeScheduling implements JobInsertionCostsCalculator{ class CalculatesServiceInsertionWithTimeScheduling implements JobInsertionCostsCalculator{

35
jsprit-core/src/main/java/algorithms/CalculatorBuilder.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/CalculatorBuilder.java
View file

@ -14,20 +14,23 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import basics.Delivery; import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
import basics.Job; import jsprit.core.algorithm.recreate.listener.InsertionListener;
import basics.Pickup; import jsprit.core.problem.VehicleRoutingProblem;
import basics.Service; import jsprit.core.problem.constraint.ConstraintManager;
import basics.Shipment; import jsprit.core.problem.job.Delivery;
import basics.VehicleRoutingProblem; import jsprit.core.problem.job.Job;
import basics.algo.InsertionListener; import jsprit.core.problem.job.Pickup;
import basics.algo.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener; import jsprit.core.problem.job.Service;
import basics.route.VehicleFleetManager; import jsprit.core.problem.job.Shipment;
import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
import jsprit.core.problem.vehicle.VehicleFleetManager;
@ -64,7 +67,7 @@ class CalculatorBuilder {
private VehicleRoutingProblem vrp; private VehicleRoutingProblem vrp;
private StateGetter states; private RouteAndActivityStateGetter states;
private boolean local = true; private boolean local = true;
@ -109,7 +112,7 @@ class CalculatorBuilder {
* *
* @return * @return
*/ */
public CalculatorBuilder setStates(StateGetter states){ public CalculatorBuilder setStates(RouteAndActivityStateGetter states){
this.states = states; this.states = states;
return this; return this;
} }
@ -235,7 +238,7 @@ class CalculatorBuilder {
} }
} }
private CalculatorPlusListeners createStandardLocal(VehicleRoutingProblem vrp, StateGetter statesManager){ private CalculatorPlusListeners createStandardLocal(VehicleRoutingProblem vrp, RouteAndActivityStateGetter statesManager){
if(constraintManager == null) throw new IllegalStateException("constraint-manager is null"); if(constraintManager == null) throw new IllegalStateException("constraint-manager is null");
@ -263,7 +266,7 @@ class CalculatorBuilder {
return calcPlusListeners; return calcPlusListeners;
} }
private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCostsCalculator baseCalculator, StateGetter activityStates2, double weightOfFixedCosts){ private CalculatorPlusListeners createCalculatorConsideringFixedCosts(VehicleRoutingProblem vrp, JobInsertionCostsCalculator baseCalculator, RouteAndActivityStateGetter activityStates2, double weightOfFixedCosts){
final JobInsertionConsideringFixCostsCalculator withFixCost = new JobInsertionConsideringFixCostsCalculator(baseCalculator, activityStates2); final JobInsertionConsideringFixCostsCalculator withFixCost = new JobInsertionConsideringFixCostsCalculator(baseCalculator, activityStates2);
withFixCost.setWeightOfFixCost(weightOfFixedCosts); withFixCost.setWeightOfFixCost(weightOfFixedCosts);
CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(withFixCost); CalculatorPlusListeners calcPlusListeners = new CalculatorPlusListeners(withFixCost);
@ -271,7 +274,7 @@ class CalculatorBuilder {
return calcPlusListeners; return calcPlusListeners;
} }
private CalculatorPlusListeners createStandardRoute(VehicleRoutingProblem vrp, StateGetter activityStates2, int forwardLooking, int solutionMemory){ private CalculatorPlusListeners createStandardRoute(VehicleRoutingProblem vrp, RouteAndActivityStateGetter activityStates2, int forwardLooking, int solutionMemory){
int after = forwardLooking; int after = forwardLooking;
ActivityInsertionCostsCalculator routeLevelCostEstimator; ActivityInsertionCostsCalculator routeLevelCostEstimator;
if(activityInsertionCostCalculator == null){ if(activityInsertionCostCalculator == null){
@ -289,7 +292,7 @@ class CalculatorBuilder {
return calcPlusListener; return calcPlusListener;
} }
private JobInsertionCostsCalculator createFinalInsertion(VehicleFleetManager fleetManager, JobInsertionCostsCalculator baseCalc, StateGetter activityStates2){ private JobInsertionCostsCalculator createFinalInsertion(VehicleFleetManager fleetManager, JobInsertionCostsCalculator baseCalc, RouteAndActivityStateGetter activityStates2){
return new VehicleTypeDependentJobInsertionCalculator(fleetManager, baseCalc); return new VehicleTypeDependentJobInsertionCalculator(fleetManager, baseCalc);
} }

13
jsprit-core/src/main/java/algorithms/ConfigureFixCostCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ConfigureFixCostCalculator.java
View file

@ -14,18 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.Collection; import java.util.Collection;
import jsprit.core.algorithm.recreate.listener.InsertionStartsListener;
import jsprit.core.algorithm.recreate.listener.JobInsertedListener;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import basics.Job;
import basics.VehicleRoutingProblem;
import basics.algo.InsertionStartsListener;
import basics.algo.JobInsertedListener;
import basics.route.VehicleRoute;

23
jsprit-core/src/main/java/algorithms/Inserter.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/Inserter.java
View file

@ -14,18 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import algorithms.InsertionData.NoInsertionFound; import jsprit.core.algorithm.recreate.InsertionData.NoInsertionFound;
import basics.Job; import jsprit.core.algorithm.recreate.listener.InsertionListeners;
import basics.Service; import jsprit.core.problem.job.Job;
import basics.Shipment; import jsprit.core.problem.job.Service;
import basics.route.DefaultShipmentActivityFactory; import jsprit.core.problem.job.Shipment;
import basics.route.DefaultTourActivityFactory; import jsprit.core.problem.solution.route.VehicleRoute;
import basics.route.TourActivity; import jsprit.core.problem.solution.route.activity.DefaultShipmentActivityFactory;
import basics.route.TourActivityFactory; import jsprit.core.problem.solution.route.activity.DefaultTourActivityFactory;
import basics.route.TourShipmentActivityFactory; import jsprit.core.problem.solution.route.activity.TourActivity;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.activity.TourActivityFactory;
import jsprit.core.problem.solution.route.activity.TourShipmentActivityFactory;
class Inserter { class Inserter {

6
jsprit-core/src/main/java/algorithms/InsertionData.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/InsertionData.java
View file

@ -14,10 +14,10 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import basics.route.Driver; import jsprit.core.problem.driver.Driver;
import basics.route.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
/** /**
* Data object that collects insertion information. It collects insertionCosts, insertionIndeces, vehicle and driver to be employed * Data object that collects insertion information. It collects insertionCosts, insertionIndeces, vehicle and driver to be employed

9
jsprit-core/src/main/java/algorithms/InsertionStrategy.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/InsertionStrategy.java
View file

@ -14,13 +14,14 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.Collection; import java.util.Collection;
import basics.Job; import jsprit.core.algorithm.recreate.listener.InsertionListener;
import basics.algo.InsertionListener; import jsprit.core.problem.job.Job;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;

4
jsprit-core/src/main/java/algorithms/InsertionStrategyFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/InsertionStrategyFactory.java
View file

@ -14,9 +14,9 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
public interface InsertionStrategyFactory { public interface InsertionStrategyFactory {

13
jsprit-core/src/main/java/algorithms/JobCalculatorSwitcher.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobCalculatorSwitcher.java
View file

@ -1,14 +1,15 @@
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import basics.Job; import jsprit.core.problem.driver.Driver;
import basics.route.Driver; import jsprit.core.problem.job.Job;
import basics.route.Vehicle; import jsprit.core.problem.solution.route.VehicleRoute;
import basics.route.VehicleRoute; import jsprit.core.problem.vehicle.Vehicle;
public class JobCalculatorSwitcher implements JobInsertionCostsCalculator{
class JobCalculatorSwitcher implements JobInsertionCostsCalculator{
private Map<Class<? extends Job>,JobInsertionCostsCalculator> calcMap = new HashMap<Class<? extends Job>, JobInsertionCostsCalculator>(); private Map<Class<? extends Job>,JobInsertionCostsCalculator> calcMap = new HashMap<Class<? extends Job>, JobInsertionCostsCalculator>();

21
jsprit-core/src/main/java/algorithms/JobInsertionConsideringFixCostsCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionConsideringFixCostsCalculator.java
View file

@ -14,16 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import jsprit.core.algorithm.recreate.InsertionData.NoInsertionFound;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl.NoVehicle;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import algorithms.InsertionData.NoInsertionFound;
import basics.Job;
import basics.route.Driver;
import basics.route.Vehicle;
import basics.route.VehicleImpl.NoVehicle;
import basics.route.VehicleRoute;
@ -37,9 +40,9 @@ final class JobInsertionConsideringFixCostsCalculator implements JobInsertionCos
private double solution_completeness_ratio = 0.5; private double solution_completeness_ratio = 0.5;
private StateGetter stateGetter; private RouteAndActivityStateGetter stateGetter;
public JobInsertionConsideringFixCostsCalculator(final JobInsertionCostsCalculator standardInsertionCalculator, StateGetter stateGetter) { public JobInsertionConsideringFixCostsCalculator(final JobInsertionCostsCalculator standardInsertionCalculator, RouteAndActivityStateGetter stateGetter) {
super(); super();
this.standardServiceInsertion = standardInsertionCalculator; this.standardServiceInsertion = standardInsertionCalculator;
this.stateGetter = stateGetter; this.stateGetter = stateGetter;

10
jsprit-core/src/main/java/algorithms/JobInsertionCostsCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/JobInsertionCostsCalculator.java
View file

@ -14,12 +14,12 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import basics.Job; import jsprit.core.problem.driver.Driver;
import basics.route.Driver; import jsprit.core.problem.job.Job;
import basics.route.Vehicle; import jsprit.core.problem.solution.route.VehicleRoute;
import basics.route.VehicleRoute; import jsprit.core.problem.vehicle.Vehicle;
public interface JobInsertionCostsCalculator { public interface JobInsertionCostsCalculator {

14
jsprit-core/src/main/java/algorithms/LocalActivityInsertionCostsCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/LocalActivityInsertionCostsCalculator.java
View file

@ -18,11 +18,13 @@
* Contributors: * Contributors:
* Stefan Schroeder - initial API and implementation * Stefan Schroeder - initial API and implementation
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import basics.costs.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
import basics.costs.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import basics.route.TourActivity; import jsprit.core.problem.misc.JobInsertionContext;
import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.util.CalculationUtils;
/** /**
* Calculates activity insertion costs locally, i.e. by comparing the additional costs of insertion the new activity k between * Calculates activity insertion costs locally, i.e. by comparing the additional costs of insertion the new activity k between
@ -34,7 +36,7 @@ import basics.route.TourActivity;
* @author stefan * @author stefan
* *
*/ */
public class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCalculator{ class LocalActivityInsertionCostsCalculator implements ActivityInsertionCostsCalculator{
private VehicleRoutingTransportCosts routingCosts; private VehicleRoutingTransportCosts routingCosts;
@ -48,7 +50,7 @@ public class LocalActivityInsertionCostsCalculator implements ActivityInsertionC
} }
@Override @Override
public ActivityInsertionCosts getCosts(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) { public ActivityInsertionCosts getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) {
double tp_costs_prevAct_newAct = routingCosts.getTransportCost(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double tp_costs_prevAct_newAct = routingCosts.getTransportCost(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());
double tp_time_prevAct_newAct = routingCosts.getTransportTime(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle()); double tp_time_prevAct_newAct = routingCosts.getTransportTime(prevAct.getLocationId(), newAct.getLocationId(), depTimeAtPrevAct, iFacts.getNewDriver(), iFacts.getNewVehicle());

1
jsprit-core/src/main/java/algorithms/ParRegretInsertion.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ParRegretInsertion.java
View file

@ -1,3 +1,4 @@
package jsprit.core.algorithm.recreate;
/******************************************************************************* /*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder * Copyright (C) 2013 Stefan Schroeder
* *

1
jsprit-core/src/main/java/algorithms/RegretInsertion.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/RegretInsertion.java
View file

@ -1,3 +1,4 @@
package jsprit.core.algorithm.recreate;
/******************************************************************************* /*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder * Copyright (C) 2013 Stefan Schroeder
* *

24
jsprit-core/src/main/java/algorithms/RouteLevelActivityInsertionCostsEstimator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/RouteLevelActivityInsertionCostsEstimator.java
View file

@ -18,17 +18,21 @@
* Contributors: * Contributors:
* Stefan Schroeder - initial API and implementation * Stefan Schroeder - initial API and implementation
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import basics.costs.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
import basics.costs.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import basics.route.End; import jsprit.core.problem.misc.JobInsertionContext;
import basics.route.Start; import jsprit.core.problem.solution.route.VehicleRoute;
import basics.route.TourActivity; import jsprit.core.problem.solution.route.activity.End;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.activity.Start;
import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
import jsprit.core.problem.solution.route.state.StateFactory;
class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCostsCalculator{ class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCostsCalculator{
@ -36,11 +40,11 @@ class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCost
private AuxilliaryCostCalculator auxilliaryPathCostCalculator; private AuxilliaryCostCalculator auxilliaryPathCostCalculator;
private StateGetter stateManager; private RouteAndActivityStateGetter stateManager;
private int nuOfActivities2LookForward = 0; private int nuOfActivities2LookForward = 0;
public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, StateGetter stateManager) { public RouteLevelActivityInsertionCostsEstimator(VehicleRoutingTransportCosts routingCosts, VehicleRoutingActivityCosts actCosts, RouteAndActivityStateGetter stateManager) {
super(); super();
this.activityCosts = actCosts; this.activityCosts = actCosts;
this.stateManager = stateManager; this.stateManager = stateManager;
@ -48,7 +52,7 @@ class RouteLevelActivityInsertionCostsEstimator implements ActivityInsertionCost
} }
@Override @Override
public ActivityInsertionCosts getCosts(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) { public ActivityInsertionCosts getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double depTimeAtPrevAct) {
List<TourActivity> path = new ArrayList<TourActivity>(); List<TourActivity> path = new ArrayList<TourActivity>();
path.add(prevAct); path.add(newAct); path.add(nextAct); path.add(prevAct); path.add(newAct); path.add(nextAct);
int actIndex; int actIndex;

41
jsprit-core/src/main/java/algorithms/ServiceInsertionCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ServiceInsertionCalculator.java
View file

@ -14,25 +14,30 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import jsprit.core.algorithm.recreate.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
import jsprit.core.problem.constraint.HardActivityStateLevelConstraint;
import jsprit.core.problem.constraint.HardActivityStateLevelConstraint.ConstraintsStatus;
import jsprit.core.problem.constraint.HardRouteStateLevelConstraint;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Service;
import jsprit.core.problem.misc.JobInsertionContext;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.DefaultTourActivityFactory;
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.TourActivityFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl.NoVehicle;
import jsprit.core.util.CalculationUtils;
import jsprit.core.util.Neighborhood;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.Neighborhood;
import algorithms.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
import algorithms.HardActivityStateLevelConstraint.ConstraintsStatus;
import basics.Job;
import basics.Service;
import basics.costs.VehicleRoutingTransportCosts;
import basics.route.DefaultTourActivityFactory;
import basics.route.Driver;
import basics.route.End;
import basics.route.Start;
import basics.route.TourActivity;
import basics.route.TourActivityFactory;
import basics.route.Vehicle;
import basics.route.VehicleImpl.NoVehicle;
import basics.route.VehicleRoute;
@ -89,7 +94,7 @@ final class ServiceInsertionCalculator implements JobInsertionCostsCalculator{
if(jobToInsert == null) throw new IllegalStateException("jobToInsert is missing."); if(jobToInsert == null) throw new IllegalStateException("jobToInsert is missing.");
if(newVehicle == null || newVehicle instanceof NoVehicle) throw new IllegalStateException("newVehicle is missing."); if(newVehicle == null || newVehicle instanceof NoVehicle) throw new IllegalStateException("newVehicle is missing.");
InsertionContext insertionContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, newVehicleDepartureTime); JobInsertionContext insertionContext = new JobInsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, newVehicleDepartureTime);
if(!hardRouteLevelConstraint.fulfilled(insertionContext)){ if(!hardRouteLevelConstraint.fulfilled(insertionContext)){
return InsertionData.createEmptyInsertionData(); return InsertionData.createEmptyInsertionData();
} }
@ -155,7 +160,7 @@ final class ServiceInsertionCalculator implements JobInsertionCostsCalculator{
return insertionData; return insertionData;
} }
public ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double departureTimeAtPrevAct) { public ActivityInsertionCosts calculate(JobInsertionContext iFacts, TourActivity prevAct, TourActivity nextAct, TourActivity newAct, double departureTimeAtPrevAct) {
return activityInsertionCostsCalculator.getCosts(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct); return activityInsertionCostsCalculator.getCosts(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct);
} }
} }

48
jsprit-core/src/main/java/algorithms/ServiceInsertionOnRouteLevelCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ServiceInsertionOnRouteLevelCalculator.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Comparator; import java.util.Comparator;
@ -23,25 +23,31 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.PriorityQueue; import java.util.PriorityQueue;
import jsprit.core.algorithm.recreate.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
import jsprit.core.problem.constraint.HardActivityStateLevelConstraint;
import jsprit.core.problem.constraint.HardActivityStateLevelConstraint.ConstraintsStatus;
import jsprit.core.problem.constraint.HardRouteStateLevelConstraint;
import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Service;
import jsprit.core.problem.misc.JobInsertionContext;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.DefaultTourActivityFactory;
import jsprit.core.problem.solution.route.activity.End;
import jsprit.core.problem.solution.route.activity.Start;
import jsprit.core.problem.solution.route.activity.TourActivities;
import jsprit.core.problem.solution.route.activity.TourActivity;
import jsprit.core.problem.solution.route.activity.TourActivityFactory;
import jsprit.core.problem.solution.route.state.RouteAndActivityStateGetter;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl.NoVehicle;
import jsprit.core.util.Neighborhood;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.Neighborhood;
import algorithms.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
import algorithms.HardActivityStateLevelConstraint.ConstraintsStatus;
import basics.Job;
import basics.Service;
import basics.costs.VehicleRoutingActivityCosts;
import basics.costs.VehicleRoutingTransportCosts;
import basics.route.DefaultTourActivityFactory;
import basics.route.Driver;
import basics.route.End;
import basics.route.Start;
import basics.route.TourActivities;
import basics.route.TourActivity;
import basics.route.TourActivityFactory;
import basics.route.Vehicle;
import basics.route.VehicleImpl.NoVehicle;
import basics.route.VehicleRoute;
@ -57,7 +63,7 @@ final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCostsC
private TourActivityFactory tourActivityFactory = new DefaultTourActivityFactory(); private TourActivityFactory tourActivityFactory = new DefaultTourActivityFactory();
private StateGetter stateManager; private RouteAndActivityStateGetter stateManager;
private HardRouteStateLevelConstraint hardRouteLevelConstraint; private HardRouteStateLevelConstraint hardRouteLevelConstraint;
@ -108,7 +114,7 @@ final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCostsC
} }
public void setStates(StateGetter stateManager){ public void setStates(RouteAndActivityStateGetter stateManager){
this.stateManager = stateManager; this.stateManager = stateManager;
} }
@ -135,7 +141,7 @@ final class ServiceInsertionOnRouteLevelCalculator implements JobInsertionCostsC
if(jobToInsert == null) throw new IllegalStateException("job is null. cannot calculate the insertion of a null-job."); if(jobToInsert == null) throw new IllegalStateException("job is null. cannot calculate the insertion of a null-job.");
if(newVehicle == null || newVehicle instanceof NoVehicle) throw new IllegalStateException("no vehicle given. set para vehicle!"); if(newVehicle == null || newVehicle instanceof NoVehicle) throw new IllegalStateException("no vehicle given. set para vehicle!");
InsertionContext insertionContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, newVehicleDepartureTime); JobInsertionContext insertionContext = new JobInsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, newVehicleDepartureTime);
if(!hardRouteLevelConstraint.fulfilled(insertionContext)){ if(!hardRouteLevelConstraint.fulfilled(insertionContext)){
return InsertionData.createEmptyInsertionData(); return InsertionData.createEmptyInsertionData();
} }

41
jsprit-core/src/main/java/algorithms/ShipmentInsertionCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculator.java
View file

@ -14,27 +14,32 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.List; import java.util.List;
import jsprit.core.algorithm.recreate.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
import jsprit.core.problem.constraint.HardActivityStateLevelConstraint;
import jsprit.core.problem.constraint.HardActivityStateLevelConstraint.ConstraintsStatus;
import jsprit.core.problem.constraint.HardRouteStateLevelConstraint;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Shipment;
import jsprit.core.problem.misc.JobInsertionContext;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.DefaultShipmentActivityFactory;
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.TourShipmentActivityFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl.NoVehicle;
import jsprit.core.util.CalculationUtils;
import jsprit.core.util.Neighborhood;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.Neighborhood;
import algorithms.ActivityInsertionCostsCalculator.ActivityInsertionCosts;
import algorithms.HardActivityStateLevelConstraint.ConstraintsStatus;
import basics.Job;
import basics.Shipment;
import basics.costs.VehicleRoutingTransportCosts;
import basics.route.DefaultShipmentActivityFactory;
import basics.route.Driver;
import basics.route.End;
import basics.route.Start;
import basics.route.TourActivity;
import basics.route.TourShipmentActivityFactory;
import basics.route.Vehicle;
import basics.route.VehicleImpl.NoVehicle;
import basics.route.VehicleRoute;
@ -91,7 +96,7 @@ final class ShipmentInsertionCalculator implements JobInsertionCostsCalculator{
if(newVehicle == null || newVehicle instanceof NoVehicle) throw new IllegalStateException("newVehicle is missing."); if(newVehicle == null || newVehicle instanceof NoVehicle) throw new IllegalStateException("newVehicle is missing.");
if(!(jobToInsert instanceof Shipment)) throw new IllegalStateException("jobToInsert should be of type Shipment!"); if(!(jobToInsert instanceof Shipment)) throw new IllegalStateException("jobToInsert should be of type Shipment!");
InsertionContext insertionContext = new InsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, newVehicleDepartureTime); JobInsertionContext insertionContext = new JobInsertionContext(currentRoute, jobToInsert, newVehicle, newDriver, newVehicleDepartureTime);
if(!hardRouteLevelConstraint.fulfilled(insertionContext)){ if(!hardRouteLevelConstraint.fulfilled(insertionContext)){
return InsertionData.createEmptyInsertionData(); return InsertionData.createEmptyInsertionData();
} }
@ -201,7 +206,7 @@ final class ShipmentInsertionCalculator implements JobInsertionCostsCalculator{
return insertionData; return insertionData;
} }
private ActivityInsertionCosts calculate(InsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double departureTimeAtPrevAct) { private ActivityInsertionCosts calculate(JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double departureTimeAtPrevAct) {
return activityInsertionCostsCalculator.getCosts(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct); return activityInsertionCostsCalculator.getCosts(iFacts, prevAct, nextAct, newAct, departureTimeAtPrevAct);
} }

13
jsprit-core/src/main/java/algorithms/VehicleSwitched.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/VehicleSwitched.java
View file

@ -14,18 +14,19 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import basics.route.Vehicle; import jsprit.core.algorithm.recreate.listener.VehicleSwitchedListener;
import basics.route.VehicleFleetManager; import jsprit.core.problem.solution.route.VehicleRoute;
import basics.route.VehicleRoute; import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleFleetManager;
class VehicleSwitched implements VehicleSwitchedListener{ public class VehicleSwitched implements VehicleSwitchedListener{
private VehicleFleetManager fleetManager; private VehicleFleetManager fleetManager;
VehicleSwitched(VehicleFleetManager fleetManager){ public VehicleSwitched(VehicleFleetManager fleetManager){
this.fleetManager = fleetManager; this.fleetManager = fleetManager;
} }

17
jsprit-core/src/main/java/algorithms/VehicleTypeDependentJobInsertionCalculator.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/VehicleTypeDependentJobInsertionCalculator.java
View file

@ -14,20 +14,21 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import jsprit.core.algorithm.recreate.InsertionData.NoInsertionFound;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleFleetManager;
import jsprit.core.problem.vehicle.VehicleImpl.NoVehicle;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import algorithms.InsertionData.NoInsertionFound;
import basics.Job;
import basics.route.Driver;
import basics.route.Vehicle;
import basics.route.VehicleFleetManager;
import basics.route.VehicleImpl.NoVehicle;
import basics.route.VehicleRoute;

8
jsprit-core/src/main/java/algorithms/BeforeJobInsertionListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/listener/BeforeJobInsertionListener.java
View file

@ -14,11 +14,11 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate.listener;
import basics.Job; import jsprit.core.algorithm.recreate.InsertionData;
import basics.algo.InsertionListener; import jsprit.core.problem.job.Job;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;
interface BeforeJobInsertionListener extends InsertionListener{ interface BeforeJobInsertionListener extends InsertionListener{

5
jsprit-core/src/main/java/basics/algo/InsertionEndsListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/listener/InsertionEndsListener.java
View file

@ -14,11 +14,12 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.recreate.listener;
import java.util.Collection; import java.util.Collection;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;
public interface InsertionEndsListener extends InsertionListener { public interface InsertionEndsListener extends InsertionListener {

4
jsprit-core/src/main/java/basics/algo/InsertionListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/listener/InsertionListener.java
View file

@ -14,7 +14,9 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.recreate.listener;
import jsprit.core.algorithm.listener.SearchStrategyModuleListener;

16
jsprit-core/src/main/java/algorithms/InsertionListeners.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/listener/InsertionListeners.java
View file

@ -14,20 +14,18 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate.listener;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import basics.Job; import jsprit.core.algorithm.recreate.InsertionData;
import basics.algo.InsertionEndsListener; import jsprit.core.problem.job.Job;
import basics.algo.InsertionListener; import jsprit.core.problem.solution.route.VehicleRoute;
import basics.algo.InsertionStartsListener; import jsprit.core.problem.vehicle.Vehicle;
import basics.algo.JobInsertedListener;
import basics.route.Vehicle;
import basics.route.VehicleRoute;
class InsertionListeners {
public class InsertionListeners {
private Collection<InsertionListener> listeners = new ArrayList<InsertionListener>(); private Collection<InsertionListener> listeners = new ArrayList<InsertionListener>();

7
jsprit-core/src/main/java/basics/algo/InsertionStartsListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/listener/InsertionStartsListener.java
View file

@ -14,12 +14,13 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.recreate.listener;
import java.util.Collection; import java.util.Collection;
import basics.Job; import jsprit.core.problem.job.Job;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;
public interface InsertionStartsListener extends InsertionListener { public interface InsertionStartsListener extends InsertionListener {

6
jsprit-core/src/main/java/basics/algo/JobInsertedListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/listener/JobInsertedListener.java
View file

@ -14,10 +14,10 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package basics.algo; package jsprit.core.algorithm.recreate.listener;
import basics.Job; import jsprit.core.problem.job.Job;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;

9
jsprit-core/src/main/java/algorithms/VehicleSwitchedListener.java → jsprit-core/src/main/java/jsprit/core/algorithm/recreate/listener/VehicleSwitchedListener.java
View file

@ -14,13 +14,12 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.recreate.listener;
import basics.algo.InsertionListener; import jsprit.core.problem.solution.route.VehicleRoute;
import basics.route.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
import basics.route.VehicleRoute;
interface VehicleSwitchedListener extends InsertionListener{ public interface VehicleSwitchedListener extends InsertionListener{
public void vehicleSwitched(VehicleRoute vehicleRoute, Vehicle oldVehicle, Vehicle newVehicle); public void vehicleSwitched(VehicleRoute vehicleRoute, Vehicle oldVehicle, Vehicle newVehicle);

5
jsprit-core/src/main/java/algorithms/RadialRuinStrategyFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/ruin/RadialRuinStrategyFactory.java
View file

@ -1,6 +1,7 @@
package algorithms; package jsprit.core.algorithm.ruin;
import basics.VehicleRoutingProblem; import jsprit.core.algorithm.ruin.distance.JobDistance;
import jsprit.core.problem.VehicleRoutingProblem;
public class RadialRuinStrategyFactory implements RuinStrategyFactory{ public class RadialRuinStrategyFactory implements RuinStrategyFactory{

4
jsprit-core/src/main/java/algorithms/RandomRuinStrategyFactory.java → jsprit-core/src/main/java/jsprit/core/algorithm/ruin/RandomRuinStrategyFactory.java
View file

@ -1,6 +1,6 @@
package algorithms; package jsprit.core.algorithm.ruin;
import basics.VehicleRoutingProblem; import jsprit.core.problem.VehicleRoutingProblem;
public class RandomRuinStrategyFactory implements RuinStrategyFactory{ public class RandomRuinStrategyFactory implements RuinStrategyFactory{

18
jsprit-core/src/main/java/algorithms/RuinRadial.java → jsprit-core/src/main/java/jsprit/core/algorithm/ruin/RuinRadial.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.ruin;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -27,15 +27,17 @@ import java.util.Map;
import java.util.Random; import java.util.Random;
import java.util.TreeSet; import java.util.TreeSet;
import jsprit.core.algorithm.ruin.distance.JobDistance;
import jsprit.core.algorithm.ruin.listener.RuinListener;
import jsprit.core.algorithm.ruin.listener.RuinListeners;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.util.RandomNumberGeneration;
import jsprit.core.util.StopWatch;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.RandomNumberGeneration;
import util.StopWatch;
import basics.Job;
import basics.VehicleRoutingProblem;
import basics.algo.RuinListener;
import basics.algo.RuinListeners;
import basics.route.VehicleRoute;
/** /**

15
jsprit-core/src/main/java/algorithms/RuinRandom.java → jsprit-core/src/main/java/jsprit/core/algorithm/ruin/RuinRandom.java
View file

@ -14,7 +14,7 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.ruin;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
@ -22,14 +22,15 @@ import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Random; import java.util.Random;
import jsprit.core.algorithm.ruin.listener.RuinListener;
import jsprit.core.algorithm.ruin.listener.RuinListeners;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.util.RandomNumberGeneration;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import util.RandomNumberGeneration;
import basics.Job;
import basics.VehicleRoutingProblem;
import basics.algo.RuinListener;
import basics.algo.RuinListeners;
import basics.route.VehicleRoute;
/** /**

9
jsprit-core/src/main/java/algorithms/RuinStrategy.java → jsprit-core/src/main/java/jsprit/core/algorithm/ruin/RuinStrategy.java
View file

@ -14,13 +14,14 @@
* You should have received a copy of the GNU Lesser General Public * 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/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/ ******************************************************************************/
package algorithms; package jsprit.core.algorithm.ruin;
import java.util.Collection; import java.util.Collection;
import basics.Job; import jsprit.core.algorithm.ruin.listener.RuinListener;
import basics.algo.RuinListener; import jsprit.core.problem.job.Job;
import basics.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;

Some files were not shown because too many files have changed in this diff Show more