public static PotvinPDShiftMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
List<int> cities = new List<int>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
for (int i = 1; i <= individual.Cities; i++) {
if (pdp == null || pdp.GetDemand(i) >= 0)
cities.Add(i);
}
if (cities.Count >= 1) {
int city = cities[rand.Next(cities.Count)];
Tour oldTour = individual.Tours.Find(t => t.Stops.Contains(city));
int oldTourIndex = individual.Tours.IndexOf(oldTour);
int max = individual.Tours.Count;
if (individual.Tours.Count >= problemInstance.Vehicles.Value)
max = max - 1;
int newTourIndex = rand.Next(max);
if (newTourIndex >= oldTourIndex)
newTourIndex++;
return new PotvinPDShiftMove(city, oldTourIndex, newTourIndex, individual);
} else {
return null;
}
}
public static void GetSegments(PotvinTwoOptStarMove move, out List <int> segmentX1, out List <int> segmentX2)
{
PotvinEncoding solution = move.Individual as PotvinEncoding;
Tour route1 = solution.Tours[move.Tour1];
Tour route2 = solution.Tours[move.Tour2];
int x1 = move.X1;
int x2 = move.X2;
int count = route1.Stops.Count - x1;
segmentX1 = new List <int>();
if (count > 0)
{
segmentX1 = route1.Stops.GetRange(x1, count);
}
count = route2.Stops.Count - x2;
segmentX2 = new List <int>();
if (count > 0)
{
segmentX2 = route2.Stops.GetRange(x2, count);
}
}
protected static int SelectRandomTourBiasedByLength(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance) {
int tourIndex = -1;
double sum = 0.0;
double[] probabilities = new double[individual.Tours.Count];
for (int i = 0; i < individual.Tours.Count; i++) {
probabilities[i] = 1.0 / ((double)individual.Tours[i].Stops.Count / (double)instance.Cities.Value);
sum += probabilities[i];
}
for (int i = 0; i < probabilities.Length; i++)
probabilities[i] = probabilities[i] / sum;
double rand = random.NextDouble();
double cumulatedProbabilities = 0.0;
int index = 0;
while (tourIndex == -1 && index < probabilities.Length) {
if (cumulatedProbabilities <= rand && rand <= cumulatedProbabilities + probabilities[index])
tourIndex = index;
cumulatedProbabilities += probabilities[index];
index++;
}
return tourIndex;
}
public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, bool allowInfeasible) {
int selectedIndex = SelectRandomTourBiasedByLength(random, individual, instance);
if (selectedIndex >= 0) {
Tour route1 =
individual.Tours[selectedIndex];
int count = route1.Stops.Count;
int i = 0;
while (i < count) {
int insertedRoute, insertedPlace;
int city = route1.Stops[i];
route1.Stops.Remove(city);
if (FindInsertionPlace(individual, city, selectedIndex, allowInfeasible, out insertedRoute, out insertedPlace)) {
individual.Tours[insertedRoute].Stops.Insert(insertedPlace, city);
} else {
route1.Stops.Insert(i, city);
i++;
}
count = route1.Stops.Count;
}
}
}
public static void Apply(PotvinEncoding solution, PotvinPDExchangeMove move, IVRPProblemInstance problemInstance) {
if (move.Tour >= solution.Tours.Count)
solution.Tours.Add(new Tour());
Tour tour = solution.Tours[move.Tour];
Tour oldTour = solution.Tours.Find(t => t.Stops.Contains(move.City));
oldTour.Stops.Remove(move.City);
if (problemInstance is IPickupAndDeliveryProblemInstance) {
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
int location = pdp.GetPickupDeliveryLocation(move.City);
Tour oldTour2 = solution.Tours.Find(t => t.Stops.Contains(location));
oldTour2.Stops.Remove(location);
location = pdp.GetPickupDeliveryLocation(move.Replaced);
oldTour2 = solution.Tours.Find(t => t.Stops.Contains(location));
oldTour2.Stops.Remove(location);
tour.Stops.Remove(move.Replaced);
solution.InsertPair(tour, move.City, pdp.GetPickupDeliveryLocation(move.City), problemInstance);
solution.InsertPair(oldTour, move.Replaced, pdp.GetPickupDeliveryLocation(move.Replaced), problemInstance);
} else {
tour.Stops.Remove(move.Replaced);
int place = solution.FindBestInsertionPlace(tour, move.City);
tour.Stops.Insert(place, move.City);
place = solution.FindBestInsertionPlace(oldTour, move.Replaced);
oldTour.Stops.Insert(place, move.Replaced);
}
solution.Repair();
}
public PotvinCustomerRelocationMove(int city, int oldTour, int tour, PotvinEncoding individual) {
City = city;
OldTour = oldTour;
Tour = tour;
this.Individual = individual.Clone() as PotvinEncoding;
}
public static void Apply(PotvinEncoding solution, PotvinVehicleAssignmentMove move, IVRPProblemInstance problemInstance) {
int vehicle1 = solution.VehicleAssignment[move.Tour1];
int vehicle2 = solution.VehicleAssignment[move.Tour2];
solution.VehicleAssignment[move.Tour1] = vehicle2;
solution.VehicleAssignment[move.Tour2] = vehicle1;
}
protected static bool RouteUnrouted(PotvinEncoding solution, bool allowInfeasible)
{
bool success = true;
int index = 0;
while (index < solution.Unrouted.Count && success)
{
int unrouted = solution.Unrouted[index];
int route, place;
if (FindInsertionPlace(solution, unrouted, allowInfeasible,
out route, out place))
{
solution.Tours[route].Stops.Insert(place, unrouted);
}
else
{
success = false;
}
index++;
}
for (int i = 0; i < index; i++)
{
solution.Unrouted.RemoveAt(0);
}
return(success);
}
protected override PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance)
{
List <PotvinPDShiftMove> result = new List <PotvinPDShiftMove>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
int max = individual.Tours.Count;
if (individual.Tours.Count >= problemInstance.Vehicles.Value)
{
max = max - 1;
}
for (int i = 0; i < individual.Tours.Count; i++)
{
for (int j = 0; j < individual.Tours[i].Stops.Count; j++)
{
for (int k = 0; k <= max; k++)
{
if (k != i)
{
int city = individual.Tours[i].Stops[j];
if (pdp == null || pdp.GetDemand(city) >= 0)
{
PotvinPDShiftMove move = new PotvinPDShiftMove(
city, i, k, individual);
result.Add(move);
}
}
}
}
}
return(result.ToArray());
}
protected override PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinPDShiftMove> result = new List<PotvinPDShiftMove>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
int max = individual.Tours.Count;
if (individual.Tours.Count >= problemInstance.Vehicles.Value)
max = max - 1;
for (int i = 0; i < individual.Tours.Count; i++) {
for (int j = 0; j < individual.Tours[i].Stops.Count; j++) {
for (int k = 0; k <= max; k++) {
if (k != i) {
int city = individual.Tours[i].Stops[j];
if (pdp == null || pdp.GetDemand(city) >= 0) {
PotvinPDShiftMove move = new PotvinPDShiftMove(
city, i, k, individual);
result.Add(move);
}
}
}
}
}
return result.ToArray();
}
public static PotvinEncoding ConvertFrom(List <int> route, IVRPProblemInstance instance)
{
PotvinEncoding solution = new PotvinEncoding(instance);
solution.Tours = new ItemList <Tour>();
Tour tour = new Tour();
int routeIdx = 0;
for (int i = 0; i < route.Count; i++)
{
if (route[i] <= 0)
{
if (tour.Stops.Count > 0)
{
solution.Tours.Add(tour);
tour = new Tour();
}
int vehicle = -route[i];
solution.VehicleAssignment[routeIdx] = vehicle;
routeIdx++;
}
else
{
tour.Stops.Add(route[i]);
}
}
solution.Repair();
return(solution);
}
public static double CalculateSimilarity(PotvinEncoding left, PotvinEncoding right) {
if (left == null || right == null)
throw new ArgumentException("Cannot calculate similarity because one of the provided solutions or both are null.");
if (left == right) return 1.0;
// extract edges from first solution
var edges1 = new List<Tuple<int, int>>();
foreach (Tour tour in left.Tours) {
edges1.Add(new Tuple<int, int>(0, tour.Stops[0]));
for (int i = 0; i < tour.Stops.Count - 1; i++)
edges1.Add(new Tuple<int, int>(tour.Stops[i], tour.Stops[i + 1]));
edges1.Add(new Tuple<int, int>(tour.Stops[tour.Stops.Count - 1], 0));
}
// extract edges from second solution
var edges2 = new List<Tuple<int, int>>();
foreach (Tour tour in right.Tours) {
edges2.Add(new Tuple<int, int>(0, tour.Stops[0]));
for (int i = 0; i < tour.Stops.Count - 1; i++)
edges2.Add(new Tuple<int, int>(tour.Stops[i], tour.Stops[i + 1]));
edges2.Add(new Tuple<int, int>(tour.Stops[tour.Stops.Count - 1], 0));
}
if (edges1.Count + edges2.Count == 0)
throw new ArgumentException("Cannot calculate diversity because no tours exist.");
int identicalEdges = 0;
foreach (var edge in edges1) {
if (edges2.Any(x => x.Equals(edge)))
identicalEdges++;
}
return identicalEdges * 2.0 / (edges1.Count + edges2.Count);
}
public PotvinPDShiftMove(int city, int oldTour, int tour, PotvinEncoding individual) {
City = city;
OldTour = oldTour;
Tour = tour;
this.Individual = individual.Clone() as PotvinEncoding;
}
public static void Apply(PotvinEncoding solution, PotvinPDRearrangeMove move, IVRPProblemInstance problemInstance)
{
Tour tour = solution.Tours[move.Tour];
int position = tour.Stops.IndexOf(move.City);
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
if (pdp != null)
{
int location = pdp.GetPickupDeliveryLocation(move.City);
Tour tour2 = solution.Tours.Find(t => t.Stops.Contains(location));
int position2 = tour2.Stops.IndexOf(location);
tour.Stops.Remove(move.City);
tour2.Stops.Remove(location);
solution.InsertPair(tour, move.City, location, problemInstance, position, position2);
}
else
{
tour.Stops.Remove(move.City);
int place = solution.FindBestInsertionPlace(tour, move.City, position);
tour.Stops.Insert(place, move.City);
}
solution.Repair();
}
protected override PotvinCustomerRelocationMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance)
{
List <PotvinCustomerRelocationMove> result = new List <PotvinCustomerRelocationMove>();
int max = individual.Tours.Count;
if (individual.Tours.Count >= problemInstance.Vehicles.Value)
{
max = max - 1;
}
for (int i = 0; i < individual.Tours.Count; i++)
{
for (int j = 0; j < individual.Tours[i].Stops.Count; j++)
{
for (int k = 0; k <= max; k++)
{
if (k != i)
{
PotvinCustomerRelocationMove move = new PotvinCustomerRelocationMove(
individual.Tours[i].Stops[j], i, k, individual);
result.Add(move);
}
}
}
}
return(result.ToArray());
}
public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IPickupAndDeliveryProblemInstance pdp, bool allowInfeasible)
{
int selectedIndex = SelectRandomTourBiasedByLength(random, individual, pdp);
if (selectedIndex >= 0)
{
Tour route1 =
individual.Tours[selectedIndex];
int count = route1.Stops.Count;
if (count > 0)
{
int i = random.Next(0, count);
int city = route1.Stops[i];
if (!PairwiseMove(individual, pdp, city, allowInfeasible))
{
i++;
}
count = route1.Stops.Count;
}
}
}
public PotvinPDRearrangeMove(int city, int tour, PotvinEncoding individual)
{
City = city;
Tour = tour;
this.Individual = individual.Clone() as PotvinEncoding;
}
public void ImportSolution(string solutionFileName)
{
SolutionParser parser = new SolutionParser(solutionFileName);
parser.Parse();
HeuristicLab.Problems.VehicleRouting.Encodings.Potvin.PotvinEncoding encoding = new Encodings.Potvin.PotvinEncoding(ProblemInstance);
int cities = 0;
foreach (List <int> route in parser.Routes)
{
Tour tour = new Tour();
tour.Stops.AddRange(route);
cities += tour.Stops.Count;
encoding.Tours.Add(tour);
}
if (cities != ProblemInstance.Coordinates.Rows - 1)
{
ErrorHandling.ShowErrorDialog(new Exception("The optimal solution does not seem to correspond with the problem data"));
}
else
{
VRPSolution solution = new VRPSolution(ProblemInstance, encoding, new DoubleValue(0));
BestKnownSolutionParameter.Value = solution;
}
}
public PotvinVehicleAssignmentMove(int tour1, int tour2, PotvinEncoding individual)
{
Tour1 = tour1;
Tour2 = tour2;
this.Individual = individual.Clone() as PotvinEncoding;
}
public static PotvinPDRearrangeMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand)
{
List <int> cities = new List <int>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
for (int i = 1; i <= individual.Cities; i++)
{
if (pdp == null || pdp.GetDemand(i) >= 0)
{
cities.Add(i);
}
}
if (cities.Count > 0)
{
int city = cities[rand.Next(cities.Count)];
int tour = individual.Tours.FindIndex(t => t.Stops.Contains(city));
return(new PotvinPDRearrangeMove(city, tour, individual));
}
else
{
return(null);
}
}
protected static int SelectRandomTourBiasedByLength(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance)
{
int tourIndex = -1;
double sum = 0.0;
double[] probabilities = new double[individual.Tours.Count];
for (int i = 0; i < individual.Tours.Count; i++)
{
probabilities[i] = 1.0 / ((double)individual.Tours[i].Stops.Count / (double)instance.Cities.Value);
sum += probabilities[i];
}
for (int i = 0; i < probabilities.Length; i++)
{
probabilities[i] = probabilities[i] / sum;
}
double rand = random.NextDouble();
double cumulatedProbabilities = 0.0;
int index = 0;
while (tourIndex == -1 && index < probabilities.Length)
{
if (cumulatedProbabilities <= rand && rand <= cumulatedProbabilities + probabilities[index])
{
tourIndex = index;
}
cumulatedProbabilities += probabilities[index];
index++;
}
return(tourIndex);
}
public static void Apply(PotvinEncoding solution, PotvinPDShiftMove move, IVRPProblemInstance problemInstance) {
bool newTour = false;
if (move.Tour >= solution.Tours.Count) {
solution.Tours.Add(new Tour());
newTour = true;
}
Tour tour = solution.Tours[move.Tour];
Tour oldTour = solution.Tours.Find(t => t.Stops.Contains(move.City));
oldTour.Stops.Remove(move.City);
if (problemInstance is IPickupAndDeliveryProblemInstance) {
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
int location = pdp.GetPickupDeliveryLocation(move.City);
Tour oldTour2 = solution.Tours.Find(t => t.Stops.Contains(location));
oldTour2.Stops.Remove(location);
solution.InsertPair(tour, move.City, location, problemInstance);
} else {
int place = solution.FindBestInsertionPlace(tour, move.City);
tour.Stops.Insert(place, move.City);
}
if (newTour) {
List<int> vehicles = new List<int>();
for (int i = move.Tour; i < problemInstance.Vehicles.Value; i++) {
vehicles.Add(solution.GetVehicleAssignment(i));
}
double bestQuality = double.MaxValue;
int bestVehicle = -1;
int originalVehicle = solution.GetVehicleAssignment(move.Tour);
foreach (int vehicle in vehicles) {
solution.VehicleAssignment[move.Tour] = vehicle;
double quality = problemInstance.EvaluateTour(tour, solution).Quality;
if (quality < bestQuality) {
bestQuality = quality;
bestVehicle = vehicle;
}
}
solution.VehicleAssignment[move.Tour] = originalVehicle;
int index = -1;
for (int i = move.Tour; i < solution.VehicleAssignment.Length; i++) {
if (solution.VehicleAssignment[i] == bestVehicle) {
index = i;
break;
}
}
solution.VehicleAssignment[index] = originalVehicle;
solution.VehicleAssignment[move.Tour] = bestVehicle;
}
solution.Repair();
}
protected static bool FindInsertionPlace(PotvinEncoding individual, int city, bool allowInfeasible,
out int route, out int place)
{
return(individual.FindInsertionPlace(
city, -1, allowInfeasible,
out route, out place));
}
public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, bool allowInfeasible)
{
int selectedIndex = SelectRandomTourBiasedByLength(random, individual, instance);
if (selectedIndex >= 0)
{
Tour route1 =
individual.Tours[selectedIndex];
int count = route1.Stops.Count;
int i = 0;
while (i < count)
{
int insertedRoute, insertedPlace;
int city = route1.Stops[i];
route1.Stops.Remove(city);
if (FindInsertionPlace(individual, city, selectedIndex, allowInfeasible, out insertedRoute, out insertedPlace))
{
individual.Tours[insertedRoute].Stops.Insert(insertedPlace, city);
}
else
{
route1.Stops.Insert(i, city);
i++;
}
count = route1.Stops.Count;
}
}
}
protected override void EvaluateMove()
{
PotvinCustomerRelocationMove move = CustomerRelocationMoveParameter.ActualValue;
PotvinEncoding newSolution = CustomerRelocationMoveParameter.ActualValue.Individual.Clone() as PotvinEncoding;
PotvinCustomerRelocationMoveMaker.Apply(newSolution, move, ProblemInstance);
UpdateEvaluation(newSolution);
//Apply memory, only if move is worse
if (MoveQualityParameter.ActualValue.Value >= QualityParameter.ActualValue.Value)
{
VariableCollection memory = MemoriesParameter.ActualValue;
string key = AdditionFrequencyMemoryKeyParameter.Value.Value;
if (memory != null && memory.ContainsKey(key))
{
ItemDictionary <PotvinCustomerRelocationMoveAttribute, IntValue> additionFrequency =
memory[key].Value as ItemDictionary <PotvinCustomerRelocationMoveAttribute, IntValue>;
PotvinCustomerRelocationMoveAttribute attr = new PotvinCustomerRelocationMoveAttribute(0, move.Tour, move.City);
if (additionFrequency.ContainsKey(attr))
{
int frequency = additionFrequency[attr].Value;
double quality = MoveQualityParameter.ActualValue.Value;
MoveQualityParameter.ActualValue.Value +=
LambdaParameter.Value.Value * quality * frequency;
}
}
}
}
public static PotvinPDExchangeMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand)
{
List <int> cities = new List <int>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
for (int i = 1; i <= individual.Cities; i++)
{
if (pdp == null || pdp.GetDemand(i) >= 0)
{
cities.Add(i);
}
}
if (cities.Count > 1 && individual.Tours.Count > 1)
{
PotvinPDExchangeMove move = null;
while (cities.Count > 1 && move == null)
{
int city = cities[rand.Next(cities.Count)];
Tour oldTour = individual.Tours.Find(t => t.Stops.Contains(city));
int oldTourIndex = individual.Tours.IndexOf(oldTour);
int max = individual.Tours.Count - 1;
int newTourIndex = rand.Next(max);
if (newTourIndex >= oldTourIndex)
{
newTourIndex++;
}
Tour newTour = individual.Tours[newTourIndex];
List <int> tourCities = new List <int>();
foreach (int stop in newTour.Stops)
{
if (pdp == null ||
(pdp.GetDemand(stop) >= 0 &&
pdp.GetPickupDeliveryLocation(stop) != pdp.GetPickupDeliveryLocation(city) &&
pdp.GetPickupDeliveryLocation(stop) != city &&
pdp.GetPickupDeliveryLocation(city) != stop))
{
tourCities.Add(stop);
}
}
if (tourCities.Count > 0)
{
int replaced = tourCities[rand.Next(tourCities.Count)];
move = new PotvinPDExchangeMove(city, oldTourIndex, newTourIndex, replaced, individual);
}
}
return(move);
}
else
{
return(null);
}
}
public static PotvinEncoding Apply(IRandom random, PotvinEncoding parent1, PotvinEncoding parent2, IVRPProblemInstance problemInstance, bool allowInfeasible)
{
PotvinEncoding child = parent2.Clone() as PotvinEncoding;
if (parent1.Tours.Count > 0 && child.Tours.Count > 0)
{
int tourParent1 = random.Next(parent1.Tours.Count);
Tour replacing = parent1.Tours[tourParent1].Clone() as Tour;
int tourParent2 = random.Next(child.Tours.Count);
Tour replaced = child.Tours[tourParent2];
child.Tours.Remove(replaced);
child.Tours.Insert(tourParent2, replacing);
Permutation vehicleAssignment = child.VehicleAssignment;
int vehicle = vehicleAssignment[tourParent2];
int vehicle2 = parent1.VehicleAssignment[tourParent1];
vehicleAssignment[tourParent2] = vehicle2;
for (int i = 0; i < vehicleAssignment.Length; i++)
{
if (vehicleAssignment[i] == vehicle2 && i != tourParent2)
{
vehicleAssignment[i] = vehicle;
break;
}
}
foreach (int city in replaced.Stops)
{
if (FindRoute(child, city) == null && !child.Unrouted.Contains(city))
{
child.Unrouted.Add(city);
}
}
if (Repair(random, child, replacing, problemInstance, allowInfeasible) || allowInfeasible)
{
return(child);
}
else
{
if (random.NextDouble() < 0.5)
{
return(parent1.Clone() as PotvinEncoding);
}
else
{
return(parent2.Clone() as PotvinEncoding);
}
}
}
else
{
return(child);
}
}
public PotvinPDShiftMove(int city, int oldTour, int tour, PotvinEncoding individual)
{
City = city;
OldTour = oldTour;
Tour = tour;
this.Individual = individual.Clone() as PotvinEncoding;
}
public PotvinPDExchangeMove(int city, int oldTour, int tour, int replaced, PotvinEncoding individual) {
City = city;
OldTour = oldTour;
Tour = tour;
Replaced = replaced;
this.Individual = individual.Clone() as PotvinEncoding;
}
public PotvinCustomerRelocationMove(int city, int oldTour, int tour, PotvinEncoding individual)
{
City = city;
OldTour = oldTour;
Tour = tour;
this.Individual = individual.Clone() as PotvinEncoding;
}
public static void Apply(PotvinEncoding solution, PotvinVehicleAssignmentMove move, IVRPProblemInstance problemInstance)
{
int vehicle1 = solution.VehicleAssignment[move.Tour1];
int vehicle2 = solution.VehicleAssignment[move.Tour2];
solution.VehicleAssignment[move.Tour1] = vehicle2;
solution.VehicleAssignment[move.Tour2] = vehicle1;
}
public PotvinTwoOptStarMove(int tour1, int x1, int tour2, int x2, PotvinEncoding individual) {
Tour1 = tour1;
X1 = x1;
Tour2 = tour2;
X2 = x2;
this.Individual = individual.Clone() as PotvinEncoding;
}
public static PotvinEncoding CreateSolution(IVRPProblemInstance instance, IRandom random, bool adhereTimeWindows) {
PotvinEncoding result = new PotvinEncoding(instance);
IPickupAndDeliveryProblemInstance pdp = instance as IPickupAndDeliveryProblemInstance;
List<int> customers = new List<int>();
for (int i = 1; i <= instance.Cities.Value; i++)
if (pdp == null || pdp.GetDemand(i) >= 0)
customers.Add(i);
customers.Sort((city1, city2) => {
double angle1 = CalculateAngleToDepot(instance, city1);
double angle2 = CalculateAngleToDepot(instance, city2);
return angle1.CompareTo(angle2);
});
Tour currentTour = new Tour();
result.Tours.Add(currentTour);
int j = random.Next(customers.Count);
for (int i = 0; i < customers.Count; i++) {
int index = (i + j) % customers.Count;
int stopIdx = 0;
if (currentTour.Stops.Count > 0)
stopIdx = result.FindBestInsertionPlace(currentTour, customers[index]);
currentTour.Stops.Insert(stopIdx, customers[index]);
if (pdp != null) {
stopIdx = result.FindBestInsertionPlace(currentTour, pdp.GetPickupDeliveryLocation(customers[index]));
currentTour.Stops.Insert(stopIdx, pdp.GetPickupDeliveryLocation(customers[index]));
}
CVRPEvaluation evaluation = instance.EvaluateTour(currentTour, result) as CVRPEvaluation;
if (result.Tours.Count < instance.Vehicles.Value &&
((adhereTimeWindows && !instance.Feasible(evaluation)) || ((!adhereTimeWindows) && evaluation.Overload > double.Epsilon))) {
currentTour.Stops.Remove(customers[index]);
if (pdp != null)
currentTour.Stops.Remove(pdp.GetPickupDeliveryLocation(customers[index]));
if (currentTour.Stops.Count == 0)
result.Tours.Remove(currentTour);
currentTour = new Tour();
result.Tours.Add(currentTour);
currentTour.Stops.Add(customers[index]);
if (pdp != null) {
currentTour.Stops.Add(pdp.GetPickupDeliveryLocation(customers[index]));
}
}
}
if (currentTour.Stops.Count == 0)
result.Tours.Remove(currentTour);
return result;
}
public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, int maxIterations)
{
//only apply to feasible individuals
if (instance.Feasible(individual))
{
bool insertionFound;
int iterations = 0;
do
{
insertionFound = false;
int length = 3;
while (length > 0 && !insertionFound)
{
int tour = 0;
while (tour < individual.Tours.Count && !insertionFound)
{
int city = 0;
while (city <= individual.Tours[tour].Stops.Count - length && !insertionFound)
{
int insertionTour, insertionPlace;
if (FindBetterInsertionPlace(individual, instance, tour, city, length,
out insertionTour, out insertionPlace))
{
insertionFound = true;
List <int> toBeInserted = individual.Tours[tour].Stops.GetRange(city, length);
individual.Tours[tour].Stops.RemoveRange(city, length);
individual.Tours[insertionTour].Stops.InsertRange(
insertionPlace,
toBeInserted);
}
city++;
}
tour++;
}
length--;
}
iterations++;
} while (insertionFound &&
iterations < maxIterations);
IList <Tour> toBeRemoved = new List <Tour>();
foreach (Tour tour in individual.Tours)
{
if (tour.Stops.Count == 0)
{
toBeRemoved.Add(tour);
}
}
foreach (Tour tour in toBeRemoved)
{
individual.Tours.Remove(tour);
}
}
}
protected override PotvinVehicleAssignmentMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinVehicleAssignmentMove> result = new List<PotvinVehicleAssignmentMove>();
PotvinVehicleAssignmentMove move = Apply(individual, ProblemInstance, RandomParameter.ActualValue);
if (move != null)
result.Add(move);
return result.ToArray();
}
public PotvinTwoOptStarMove(int tour1, int x1, int tour2, int x2, PotvinEncoding individual)
{
Tour1 = tour1;
X1 = x1;
Tour2 = tour2;
X2 = x2;
this.Individual = individual.Clone() as PotvinEncoding;
}
protected override void PerformMove()
{
PotvinPDRearrangeMove move = PDRearrangeMoveParameter.ActualValue;
PotvinEncoding newSolution = move.Individual.Clone() as PotvinEncoding;
Apply(newSolution, move, ProblemInstance);
VRPToursParameter.ActualValue = newSolution;
}
protected override PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinPDShiftMove> result = new List<PotvinPDShiftMove>();
PotvinPDShiftMove move = Apply(individual, ProblemInstance, RandomParameter.ActualValue);
if (move != null)
result.Add(move);
return result.ToArray();
}
protected override PotvinCustomerRelocationMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinCustomerRelocationMove> result = new List<PotvinCustomerRelocationMove>();
for (int i = 0; i < SampleSizeParameter.ActualValue.Value; i++) {
result.Add(PotvinCustomerRelocationSingleMoveGenerator.Apply(individual, ProblemInstance, RandomParameter.ActualValue));
}
return result.ToArray();
}
public PotvinPDExchangeMove(int city, int oldTour, int tour, int replaced, PotvinEncoding individual)
{
City = city;
OldTour = oldTour;
Tour = tour;
Replaced = replaced;
this.Individual = individual.Clone() as PotvinEncoding;
}
protected override void EvaluateMove()
{
PotvinPDExchangeMove move = PDExchangeMoveParameter.ActualValue;
PotvinEncoding newSolution = PDExchangeMoveParameter.ActualValue.Individual.Clone() as PotvinEncoding;
PotvinPDExchangeMoveMaker.Apply(newSolution, move, ProblemInstance);
UpdateEvaluation(newSolution);
}
protected override void PerformMove()
{
PotvinVehicleAssignmentMove move = VehicleAssignmentMoveParameter.ActualValue;
PotvinEncoding newSolution = move.Individual.Clone() as PotvinEncoding;
Apply(newSolution, move, ProblemInstance);
newSolution.Repair();
VRPToursParameter.ActualValue = newSolution;
}
public override IOperation InstrumentedApply()
{
IVRPEncoding solution = VRPToursParameter.ActualValue;
if (!(solution is PotvinEncoding))
{
VRPToursParameter.ActualValue = PotvinEncoding.ConvertFrom(solution, ProblemInstance);
}
return(base.InstrumentedApply());
}
protected override void Manipulate(IRandom random, PotvinEncoding individual)
{
bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
IPickupAndDeliveryProblemInstance pdp = ProblemInstance as IPickupAndDeliveryProblemInstance;
if (pdp != null)
{
ApplyManipulation(random, individual, pdp, allowInfeasible);
}
}
protected override PotvinVehicleAssignmentMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinVehicleAssignmentMove> result = new List<PotvinVehicleAssignmentMove>();
for (int i = 0; i < SampleSizeParameter.ActualValue.Value; i++) {
var move = PotvinVehicleAssignmentSingleMoveGenerator.Apply(individual, ProblemInstance, RandomParameter.ActualValue);
if (move != null)
result.Add(move);
}
return result.ToArray();
}
protected override PotvinCustomerRelocationMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance)
{
List <PotvinCustomerRelocationMove> result = new List <PotvinCustomerRelocationMove>();
for (int i = 0; i < SampleSizeParameter.ActualValue.Value; i++)
{
result.Add(PotvinCustomerRelocationSingleMoveGenerator.Apply(individual, ProblemInstance, RandomParameter.ActualValue));
}
return(result.ToArray());
}
protected static Tour FindRoute(PotvinEncoding solution, int city) {
Tour found = null;
foreach (Tour tour in solution.Tours) {
if (tour.Stops.Contains(city)) {
found = tour;
break;
}
}
return found;
}
protected override int Improve(PotvinEncoding solution) {
int evaluatedSolutions = 0;
var rand = RandomParameter.ActualValue;
var instance = ProblemInstance;
int sampleSize = SampleSizeParameter.Value.Value;
int attempts = ImprovementAttemptsParameter.Value.Value;
int customers = instance.Cities.Value;
// store city-to-tour assignment and position of the city within the tour
var tours = new Dictionary<int, Tour>();
var position = new Dictionary<int, int>();
foreach (Tour tour in solution.Tours) {
for (int stop = 0; stop < tour.Stops.Count; stop++) {
int city = tour.Stops[stop];
tours[city] = tour;
position[city] = stop;
}
}
for (int attempt = 0; attempt < attempts; attempt++) {
for (int sample = 0; sample < sampleSize; sample++) {
int chosenCust = 1 + rand.Next(customers);
var custTour = tours[chosenCust];
double beforeQuality = instance.EvaluateTour(custTour, solution).Quality;
evaluatedSolutions++;
custTour.Stops.RemoveAt(position[chosenCust]);
int place = solution.FindBestInsertionPlace(custTour, chosenCust);
evaluatedSolutions += custTour.Stops.Count;
custTour.Stops.Insert(place, chosenCust);
if (place != position[chosenCust]) {
double afterQuality = instance.EvaluateTour(custTour, solution).Quality;
if (afterQuality > beforeQuality) {
// revert move
custTour.Stops.RemoveAt(place);
custTour.Stops.Insert(position[chosenCust], chosenCust);
} else {
// accept move and update positions of the cities within the tour
for (int stop = 0; stop < custTour.Stops.Count; stop++) {
int city = custTour.Stops[stop];
position[city] = stop;
}
break;
}
}
}
}
return evaluatedSolutions;
}
protected override PotvinVehicleAssignmentMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinVehicleAssignmentMove> result = new List<PotvinVehicleAssignmentMove>();
for (int i = 0; i < individual.Tours.Count; i++) {
for (int j = i + 1; j < problemInstance.Vehicles.Value; j++) {
result.Add(new PotvinVehicleAssignmentMove(i, j, individual));
}
}
return result.ToArray();
}
public static PotvinVehicleAssignmentMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
if (individual.Tours.Count > 1) {
int tour1 = rand.Next(individual.Tours.Count);
int tour2 = rand.Next(problemInstance.Vehicles.Value);
while (tour2 == tour1)
tour2 = rand.Next(problemInstance.Vehicles.Value);
return new PotvinVehicleAssignmentMove(tour1, tour2, individual);
} else {
return null;
}
}
protected override PotvinPDRearrangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinPDRearrangeMove> result = new List<PotvinPDRearrangeMove>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
for (int i = 1; i <= problemInstance.Cities.Value; i++) {
if (pdp == null || pdp.GetDemand(i) >= 0) {
int tour = individual.Tours.FindIndex(t => t.Stops.Contains(i));
result.Add(new PotvinPDRearrangeMove(i, tour, individual));
}
}
return result.ToArray();
}
public static PotvinTwoOptStarMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
int route1Idx = rand.Next(individual.Tours.Count);
int route2Idx = rand.Next(individual.Tours.Count - 1);
if (route2Idx >= route1Idx)
route2Idx++;
Tour route1 = individual.Tours[route1Idx];
Tour route2 = individual.Tours[route2Idx];
int x1 = rand.Next(route1.Stops.Count + 1);
int x2 = rand.Next(route2.Stops.Count + 1);
return new PotvinTwoOptStarMove(route1Idx, x1, route2Idx, x2, individual);
}
public static void ApplyManipulation(IRandom random, PotvinEncoding individual, IVRPProblemInstance instance, bool allowInfeasible) {
int selectedIndex = SelectRandomTourBiasedByLength(random, individual, instance);
if (selectedIndex >= 0) {
Tour route1 = individual.Tours[selectedIndex];
bool performed = false;
int customer1Position = 0;
while (customer1Position < route1.Stops.Count) {
performed = false;
foreach (Tour tour in individual.Tours) {
if (tour != route1) {
for (int customer2Position = 0; customer2Position < tour.Stops.Count; customer2Position++) {
int customer1 = route1.Stops[customer1Position];
int customer2 = tour.Stops[customer2Position];
//customer1 can be feasibly inserted at the location of customer2
tour.Stops[customer2Position] = customer1;
route1.Stops.RemoveAt(customer1Position);
if (instance.TourFeasible(tour, individual)) {
int routeIdx, place;
if (FindInsertionPlace(individual,
customer2, selectedIndex, allowInfeasible, out routeIdx, out place)) {
individual.Tours[routeIdx].Stops.Insert(place, customer2);
//two-level exchange has been performed
performed = true;
break;
} else {
tour.Stops[customer2Position] = customer2;
route1.Stops.Insert(customer1Position, customer1);
}
} else {
tour.Stops[customer2Position] = customer2;
route1.Stops.Insert(customer1Position, customer1);
}
}
}
if (performed)
break;
}
if (!performed)
customer1Position++;
}
}
}
public static void Apply(PotvinEncoding solution, PotvinCustomerRelocationMove move, IVRPProblemInstance problemInstance) {
if (move.Tour >= solution.Tours.Count)
solution.Tours.Add(new Tour());
Tour tour = solution.Tours[move.Tour];
Tour oldTour = solution.Tours.Find(t => t.Stops.Contains(move.City));
oldTour.Stops.Remove(move.City);
/*if (oldTour.Stops.Count == 0)
solution.Tours.Remove(oldTour);*/
int place = solution.FindBestInsertionPlace(tour, move.City);
tour.Stops.Insert(place, move.City);
solution.Repair();
}
public static PotvinCustomerRelocationMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
int city = 1 + rand.Next(individual.Cities);
Tour oldTour = individual.Tours.Find(t => t.Stops.Contains(city));
int oldTourIndex = individual.Tours.IndexOf(oldTour);
int max = individual.Tours.Count;
if (individual.Tours.Count < problemInstance.Vehicles.Value)
max = max - 1;
int newTourIndex = rand.Next(max);
if (newTourIndex >= oldTourIndex)
newTourIndex++;
return new PotvinCustomerRelocationMove(city, oldTourIndex, newTourIndex, individual);
}
public static void Apply(PotvinEncoding solution, PotvinTwoOptStarMove move, IVRPProblemInstance problemInstance) {
List<int> segmentX1;
List<int> segmentX2;
GetSegments(move, out segmentX1, out segmentX2);
Tour route1 = solution.Tours[move.Tour1];
Tour route2 = solution.Tours[move.Tour2];
foreach (int stop in segmentX1)
route1.Stops.Remove(stop);
route1.Stops.AddRange(segmentX2);
foreach (int stop in segmentX2)
route2.Stops.Remove(stop);
route2.Stops.AddRange(segmentX1);
}
public static PotvinPDRearrangeMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
List<int> cities = new List<int>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
for (int i = 1; i <= individual.Cities; i++) {
if (pdp == null || pdp.GetDemand(i) >= 0)
cities.Add(i);
}
if (cities.Count > 0) {
int city = cities[rand.Next(cities.Count)];
int tour = individual.Tours.FindIndex(t => t.Stops.Contains(city));
return new PotvinPDRearrangeMove(city, tour, individual);
} else {
return null;
}
}
protected override PotvinTwoOptStarMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
List<PotvinTwoOptStarMove> result = new List<PotvinTwoOptStarMove>();
for (int tour1 = 0; tour1 < individual.Tours.Count; tour1++) {
for (int tour2 = tour1 + 1; tour2 < individual.Tours.Count; tour2++) {
for (int index1 = 0; index1 <= individual.Tours[tour1].Stops.Count; index1++) {
for (int index2 = 0; index2 <= individual.Tours[tour2].Stops.Count; index2++) {
if ((index1 != individual.Tours[tour1].Stops.Count || index2 != individual.Tours[tour2].Stops.Count) &&
(index1 != 0 || index2 != 0))
result.Add(new PotvinTwoOptStarMove(tour1, index1, tour2, index2, individual));
}
}
}
}
return result.ToArray();
}
public static PotvinPDExchangeMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
List<int> cities = new List<int>();
IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
for (int i = 1; i <= individual.Cities; i++) {
if (pdp == null || pdp.GetDemand(i) >= 0)
cities.Add(i);
}
if (cities.Count > 1 && individual.Tours.Count > 1) {
PotvinPDExchangeMove move = null;
while (cities.Count > 1 && move == null) {
int city = cities[rand.Next(cities.Count)];
Tour oldTour = individual.Tours.Find(t => t.Stops.Contains(city));
int oldTourIndex = individual.Tours.IndexOf(oldTour);
int max = individual.Tours.Count;
if (individual.Tours.Count < problemInstance.Vehicles.Value)
max = max - 1;
int newTourIndex = rand.Next(max);
if (newTourIndex >= oldTourIndex)
newTourIndex++;
Tour newTour = individual.Tours[newTourIndex];
List<int> tourCities = new List<int>();
foreach (int stop in newTour.Stops) {
if (pdp == null ||
(pdp.GetDemand(stop) >= 0 &&
pdp.GetPickupDeliveryLocation(stop) != pdp.GetPickupDeliveryLocation(city) &&
pdp.GetPickupDeliveryLocation(stop) != city &&
pdp.GetPickupDeliveryLocation(city) != stop))
tourCities.Add(stop);
}
if (tourCities.Count > 0) {
int replaced = tourCities[rand.Next(tourCities.Count)];
move = new PotvinPDExchangeMove(city, oldTourIndex, newTourIndex, replaced, individual);
}
}
return move;
} else {
return null;
}
}
public static PotvinEncoding Apply(IRandom random, PotvinEncoding parent1, PotvinEncoding parent2, IVRPProblemInstance problemInstance, bool allowInfeasible) {
PotvinEncoding child = parent1.Clone() as PotvinEncoding;
Tour newTour = new Tour();
int cities = problemInstance.Cities.Value;
if (cities > 0) {
int breakPoint1 = random.Next(1, cities + 1);
Tour tour1 = FindRoute(child, breakPoint1);
breakPoint1 = tour1.Stops.IndexOf(breakPoint1);
for (int i = 0; i < breakPoint1; i++)
newTour.Stops.Add(tour1.Stops[i]);
int breakPoint2 = random.Next(1, cities + 1);
Tour tour2 = FindRoute(parent2, breakPoint2);
breakPoint2 = tour2.Stops.IndexOf(breakPoint2);
for (int i = breakPoint2; i < tour2.Stops.Count; i++)
newTour.Stops.Add(tour2.Stops[i]);
int tour1Index = child.Tours.IndexOf(tour1);
child.Tours.Remove(tour1);
child.Tours.Insert(tour1Index, newTour);
foreach (int city in tour1.Stops)
if (FindRoute(child, city) == null && !child.Unrouted.Contains(city))
child.Unrouted.Add(city);
foreach (int city in tour2.Stops)
if (FindRoute(child, city) == null && !child.Unrouted.Contains(city))
child.Unrouted.Add(city);
if (Repair(random, child, newTour, problemInstance, allowInfeasible) || allowInfeasible) {
return child;
} else {
if (random.NextDouble() < 0.5)
return parent1.Clone() as PotvinEncoding;
else
return parent2.Clone() as PotvinEncoding;
}
} else {
return child;
}
}
