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 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; }
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 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); }
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 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 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);
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); } }