public override Solution undoStrategy(Solution toStartFrom)
{
if (!strategyHasExecuted)
return toStartFrom;
toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, routeDeleted);
return toStartFrom;
}
public override Solution undoStrategy(Solution toStartFrom)
{
if (!strategyHasExecuted)
return toStartFrom;
toStartFrom.AddRoute(old_route);
toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, new_route);
toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, old_route);
toStartFrom.RemoveRoute(new_route);
return toStartFrom;
}
public override Solution undoStrategy(Solution toStartFrom)
{
if (!strategyHasExecuted)
return toStartFrom;
Route routeRestored = new Route(dayDestroyed);
foreach (Order order in ordersDestroyed)
{
routeRestored.AddOrder(order);
order.RemoveAvailableOrderFromCluster();
}
toStartFrom.AddRoute(routeRestored);
toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, routeRestored);
return toStartFrom;
}
public override Solution undoStrategy(Solution toStartFrom)
{
if (!strategyHasExecuted)
return toStartFrom;
Route[] routesToSwap = new Route[2];
for (int i = 0; i < 2; i++)
routesToSwap[i] = Plans[i].Item3[routeIndicesSwapped[i]];
for (int i = 0; i < 2; i++)
{
toStartFrom.RemoveRouteFromPlanning(Plans[i].Item1, Plans[i].Item2, routesToSwap[i]);
toStartFrom.AddRouteToPlanning(Plans[(i + 1) % 2].Item1, Plans[(i + 1) % 2].Item2, routesToSwap[i]);
}
return toStartFrom;
}
public override Solution undoStrategy(Solution toStartFrom)
{
if (!strategyHasExecuted)
return toStartFrom;
if (OriginalRoute.Orders.Count == 1)
{ // If empty
toStartFrom.AddRoute(OriginalRoute);
toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, OriginalRoute);
}
OrderRemoved.RemoveAvailableOrderFromCluster();
if (OrderBefore == null)
OriginalRoute.AddOrderAtStart(OrderRemoved);
else
OriginalRoute.AddOrderAt(OrderRemoved, OrderBefore);
return toStartFrom;
}
public override Solution executeStrategy(Solution toStartFrom)
{
if (toStartFrom.AvailableRoutes.Count == 0)
return toStartFrom; // No routes to plan
Planning = toStartFrom.GetRandomPlanning();
routePlanned = toStartFrom.AvailableRoutes[random.Next(toStartFrom.AvailableRoutes.Count)];
double totalTravelTime = 0.0d;
foreach (Route route in Planning.Item3)
totalTravelTime += route.TravelTime;
if (routePlanned.Day != Planning.Item1 || totalTravelTime + routePlanned.TravelTime > 43200.0d)
return toStartFrom;
toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, routePlanned);
strategyHasExecuted = true;
return toStartFrom;
}
public override Solution executeStrategy(Solution toStartFrom)
{
Planning = toStartFrom.GetRandomPlanning();
if (Planning.Item3.Count == 0)
return toStartFrom;
old_route = Planning.Item3[random.Next(Planning.Item3.Count)];
if (old_route == null || old_route.Orders.Count < 4)
return toStartFrom; // Could not find a valid route to shuffle
new_route = new Route(Planning.Item1);
foreach (Order order in old_route.Orders)
new_route.AddOrder(order);
int firstIndex = random.Next(old_route.Orders.Count - 1);
int secondIndex = random.Next(old_route.Orders.Count - 1);
int thirdIndex = random.Next(old_route.Orders.Count - 1);
while (firstIndex == secondIndex || firstIndex == thirdIndex || secondIndex == thirdIndex)
return toStartFrom;
double timeLimit = 0.0d; // Check if route can be swapped traveltime-wise
foreach (Route route in Planning.Item3)
if (route != old_route)
timeLimit += route.TravelTime;
timeLimit = 43200.0d - timeLimit;
if (new_route.CanHalfSwapOrder(old_route.Orders[firstIndex], old_route.Orders[thirdIndex], old_route.Orders[thirdIndex], timeLimit))
{
new_route.HalfSwapOrders(old_route.Orders[firstIndex], old_route.Orders[thirdIndex], old_route.Orders[thirdIndex]);
toStartFrom.AddRoute(new_route);
toStartFrom.RemoveRouteFromPlanning(Planning.Item1, Planning.Item2, old_route);
toStartFrom.AddRouteToPlanning(Planning.Item1, Planning.Item2, new_route);
toStartFrom.RemoveRoute(old_route);
strategyHasExecuted = true;
}
return toStartFrom;
}
public override Solution executeStrategy(Solution toStartFrom)
{
for (int i = 0; i < 2; i++)
{
Plans[i] = toStartFrom.GetRandomPlanning();
if (Plans[i].Item3.Count == 0 || (i == 1 && Plans[0].Item1 != Plans[1].Item1)) // Make sure it has routes to swap and is on the same day
return toStartFrom;
routeIndicesSwapped[i] = random.Next(Plans[i].Item3.Count);
if (i == 1 && routeIndicesSwapped[0] == routeIndicesSwapped[1])
return toStartFrom;
}
Route[] routesToSwap = new Route[2];
for (int i = 0; i < 2; i++)
routesToSwap[i] = Plans[i].Item3[routeIndicesSwapped[i]];
for (int i = 0; i < 2; i++) // Check if route can be swapped traveltime-wise
{
double tempTT = 0.0d;
foreach (Route route in Plans[i].Item3)
if(route != routesToSwap[i])
tempTT += route.TravelTime;
tempTT += routesToSwap[(i + 1) % 2].TravelTime;
if (tempTT > 43200.0d)
return toStartFrom;
}
for (int i = 0; i < 2; i++)
{
toStartFrom.RemoveRouteFromPlanning(Plans[i].Item1, Plans[i].Item2, routesToSwap[i]);
toStartFrom.AddRouteToPlanning(Plans[(i + 1) % 2].Item1, Plans[(i + 1) % 2].Item2, routesToSwap[i]);
}
strategyHasExecuted = true;
return toStartFrom;
}
public override Solution undoStrategy(Solution toStartFrom)
{
if (!strategyHasExecuted)
return toStartFrom;
originalRoutes[1].RemoveOrder(ordersShifted[0]);
if (originalRoutes[0].Orders.Count == 1) // if route has only 0order (because other order has been shifted away and the route has been deleted)
{
toStartFrom.AddRoute(originalRoutes[0]);
toStartFrom.AddRouteToPlanning(Plans[0].Item1, Plans[0].Item2, originalRoutes[0]);
}
if (orderInFrontOfTheShiftedOrder != null)
originalRoutes[0].AddOrderAt(ordersShifted[0], orderInFrontOfTheShiftedOrder);
else
originalRoutes[0].AddOrderAtStart(ordersShifted[0]);
return toStartFrom;
}
public override Solution executeStrategy(Solution toStartFrom)
{
planningForSelectedRoute = toStartFrom.GetRandomPlanning();
originalRoute = planningForSelectedRoute.Item3[random.Next(planningForSelectedRoute.Item3.Count)];
double originalTravelTime = originalRoute.TravelTime;
int numOfSlices = random.Next(1, originalRoute.Orders.Count - 2);
List<int> sliceIndices = new List<int>();
for (int i = 1; i < numOfSlices; i++)
{
bool hasAddedAnIndex = false;
do
{
int sliceIndex = random.Next(1, numOfSlices);
if (!sliceIndices.Contains(sliceIndex))
{
sliceIndices.Add(sliceIndex);
hasAddedAnIndex = true;
}
} while (!hasAddedAnIndex);
}
sliceIndices.Sort();
// COMMENCE THE GENETIC EXPERIMENTS!
// OPERATION SLICE & SPLICE AN ABOMINATION IS ACTIVE!
List<Order>[] orderSlices = new List<Order>[sliceIndices.Count];
for (int i = 0; i < sliceIndices.Count; i++)
{
orderSlices[i] = new List<Order>();
int startIndex = i == 0 ? 0 : sliceIndices[i - 1];
for (int j = startIndex; j < sliceIndices[i]; j++)
orderSlices[i].Add(originalRoute.Orders[j]);
}
// Now that you've sliced up the orders in the selected route, it is time for randomizing the slices and putting it back together
Route firstAbominationRoute = new Route(originalRoute.Day);
List<int> slicesIndexPutBack = new List<int>();
for (int i = 0; i < orderSlices.Length - 2; i++)
{
bool hasPutBackASlice = false;
do
{
int sliceIndex = random.Next(1, orderSlices.Length - 1);
if (!slicesIndexPutBack.Contains(sliceIndex))
{
for (int j = 0; j < orderSlices[sliceIndex].Count; j++)
if (orderSlices[sliceIndex][j].OrderNumber != 0)
firstAbominationRoute.AddOrder(orderSlices[sliceIndex][j]);
slicesIndexPutBack.Add(sliceIndex);
hasPutBackASlice = true;
}
} while (!hasPutBackASlice);
}
// COMMENCE THE GENETIC EXPERIMENTS PHASE TWO!
// OPERATION DARWIN'S ABOMINATION REPRODUCTION IS NOW OPERATIONAL!
Route bestBoyAbominationOffspring = originalRoute;
Route bestGirlAbominationOffspring = firstAbominationRoute;
Boolean boyAbominationIsTheBest = bestBoyAbominationOffspring.TravelTime >= bestGirlAbominationOffspring.TravelTime;
int numberOfGenesThatAreTransferred = originalRoute.Orders.Count / 2;
List<Order> ordersSelectedForGeneticSwap = new List<Order>();
for (int numOfGenerationsToMake = 64; numOfGenerationsToMake > 0; numOfGenerationsToMake--)
{
ordersSelectedForGeneticSwap.Clear();
int orderIndex = -1;
do
{
orderIndex = random.Next(orderSlices.Length - 1); // What?
Order randomOrder = null;
if (boyAbominationIsTheBest)
randomOrder = bestBoyAbominationOffspring.Orders[orderIndex];
else
randomOrder = bestGirlAbominationOffspring.Orders[orderIndex];
if (ordersSelectedForGeneticSwap.Contains(randomOrder))
continue;
ordersSelectedForGeneticSwap.Add(randomOrder);
} while (ordersSelectedForGeneticSwap.Count * 2 < numberOfGenesThatAreTransferred - 1);
List<int> indicesToBeSwaped = new List<int>(); // Change into a array [2], to keep track which index belongs where
foreach (Order order in ordersSelectedForGeneticSwap)
{
indicesToBeSwaped.Add(bestBoyAbominationOffspring.Orders.FindIndex(o => o == order));
indicesToBeSwaped.Add(bestGirlAbominationOffspring.Orders.FindIndex(o => o == order));
}
indicesToBeSwaped.Sort();
Route newBoyAbominationOffspring = new Route(originalRoute.Day);
Route newGirlAbominationOffspring = new Route(originalRoute.Day);
for (int index = 0; index < originalRoute.Orders.Count - 1; index++)
{
if (indicesToBeSwaped.Contains(index)) // Erm.. What?
{
newBoyAbominationOffspring.AddOrder(bestGirlAbominationOffspring.Orders[index]);
newGirlAbominationOffspring.AddOrder(bestBoyAbominationOffspring.Orders[index]);
}
else
{
newBoyAbominationOffspring.AddOrder(bestBoyAbominationOffspring.Orders[index]);
newGirlAbominationOffspring.AddOrder(bestGirlAbominationOffspring.Orders[index]);
}
}
if (newBoyAbominationOffspring.isValid() && !newGirlAbominationOffspring.isValid()) // One is allowed
if (bestBoyAbominationOffspring.TravelTime < bestGirlAbominationOffspring.TravelTime)
bestGirlAbominationOffspring = newBoyAbominationOffspring;
else
bestBoyAbominationOffspring = newBoyAbominationOffspring;
else if (!newBoyAbominationOffspring.isValid() && newGirlAbominationOffspring.isValid()) // Other one allowed
if (bestBoyAbominationOffspring.TravelTime < bestGirlAbominationOffspring.TravelTime)
bestGirlAbominationOffspring = newGirlAbominationOffspring;
else
bestBoyAbominationOffspring = newGirlAbominationOffspring;
else if (!newBoyAbominationOffspring.isValid() && !newGirlAbominationOffspring.isValid()) // Neither is allowed
{
numOfGenerationsToMake--;
continue;
}
bool newGirlAbominationOffspringIstheBest = newBoyAbominationOffspring.TravelTime <= newGirlAbominationOffspring.TravelTime;
if (boyAbominationIsTheBest)
{
if (newGirlAbominationOffspringIstheBest)
{
if (bestGirlAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
{
bestGirlAbominationOffspring = newGirlAbominationOffspring;
if (bestBoyAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
{
bestBoyAbominationOffspring = newBoyAbominationOffspring;
}
}
}
else
{
if (bestGirlAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
{
bestGirlAbominationOffspring = newBoyAbominationOffspring;
if (bestBoyAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
{
bestBoyAbominationOffspring = newGirlAbominationOffspring;
}
}
}
}
else
{
if (newGirlAbominationOffspringIstheBest)
{
if (bestBoyAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
{
bestBoyAbominationOffspring = newGirlAbominationOffspring;
if (bestGirlAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
{
bestGirlAbominationOffspring = newBoyAbominationOffspring;
}
}
}
else
{
if (bestBoyAbominationOffspring.TravelTime < newBoyAbominationOffspring.TravelTime)
{
bestBoyAbominationOffspring = newBoyAbominationOffspring;
if (bestGirlAbominationOffspring.TravelTime < newGirlAbominationOffspring.TravelTime)
{
bestGirlAbominationOffspring = newGirlAbominationOffspring;
}
}
}
}
boyAbominationIsTheBest = bestBoyAbominationOffspring.TravelTime >= bestGirlAbominationOffspring.TravelTime;
numOfGenerationsToMake--;
}
// PHASE 3 - INSERT THE ABOMINATION INTO THE PUBLIC!
bestAbominationOffspringRoute = boyAbominationIsTheBest ? bestBoyAbominationOffspring : bestGirlAbominationOffspring;
Console.WriteLine("Original Travel Time: {0}", originalTravelTime); // These three lines are temporarily here
Console.WriteLine("The First Abomination Travel Time: {0}", firstAbominationRoute.TravelTime);
Console.WriteLine("Best Abomination Offspring Travel Time: {0}", bestAbominationOffspringRoute.TravelTime);
toStartFrom.RemoveRouteFromPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, originalRoute);
toStartFrom.AddRouteToPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, bestAbominationOffspringRoute);
return toStartFrom;
}
public override Solution undoStrategy(Solution toStartFrom)
{
// Revert abomination to Patient Zero...
toStartFrom.RemoveRouteFromPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, bestAbominationOffspringRoute);
toStartFrom.AddRouteToPlanning(planningForSelectedRoute.Item1, planningForSelectedRoute.Item2, originalRoute);
return toStartFrom;
}
