protected override void Manipulate(IRandom random, AlbaEncoding individual)
{
int breakPoint1, breakPoint2;
int customer1 = random.Next(ProblemInstance.Cities.Value);
breakPoint1 = FindCustomerLocation(customer1, individual);
int customer2 = random.Next(ProblemInstance.Cities.Value);
breakPoint2 = FindCustomerLocation(customer1, individual);
List <int> visitingOrder = new List <int>();
for (int i = breakPoint1; i <= breakPoint2; i++)
{
if (individual[i] != 0)
{
visitingOrder.Add(individual[i]);
}
}
visitingOrder.Reverse();
for (int i = breakPoint1; i <= breakPoint2; i++)
{
if (individual[i] != 0)
{
individual[i] = visitingOrder[0];
visitingOrder.RemoveAt(0);
}
}
}
protected override void Manipulate(IRandom rand, AlbaEncoding individual)
{
List <Tour> tours = individual.GetTours();
if (tours.Count > 1)
{
int lambda = LambdaParameter.Value.Value;
int route1Index = rand.Next(tours.Count);
Tour route1 = tours[route1Index];
int route2Index = rand.Next(tours.Count - 1);
if (route2Index >= route1Index)
{
route2Index += 1;
}
Tour route2 = tours[route2Index];
int length1 = rand.Next(Math.Min(lambda + 1, route1.Stops.Count + 1));
int index1 = rand.Next(route1.Stops.Count - length1 + 1);
int l2Min = 0;
if (length1 == 0)
{
l2Min = 1;
}
int length2 = rand.Next(l2Min, Math.Min(lambda + 1, route2.Stops.Count + 1));
int index2 = rand.Next(route2.Stops.Count - length2 + 1);
Apply(individual, route1Index, index1, length1,
route2Index, index2, length2);
}
}
protected override void Manipulate(IRandom random, AlbaEncoding individual) {
InnerManipulatorParameter.ActualValue.PermutationParameter.ActualName = VRPToursParameter.ActualName;
IAtomicOperation op = this.ExecutionContext.CreateOperation(
InnerManipulatorParameter.ActualValue, this.ExecutionContext.Scope);
op.Operator.Execute((IExecutionContext)op, CancellationToken);
}
public override IOperation InstrumentedApply()
{
int maxIterations = MaximumIterationsParameter.ActualValue.Value;
AlbaEncoding solution = null;
if (VRPToursParameter.ActualValue is AlbaEncoding)
{
solution = VRPToursParameter.ActualValue as AlbaEncoding;
}
else
{
VRPToursParameter.ActualValue = solution = AlbaEncoding.ConvertFrom(VRPToursParameter.ActualValue, ProblemInstance);
}
int lambda = LambdaParameter.Value.Value;
int samples = SampleSizeParameter.Value.Value;
IRandom random = RandomParameter.ActualValue;
double quality = QualityParameter.ActualValue.Value;
int evaluatedSolutions;
Apply(solution, maxIterations, lambda, samples, random, ProblemInstance, ref quality, out evaluatedSolutions);
EvaluatedSolutionsParameter.ActualValue.Value += evaluatedSolutions;
QualityParameter.ActualValue.Value = quality;
return(base.InstrumentedApply());
}
public override IOperation InstrumentedApply()
{
ItemArray <IVRPEncoding> parents = new ItemArray <IVRPEncoding>(ParentsParameter.ActualValue.Length);
for (int i = 0; i < ParentsParameter.ActualValue.Length; i++)
{
IVRPEncoding solution = ParentsParameter.ActualValue[i];
if (!(solution is AlbaEncoding))
{
parents[i] = AlbaEncoding.ConvertFrom(solution, ProblemInstance);
}
else
{
parents[i] = solution;
}
}
ParentsParameter.ActualValue = parents;
ChildParameter.ActualValue =
Crossover(RandomParameter.ActualValue, parents[0] as AlbaEncoding, parents[1] as AlbaEncoding);
(ChildParameter.ActualValue as AlbaEncoding).Repair();
return(base.InstrumentedApply());
}
public static void Apply(AlbaEncoding solution, int maxIterations,
int lambda, int samples, IRandom random, IVRPProblemInstance problemInstance, ref double quality, out int evaluatedSolutions)
{
evaluatedSolutions = 0;
for (int i = 0; i < maxIterations; i++)
{
AlbaLambdaInterchangeMove bestMove = null;
foreach (AlbaLambdaInterchangeMove move in AlbaStochasticLambdaInterchangeMultiMoveGenerator.GenerateAllMoves(solution, problemInstance, lambda, samples, random))
{
AlbaEncoding newSolution = solution.Clone() as AlbaEncoding;
AlbaLambdaInterchangeMoveMaker.Apply(newSolution, move);
double moveQuality =
problemInstance.Evaluate(newSolution).Quality;
evaluatedSolutions++;
if (moveQuality < quality || quality == -1)
{
quality = moveQuality;
bestMove = move;
}
}
if (bestMove != null)
{
AlbaLambdaInterchangeMoveMaker.Apply(solution, bestMove);
}
}
}
protected override void Manipulate(IRandom random, AlbaEncoding individual) {
AlbaEncoding original = (AlbaEncoding)individual.Clone();
int cutIndex, insertIndex, number;
int customer = random.Next(ProblemInstance.Cities.Value);
cutIndex = FindCustomerLocation(customer, individual);
insertIndex = random.Next(original.Length);
number = original[cutIndex];
int i = 0; // index in new permutation
int j = 0; // index in old permutation
while (i < original.Length) {
if (j == cutIndex) {
j++;
}
if (i == insertIndex) {
individual[i] = number;
i++;
}
if ((i < original.Length) && (j < original.Length)) {
individual[i] = original[j];
i++;
j++;
}
}
}
public static AlbaLambdaInterchangeMove Apply(AlbaEncoding individual, int cities, int lambda, IRandom rand)
{
List <Tour> tours = individual.GetTours();
if (tours.Count > 1)
{
int route1Index = rand.Next(tours.Count);
Tour route1 = tours[route1Index];
int route2Index = rand.Next(tours.Count - 1);
if (route2Index >= route1Index)
{
route2Index += 1;
}
Tour route2 = tours[route2Index];
int length1 = rand.Next(Math.Min(lambda + 1, route1.Stops.Count + 1));
int index1 = rand.Next(route1.Stops.Count - length1 + 1);
int l2Min = 0;
if (length1 == 0)
{
l2Min = 1;
}
int length2 = rand.Next(l2Min, Math.Min(lambda + 1, route2.Stops.Count + 1));
int index2 = rand.Next(route2.Stops.Count - length2 + 1);
return(new AlbaLambdaInterchangeMove(route1Index, index1, length1, route2Index, index2, length2, individual));
}
else
{
return(new AlbaLambdaInterchangeMove(0, 0, 0, 0, 0, 0, individual));
}
}
public static void Apply(AlbaEncoding solution, AlbaLambdaInterchangeMove move)
{
AlbaLambdaInterchangeManipulator.Apply(
solution,
move.Tour1, move.Position1, move.Length1,
move.Tour2, move.Position2, move.Length2);
}
protected override void Manipulate(IRandom random, AlbaEncoding individual)
{
AlbaEncoding original = (AlbaEncoding)individual.Clone();
int cutIndex, insertIndex, number;
int customer = random.Next(ProblemInstance.Cities.Value);
cutIndex = FindCustomerLocation(customer, individual);
insertIndex = random.Next(original.Length);
number = original[cutIndex];
int i = 0; // index in new permutation
int j = 0; // index in old permutation
while (i < original.Length)
{
if (j == cutIndex)
{
j++;
}
if (i == insertIndex)
{
individual[i] = number;
i++;
}
if ((i < original.Length) && (j < original.Length))
{
individual[i] = original[j];
i++;
j++;
}
}
}
protected override AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda) {
List<AlbaLambdaInterchangeMove> moves = new List<AlbaLambdaInterchangeMove>();
List<Tour> tours = individual.GetTours();
for (int tour1Index = 0; tour1Index < tours.Count; tour1Index++) {
Tour tour1 = tours[tour1Index];
for (int tour2Index = tour1Index + 1; tour2Index < tours.Count; tour2Index++) {
Tour tour2 = tours[tour2Index];
for (int length1 = 0; length1 <= Math.Min(lambda, tour1.Stops.Count); length1++) {
for (int length2 = 0; length2 <= Math.Min(lambda, tour2.Stops.Count); length2++) {
if (length1 != 0 || length2 != 0) {
for (int index1 = 0; index1 < tour1.Stops.Count - length1 + 1; index1++) {
for (int index2 = 0; index2 < tour2.Stops.Count - length2 + 1; index2++) {
moves.Add(new AlbaLambdaInterchangeMove(tour1Index, index1, length1,
tour2Index, index2, length2, individual));
}
}
}
}
}
}
}
return moves.ToArray();
}
public static AlbaIntraRouteInversionMove Apply(AlbaEncoding individual, int cities, IRandom rand) {
int index1 = -1;
int index2 = -1;
List<Tour> validTours = new List<Tour>();
foreach (Tour tour in individual.GetTours()) {
if (tour.Stops.Count >= 4)
validTours.Add(tour);
}
if (validTours.Count > 0) {
Tour chosenTour = validTours[rand.Next(validTours.Count)];
int currentTourStart = -1;
for (int i = 0; i < individual.Length; i++) {
if (individual[i] + 1 == chosenTour.Stops[0]) {
currentTourStart = i;
break;
}
}
int currentTourEnd = currentTourStart;
while (currentTourEnd < individual.Length &&
individual[currentTourEnd] < cities) {
currentTourEnd++;
}
int tourLength = currentTourEnd - currentTourStart;
int a = rand.Next(tourLength - 3);
index1 = currentTourStart + a;
index2 = currentTourStart + rand.Next(a + 2, tourLength - 1);
}
return new AlbaIntraRouteInversionMove(index1, index2, individual);
}
protected override AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance) {
List<AlbaIntraRouteInversionMove> moves = new List<AlbaIntraRouteInversionMove>();
int currentTourStart = 0;
int currentTourEnd = 0;
while (currentTourEnd != individual.Length) {
currentTourEnd = currentTourStart;
while (individual[currentTourEnd] < problemInstance.Cities.Value &&
currentTourEnd < individual.Length) {
currentTourEnd++;
}
int tourLength = currentTourEnd - currentTourStart;
if (tourLength >= 4) {
for (int i = 0; i <= tourLength - 4; i++) {
for (int j = i + 2; j <= tourLength - 2; j++) {
AlbaIntraRouteInversionMove move = new AlbaIntraRouteInversionMove(
currentTourStart + i,
currentTourStart + j,
individual);
moves.Add(move);
}
}
}
currentTourStart = currentTourEnd;
}
return moves.ToArray();
}
protected override AlbaEncoding Crossover(IRandom random, AlbaEncoding parent1, AlbaEncoding parent2)
{
//note - the inner crossover is called here and the result is converted to an alba representation
//some refactoring should be done here in the future - the crossover operation should be called directly
if (parent1.Length != parent2.Length)
{
return(parent1.Clone() as AlbaEncoding);
}
InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
IAtomicOperation op = this.ExecutionContext.CreateOperation(
InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
op.Operator.Execute((IExecutionContext)op, CancellationToken);
string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName;
if (ExecutionContext.Scope.Variables.ContainsKey(childName))
{
Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
ExecutionContext.Scope.Variables.Remove(childName);
return(new AlbaEncoding(permutation, ProblemInstance));
}
else
{
return(null);
}
}
public override IOperation InstrumentedApply()
{
//choose default encoding here
VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(CreateSolution(), ProblemInstance);
return(base.InstrumentedApply());
}
protected override void Manipulate(IRandom rand, AlbaEncoding individual) {
int index1 = -1;
int index2 = -1;
List<Tour> validTours = new List<Tour>();
foreach (Tour tour in individual.GetTours()) {
if (tour.Stops.Count >= 4)
validTours.Add(tour);
}
if (validTours.Count > 0) {
Tour chosenTour = validTours[rand.Next(validTours.Count)];
int currentTourStart = -1;
for (int i = 0; i < individual.Length; i++) {
if (individual[i] + 1 == chosenTour.Stops[0]) {
currentTourStart = i;
break;
}
}
int currentTourEnd = currentTourStart;
while (currentTourEnd < individual.Length &&
individual[currentTourEnd] < ProblemInstance.Cities.Value) {
currentTourEnd++;
}
int tourLength = currentTourEnd - currentTourStart;
int a = rand.Next(tourLength - 3);
index1 = currentTourStart + a;
index2 = currentTourStart + rand.Next(a + 2, tourLength - 1);
}
Apply(individual, index1, index2);
}
protected override AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda)
{
List <AlbaLambdaInterchangeMove> moves = new List <AlbaLambdaInterchangeMove>();
List <Tour> tours = individual.GetTours();
for (int tour1Index = 0; tour1Index < tours.Count; tour1Index++)
{
Tour tour1 = tours[tour1Index];
for (int tour2Index = tour1Index + 1; tour2Index < tours.Count; tour2Index++)
{
Tour tour2 = tours[tour2Index];
for (int length1 = 0; length1 <= Math.Min(lambda, tour1.Stops.Count); length1++)
{
for (int length2 = 0; length2 <= Math.Min(lambda, tour2.Stops.Count); length2++)
{
if (length1 != 0 || length2 != 0)
{
for (int index1 = 0; index1 < tour1.Stops.Count - length1 + 1; index1++)
{
for (int index2 = 0; index2 < tour2.Stops.Count - length2 + 1; index2++)
{
moves.Add(new AlbaLambdaInterchangeMove(tour1Index, index1, length1,
tour2Index, index2, length2, individual));
}
}
}
}
}
}
}
return(moves.ToArray());
}
public static AlbaLambdaInterchangeMove Apply(AlbaEncoding individual, int cities, int lambda, IRandom rand) {
List<Tour> tours = individual.GetTours();
if (tours.Count > 1) {
int route1Index = rand.Next(tours.Count);
Tour route1 = tours[route1Index];
int route2Index = rand.Next(tours.Count - 1);
if (route2Index >= route1Index)
route2Index += 1;
Tour route2 = tours[route2Index];
int length1 = rand.Next(Math.Min(lambda + 1, route1.Stops.Count + 1));
int index1 = rand.Next(route1.Stops.Count - length1 + 1);
int l2Min = 0;
if (length1 == 0)
l2Min = 1;
int length2 = rand.Next(l2Min, Math.Min(lambda + 1, route2.Stops.Count + 1));
int index2 = rand.Next(route2.Stops.Count - length2 + 1);
return new AlbaLambdaInterchangeMove(route1Index, index1, length1, route2Index, index2, length2, individual);
} else {
return new AlbaLambdaInterchangeMove(0, 0, 0, 0, 0, 0, individual);
}
}
public static AlbaLambdaInterchangeMove[] GenerateAllMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda, int sampleSize, IRandom rand) {
AlbaLambdaInterchangeMove[] moves = new AlbaLambdaInterchangeMove[sampleSize];
for (int i = 0; i < sampleSize; i++) {
moves[i] = AlbaStochasticLambdaInterchangeSingleMoveGenerator.Apply(
individual, problemInstance.Cities.Value, lambda, rand);
}
return moves;
}
protected override void Manipulate(IRandom random, AlbaEncoding individual)
{
InnerManipulatorParameter.ActualValue.PermutationParameter.ActualName = VRPToursParameter.ActualName;
IAtomicOperation op = this.ExecutionContext.CreateOperation(
InnerManipulatorParameter.ActualValue, this.ExecutionContext.Scope);
op.Operator.Execute((IExecutionContext)op, CancellationToken);
}
public override IOperation InstrumentedApply()
{
IVRPEncoding solution = VRPToursParameter.ActualValue;
if (!(solution is AlbaEncoding))
{
VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, ProblemInstance);
}
return(base.InstrumentedApply());
}
public static void Apply(AlbaEncoding individual, int index1, int index2) {
if (index1 != -1 && index2 != -1) {
int breakPoint1 = index1 + 1;
int breakPoint2 = index2;
for (int i = 0; i <= (breakPoint2 - breakPoint1) / 2; i++) { // invert permutation between breakpoints
int temp = individual[breakPoint1 + i];
individual[breakPoint1 + i] = individual[breakPoint2 - i];
individual[breakPoint2 - i] = temp;
}
}
}
public static AlbaLambdaInterchangeMove[] GenerateAllMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda, int sampleSize, IRandom rand)
{
AlbaLambdaInterchangeMove[] moves = new AlbaLambdaInterchangeMove[sampleSize];
for (int i = 0; i < sampleSize; i++)
{
moves[i] = AlbaStochasticLambdaInterchangeSingleMoveGenerator.Apply(
individual, problemInstance.Cities.Value, lambda, rand);
}
return(moves);
}
protected int FindCustomerLocation(int customer, AlbaEncoding individual) {
int pos = -1;
for (int i = 0; i < individual.Length; i++) {
if (individual[i] == customer) {
pos = i;
break;
}
}
return pos;
}
protected override AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance) {
int sampleSize = SampleSizeParameter.ActualValue.Value;
AlbaIntraRouteInversionMove[] moves = new AlbaIntraRouteInversionMove[sampleSize];
for (int i = 0; i < sampleSize; i++) {
moves[i] = AlbaStochasticIntraRouteInversionSingleMoveGenerator.Apply(
individual, problemInstance.Cities.Value, RandomParameter.ActualValue);
}
return moves;
}
public static void Apply(AlbaEncoding individual, int tour1Index, int position1, int length1,
int tour2Index, int position2, int length2) {
List<Tour> tours = individual.GetTours();
Tour tour1 = tours[tour1Index];
int tour1Start = -1;
for (int i = 0; i < individual.Length; i++) {
if (individual[i] == tour1.Stops[0] - 1) {
tour1Start = i;
break;
}
}
Tour tour2 = tours[tour2Index];
int tour2Start = -1;
for (int i = 0; i < individual.Length; i++) {
if (individual[i] == tour2.Stops[0] - 1) {
tour2Start = i;
break;
}
}
AlbaEncoding original = individual.Clone() as AlbaEncoding;
int index = 0;
int start1 = tour1Start + position1;
int end1 = start1 + length1;
int start2 = tour2Start + position2;
int end2 = start2 + length2;
for (int i = 0; i < original.Length; i++) {
if (index == start1) {
if (end2 - start2 == 0)
index = end1;
else
index = start2;
} else if (index == start2) {
if (end1 - start1 == 0)
index = end2;
else
index = start1;
} else if (index == end1) {
index = end2;
} else if (index == end2) {
index = end1;
}
individual[i] = original[index];
index++;
}
}
public AlbaLambdaInterchangeMove(int tour1, int position1, int length1,
int tour2, int position2, int length2, AlbaEncoding permutation) {
Tour1 = tour1;
Position1 = position1;
Length1 = length1;
Tour2 = tour2;
Position2 = position2;
Length2 = length2;
this.Individual = permutation.Clone() as AlbaEncoding;
}
protected override AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance)
{
int sampleSize = SampleSizeParameter.ActualValue.Value;
AlbaIntraRouteInversionMove[] moves = new AlbaIntraRouteInversionMove[sampleSize];
for (int i = 0; i < sampleSize; i++)
{
moves[i] = AlbaStochasticIntraRouteInversionSingleMoveGenerator.Apply(
individual, problemInstance.Cities.Value, RandomParameter.ActualValue);
}
return(moves);
}
protected override void Manipulate(IRandom random, AlbaEncoding individual) {
int index1, index2, temp;
int customer1 = random.Next(ProblemInstance.Cities.Value);
index1 = FindCustomerLocation(customer1, individual);
int customer2 = random.Next(ProblemInstance.Cities.Value);
index2 = FindCustomerLocation(customer2, individual);
temp = individual[index1];
individual[index1] = individual[index2];
individual[index2] = temp;
}
protected override AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda)
{
List <AlbaLambdaInterchangeMove> moves = new List <AlbaLambdaInterchangeMove>();
AlbaLambdaInterchangeMove move = Apply(individual, problemInstance.Cities.Value, lambda, RandomParameter.ActualValue);
if (move != null)
{
moves.Add(move);
}
return(moves.ToArray());
}
protected override AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance)
{
List <AlbaIntraRouteInversionMove> moves = new List <AlbaIntraRouteInversionMove>();
AlbaIntraRouteInversionMove move = Apply(individual, problemInstance.Cities.Value, RandomParameter.ActualValue);
if (move != null)
{
moves.Add(move);
}
return(moves.ToArray());
}
public AlbaLambdaInterchangeMove(int tour1, int position1, int length1,
int tour2, int position2, int length2, AlbaEncoding permutation)
{
Tour1 = tour1;
Position1 = position1;
Length1 = length1;
Tour2 = tour2;
Position2 = position2;
Length2 = length2;
this.Individual = permutation.Clone() as AlbaEncoding;
}
public override IOperation InstrumentedApply()
{
IVRPEncoding solution = VRPToursParameter.ActualValue;
if (!(solution is AlbaEncoding))
{
VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, ProblemInstance);
}
Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as AlbaEncoding);
(VRPToursParameter.ActualValue as AlbaEncoding).Repair();
return(base.InstrumentedApply());
}
public static void Apply(AlbaEncoding individual, int index1, int index2)
{
if (index1 != -1 && index2 != -1)
{
int breakPoint1 = index1 + 1;
int breakPoint2 = index2;
for (int i = 0; i <= (breakPoint2 - breakPoint1) / 2; i++) // invert permutation between breakpoints
{
int temp = individual[breakPoint1 + i];
individual[breakPoint1 + i] = individual[breakPoint2 - i];
individual[breakPoint2 - i] = temp;
}
}
}
protected int FindCustomerLocation(int customer, AlbaEncoding individual)
{
int pos = -1;
for (int i = 0; i < individual.Length; i++)
{
if (individual[i] == customer)
{
pos = i;
break;
}
}
return(pos);
}
protected override void Manipulate(IRandom random, AlbaEncoding individual)
{
int index1, index2, temp;
int customer1 = random.Next(ProblemInstance.Cities.Value);
index1 = FindCustomerLocation(customer1, individual);
int customer2 = random.Next(ProblemInstance.Cities.Value);
index2 = FindCustomerLocation(customer2, individual);
temp = individual[index1];
individual[index1] = individual[index2];
individual[index2] = temp;
}
public static AlbaEncoding ConvertFrom(IVRPEncoding encoding, IVRPProblemInstance instance)
{
List <Tour> tours = encoding.GetTours();
int cities = 0;
foreach (Tour tour in tours)
{
cities += tour.Stops.Count;
}
int emptyVehicles = instance.Vehicles.Value - tours.Count;
int[] array = new int[cities + tours.Count + emptyVehicles];
int delimiter = 0;
int arrayIndex = 0;
foreach (Tour tour in tours)
{
foreach (int city in tour.Stops)
{
array[arrayIndex] = city - 1;
arrayIndex++;
}
if (arrayIndex != array.Length)
{
array[arrayIndex] = cities + encoding.GetVehicleAssignment(delimiter);
delimiter++;
arrayIndex++;
}
}
for (int i = 0; i < emptyVehicles; i++)
{
array[arrayIndex] = cities + encoding.GetVehicleAssignment(delimiter);
delimiter++;
arrayIndex++;
}
AlbaEncoding solution = new AlbaEncoding(new Permutation(PermutationTypes.RelativeUndirected, new IntArray(array)), instance);
return(solution);
}
public override IOperation InstrumentedApply()
{
IOperation next = base.InstrumentedApply();
AlbaEncoding individual = VRPToursParameter.ActualValue as AlbaEncoding;
AlbaIntraRouteInversionMove[] moves = GenerateMoves(individual, ProblemInstance);
Scope[] moveScopes = new Scope[moves.Length];
for (int i = 0; i < moveScopes.Length; i++)
{
moveScopes[i] = new Scope(i.ToString());
moveScopes[i].Variables.Add(new Variable(IntraRouteInversionMoveParameter.ActualName, moves[i]));
}
CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
return(next);
}
public static AlbaIntraRouteInversionMove Apply(AlbaEncoding individual, int cities, IRandom rand)
{
int index1 = -1;
int index2 = -1;
List <Tour> validTours = new List <Tour>();
foreach (Tour tour in individual.GetTours())
{
if (tour.Stops.Count >= 4)
{
validTours.Add(tour);
}
}
if (validTours.Count > 0)
{
Tour chosenTour = validTours[rand.Next(validTours.Count)];
int currentTourStart = -1;
for (int i = 0; i < individual.Length; i++)
{
if (individual[i] + 1 == chosenTour.Stops[0])
{
currentTourStart = i;
break;
}
}
int currentTourEnd = currentTourStart;
while (currentTourEnd < individual.Length &&
individual[currentTourEnd] < cities)
{
currentTourEnd++;
}
int tourLength = currentTourEnd - currentTourStart;
int a = rand.Next(tourLength - 3);
index1 = currentTourStart + a;
index2 = currentTourStart + rand.Next(a + 2, tourLength - 1);
}
return(new AlbaIntraRouteInversionMove(index1, index2, individual));
}
protected override void Manipulate(IRandom rand, AlbaEncoding individual)
{
int index1 = -1;
int index2 = -1;
List <Tour> validTours = new List <Tour>();
foreach (Tour tour in individual.GetTours())
{
if (tour.Stops.Count >= 4)
{
validTours.Add(tour);
}
}
if (validTours.Count > 0)
{
Tour chosenTour = validTours[rand.Next(validTours.Count)];
int currentTourStart = -1;
for (int i = 0; i < individual.Length; i++)
{
if (individual[i] + 1 == chosenTour.Stops[0])
{
currentTourStart = i;
break;
}
}
int currentTourEnd = currentTourStart;
while (currentTourEnd < individual.Length &&
individual[currentTourEnd] < ProblemInstance.Cities.Value)
{
currentTourEnd++;
}
int tourLength = currentTourEnd - currentTourStart;
int a = rand.Next(tourLength - 3);
index1 = currentTourStart + a;
index2 = currentTourStart + rand.Next(a + 2, tourLength - 1);
}
Apply(individual, index1, index2);
}
protected override AlbaEncoding Crossover(IRandom random, AlbaEncoding parent1, AlbaEncoding parent2) {
//note - the inner crossover is called here and the result is converted to an alba representation
//some refactoring should be done here in the future - the crossover operation should be called directly
if (parent1.Length != parent2.Length)
return parent1.Clone() as AlbaEncoding;
InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
IAtomicOperation op = this.ExecutionContext.CreateOperation(
InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
op.Operator.Execute((IExecutionContext)op, CancellationToken);
string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName;
if (ExecutionContext.Scope.Variables.ContainsKey(childName)) {
Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
ExecutionContext.Scope.Variables.Remove(childName);
return new AlbaEncoding(permutation, ProblemInstance);
} else
return null;
}
protected override void Manipulate(IRandom random, AlbaEncoding individual) {
int breakPoint1, breakPoint2;
int customer1 = random.Next(ProblemInstance.Cities.Value);
breakPoint1 = FindCustomerLocation(customer1, individual);
int customer2 = random.Next(ProblemInstance.Cities.Value);
breakPoint2 = FindCustomerLocation(customer1, individual);
List<int> visitingOrder = new List<int>();
for (int i = breakPoint1; i <= breakPoint2; i++) {
if (individual[i] != 0)
visitingOrder.Add(individual[i]);
}
visitingOrder.Reverse();
for (int i = breakPoint1; i <= breakPoint2; i++) {
if (individual[i] != 0) {
individual[i] = visitingOrder[0];
visitingOrder.RemoveAt(0);
}
}
}
protected override AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance)
{
List <AlbaIntraRouteInversionMove> moves = new List <AlbaIntraRouteInversionMove>();
int currentTourStart = 0;
int currentTourEnd = 0;
while (currentTourEnd != individual.Length)
{
currentTourEnd = currentTourStart;
while (individual[currentTourEnd] < problemInstance.Cities.Value &&
currentTourEnd < individual.Length)
{
currentTourEnd++;
}
int tourLength = currentTourEnd - currentTourStart;
if (tourLength >= 4)
{
for (int i = 0; i <= tourLength - 4; i++)
{
for (int j = i + 2; j <= tourLength - 2; j++)
{
AlbaIntraRouteInversionMove move = new AlbaIntraRouteInversionMove(
currentTourStart + i,
currentTourStart + j,
individual);
moves.Add(move);
}
}
}
currentTourStart = currentTourEnd;
}
return(moves.ToArray());
}
public static void Apply(AlbaEncoding solution, AlbaLambdaInterchangeMove move) {
AlbaLambdaInterchangeManipulator.Apply(
solution,
move.Tour1, move.Position1, move.Length1,
move.Tour2, move.Position2, move.Length2);
}
public static void Apply(AlbaEncoding individual, int tour1Index, int position1, int length1,
int tour2Index, int position2, int length2)
{
List <Tour> tours = individual.GetTours();
Tour tour1 = tours[tour1Index];
int tour1Start = -1;
for (int i = 0; i < individual.Length; i++)
{
if (individual[i] == tour1.Stops[0] - 1)
{
tour1Start = i;
break;
}
}
Tour tour2 = tours[tour2Index];
int tour2Start = -1;
for (int i = 0; i < individual.Length; i++)
{
if (individual[i] == tour2.Stops[0] - 1)
{
tour2Start = i;
break;
}
}
AlbaEncoding original = individual.Clone() as AlbaEncoding;
int index = 0;
int start1 = tour1Start + position1;
int end1 = start1 + length1;
int start2 = tour2Start + position2;
int end2 = start2 + length2;
for (int i = 0; i < original.Length; i++)
{
if (index == start1)
{
if (end2 - start2 == 0)
{
index = end1;
}
else
{
index = start2;
}
}
else if (index == start2)
{
if (end1 - start1 == 0)
{
index = end2;
}
else
{
index = start1;
}
}
else if (index == end1)
{
index = end2;
}
else if (index == end2)
{
index = end1;
}
individual[i] = original[index];
index++;
}
}
public AlbaTranslocationMove(int index1, int index2, int index3, AlbaEncoding individual) :
base(index1, index2, index3, individual.Clone() as AlbaEncoding) {
}
public static void Apply(AlbaEncoding solution, AlbaIntraRouteInversionMove move) {
AlbaIntraRouteInversionManipulator.Apply(solution, move.Index1, move.Index2);
}
protected abstract AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance);
protected AlbaEncoding(AlbaEncoding original, Cloner cloner)
: base(original, cloner)
{
}
protected AlbaEncoding(AlbaEncoding original, Cloner cloner)
: base(original, cloner) {
}
protected abstract AlbaEncoding Crossover(IRandom random, AlbaEncoding parent1, AlbaEncoding parent2);
protected override AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance) {
List<AlbaIntraRouteInversionMove> moves = new List<AlbaIntraRouteInversionMove>();
AlbaIntraRouteInversionMove move = Apply(individual, problemInstance.Cities.Value, RandomParameter.ActualValue);
if (move != null)
moves.Add(move);
return moves.ToArray();
}
protected abstract AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda);
public static void Apply(AlbaEncoding solution, int maxIterations,
int lambda, int samples, IRandom random, IVRPProblemInstance problemInstance, ref double quality, out int evaluatedSolutions) {
evaluatedSolutions = 0;
for (int i = 0; i < maxIterations; i++) {
AlbaLambdaInterchangeMove bestMove = null;
foreach (AlbaLambdaInterchangeMove move in AlbaStochasticLambdaInterchangeMultiMoveGenerator.GenerateAllMoves(solution, problemInstance, lambda, samples, random)) {
AlbaEncoding newSolution = solution.Clone() as AlbaEncoding;
AlbaLambdaInterchangeMoveMaker.Apply(newSolution, move);
double moveQuality =
problemInstance.Evaluate(newSolution).Quality;
evaluatedSolutions++;
if (moveQuality < quality || quality == -1) {
quality = moveQuality;
bestMove = move;
}
}
if (bestMove != null)
AlbaLambdaInterchangeMoveMaker.Apply(solution, bestMove);
}
}
protected override AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda) {
return GenerateAllMoves(individual, problemInstance, lambda, SampleSizeParameter.ActualValue.Value, RandomParameter.ActualValue);
}
protected override AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda) {
List<AlbaLambdaInterchangeMove> moves = new List<AlbaLambdaInterchangeMove>();
AlbaLambdaInterchangeMove move = Apply(individual, problemInstance.Cities.Value, lambda, RandomParameter.ActualValue);
if (move != null)
moves.Add(move);
return moves.ToArray();
}
protected abstract void Manipulate(IRandom random, AlbaEncoding individual);
protected abstract void Manipulate(IRandom random, AlbaEncoding individual);
public static AlbaEncoding ConvertFrom(IVRPEncoding encoding, IVRPProblemInstance instance) {
List<Tour> tours = encoding.GetTours();
int cities = 0;
foreach (Tour tour in tours) {
cities += tour.Stops.Count;
}
int emptyVehicles = instance.Vehicles.Value - tours.Count;
int[] array = new int[cities + tours.Count + emptyVehicles];
int delimiter = 0;
int arrayIndex = 0;
foreach (Tour tour in tours) {
foreach (int city in tour.Stops) {
array[arrayIndex] = city - 1;
arrayIndex++;
}
if (arrayIndex != array.Length) {
array[arrayIndex] = cities + encoding.GetVehicleAssignment(delimiter);
delimiter++;
arrayIndex++;
}
}
for (int i = 0; i < emptyVehicles; i++) {
array[arrayIndex] = cities + encoding.GetVehicleAssignment(delimiter);
delimiter++;
arrayIndex++;
}
AlbaEncoding solution = new AlbaEncoding(new Permutation(PermutationTypes.RelativeUndirected, new IntArray(array)), instance);
return solution;
}
protected override void Manipulate(IRandom rand, AlbaEncoding individual) {
List<Tour> tours = individual.GetTours();
if (tours.Count > 1) {
int lambda = LambdaParameter.Value.Value;
int route1Index = rand.Next(tours.Count);
Tour route1 = tours[route1Index];
int route2Index = rand.Next(tours.Count - 1);
if (route2Index >= route1Index)
route2Index += 1;
Tour route2 = tours[route2Index];
int length1 = rand.Next(Math.Min(lambda + 1, route1.Stops.Count + 1));
int index1 = rand.Next(route1.Stops.Count - length1 + 1);
int l2Min = 0;
if (length1 == 0)
l2Min = 1;
int length2 = rand.Next(l2Min, Math.Min(lambda + 1, route2.Stops.Count + 1));
int index2 = rand.Next(route2.Stops.Count - length2 + 1);
Apply(individual, route1Index, index1, length1,
route2Index, index2, length2);
}
}
