public override Solution executeStrategy(Solution toStartFrom)
{
var dayArray = Enum.GetValues(typeof(Days));
Days day = (Days)dayArray.GetValue(random.Next(1, dayArray.Length));
if (day.Equals(Days.None))
Console.WriteLine("Day is Days.None at RouteAddStrategy! FIX ME!");
routeCreated = new Route(day);
var allClusters = toStartFrom.GetAllClusters();
int clusterIndex = random.Next(allClusters.Count);
for (int i = 0; i < 16; i++) //64 -> 16
{
clusterIndex = random.Next(allClusters.Count);
if (allClusters[clusterIndex].AvailableOrdersInCluster.Count == 0)
continue;
int randomIndex = random.Next(allClusters[clusterIndex].AvailableOrdersInCluster.Count);
Order order = allClusters[clusterIndex].AvailableOrdersInCluster[randomIndex];
if (!routeCreated.CanAddOrder(order))
continue;
routeCreated.AddOrder(order);
order.RemoveAvailableOrderFromCluster();
}
if (routeCreated.Orders.Count > 1) // Does the route have orders added to it
{
toStartFrom.AddRoute(routeCreated);
strategyHasExecuted = true;
}
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);
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)
{
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 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;
}
