private static CompositionPlan MoveTowardParticle(this CompositionPlan compositionPlan, CompositionPlan target, int columnsToBeMasked, bool maskLeftToRight) { var mask = compositionPlan.GetMask(); if (maskLeftToRight) { for (int i = 0; i < columnsToBeMasked; i++) { if (mask[i] < compositionPlan.TaskServices[i].WebService.Cost && DateTime.Now.Millisecond % 2 == 0) { compositionPlan.TaskServices[i].WebService = target.TaskServices[i].WebService; } } } else { for (int i = compositionPlan.TaskServices.Count - 1; i > compositionPlan.TaskServices.Count - columnsToBeMasked; i--) { if (mask[i] < compositionPlan.TaskServices[i].WebService.Cost && DateTime.Now.Millisecond % 2 == 0) { compositionPlan.TaskServices[i].WebService = target.TaskServices[i].WebService; } } } return(compositionPlan); }
public CompositionPlan Execute(CompositionRequest input, Action <string> display) { display("ICA started...\n"); List <CompositionPlan> countries = input.CreateInitialPopulation().ToList(); countries.ForEach(p => p.PBest = p); List <Empire <CompositionPlan> > empires = CreateInitialEmpires(countries, ((IcaConfig)(input.Config))).ToList(); double iteration = 1; using (System.IO.StreamWriter file = new System.IO.StreamWriter(input.Config.OutputFile)) { file.Flush(); while (empires.Count > 1 && iteration < input.Config.MaxIteration) { foreach (Empire <CompositionPlan> empire in empires) { CompositionPlan globalBest = empires.First().Imperialist; empire //.Assimilate(empire.Imperialist,input.Config.QualityAttributeWeights, input) .CustomAssimilate(globalBest, input.Config.QualityAttributeWeights, input) .UpdateAfterAssimilation() .CalculateCost(((IcaConfig)(input.Config)).Zeta); } empires.NormalizePowers().Compete(); //countries.ForEach(c => // { // c.Revolution(countries, ((IcaConfig)(input.Config)).RevolutionRate); // }); empires.EliminatePowerlessEmpires(); string output = $"iteration {iteration}," + $" empires: {empires.Count}," + // $" best solution:{empires.First().Imperialist}," + $" best cost:{empires.First().Imperialist.Cost}"; file.WriteLine($"{iteration},{empires.First().Imperialist.Cost}"); display(output); iteration++; } } display($"ICA Best Cost: {empires.First().Imperialist.Cost}"); return(empires.First().Imperialist); }
private static CompositionPlan UpdatePBest(this CompositionPlan compositionPlan, PsoConfig psoConfig) { compositionPlan.Cost = compositionPlan.CalculateCost(psoConfig.QualityAttributeWeights); if (compositionPlan.Cost < compositionPlan.PBest.Cost) { compositionPlan.PBest = compositionPlan; } return(compositionPlan); }
public static List <Empire <CompositionPlan> > Compete(this List <Empire <CompositionPlan> > empires) { empires = empires.OrderBy(e => e.TotalCost).ToList(); CompositionPlan weakestColony = empires.Last().Colonies.OrderBy(x => x.Cost).Last(); empires.Last().Colonies.Remove(weakestColony); empires.JoinRandomly(weakestColony); return(empires); }
public static CompositionPlan UpdatePBest(this CompositionPlan compositionPlan, IcaConfig icaConfig) { compositionPlan.Cost = compositionPlan.CalculateCost(icaConfig.QualityAttributeWeights); if (compositionPlan.Cost < compositionPlan.PBest.Cost) { compositionPlan.PBest = compositionPlan; } return(compositionPlan); }
public static IEnumerable <CompositionPlan> CreateInitialPopulation(this CompositionRequest request) { List <CompositionPlan> compositionPlans = new List <CompositionPlan>(); Random random = new Random(); List <List <TaskService> > listOfLists = new List <List <TaskService> >(); foreach (TaskCandidateService taskCandidateServices in request.TaskCandidateServices) { SingleTask task = taskCandidateServices.Task; List <TaskService> taskServices = new List <TaskService>(); foreach (WebService webService in taskCandidateServices.WebServices) { int randomNumber = random.Next(0, taskCandidateServices.WebServices.Count() - 1); TaskService taskService = new TaskService { Task = task, WebService = taskCandidateServices.WebServices.ToList()[randomNumber] }; taskServices.Add(taskService); } listOfLists.Add(taskServices); } for (int i = 0; i < listOfLists[0].Count; i++) { List <TaskService> taskServices = new List <TaskService>(); foreach (List <TaskService> list in listOfLists) { TaskService taskService = list[i]; taskServices.Add(taskService); } CompositionPlan country = new CompositionPlan { Id = i, TaskServices = taskServices }; compositionPlans.Add(country); } return(compositionPlans); }
public static List <double> GetMask(this CompositionPlan compositionPlan, int min = 0, int max = 100) { Random random = new Random(); List <double> maskList = new List <double>(); for (int index = 0; index < compositionPlan.TaskServices.Count; index++) { maskList.Add((double)random.Next(min, max) / 100); } return(maskList); }
public static double CalculateCost(this CompositionPlan compositionPlan, List <QualityAttributeWeight> qualityAttributeWeights) { double cost = 0; foreach (TaskService taskService in compositionPlan.TaskServices) { taskService.WebService.Cost = taskService.WebService .CalculateCost(qualityAttributeWeights); cost += taskService.WebService.Cost; } return(cost / compositionPlan.TaskServices.Count); }
public static CompositionPlan Move(this CompositionPlan compositionPlan, CompositionPlan gBest, PsoConfig psoConfig, List <TaskCandidateService> taskCandidateServices) { int columnsToBeMaskedLocally = (int)(compositionPlan.TaskServices.Count * psoConfig.C1); int columnsToBeMaskedGlobally = compositionPlan.TaskServices.Count - columnsToBeMaskedLocally; Random r = new Random(); int mod = DateTime.Now.Millisecond % 2; bool directionLtr = mod == 1; compositionPlan.MoveTowardParticle(compositionPlan.PBest, columnsToBeMaskedLocally, directionLtr); compositionPlan.MoveTowardParticle(gBest, columnsToBeMaskedGlobally, !directionLtr); compositionPlan.UpdatePBest(psoConfig); return(compositionPlan); }
public static Empire <CompositionPlan> UpdateAfterAssimilation(this Empire <CompositionPlan> empire) { try { empire.Colonies.OrderBy(x => x.Cost); CompositionPlan bestColony = empire.Colonies.OrderBy(x => x.Cost).First(); if (bestColony.Cost < empire.Imperialist.Cost) { CompositionPlan formerImperialist = empire.Imperialist; empire.Imperialist = bestColony; empire.Colonies.Remove(bestColony); empire.Colonies.Add(formerImperialist); } } catch (Exception) { } return(empire); }
public static CompositionPlan Move(this CompositionPlan compositionPlan, CompositionPlan gBest, DpsoConfig DpsoConfig, List <TaskCandidateService> taskCandidateServices) { double mut = (double)1 / DpsoConfig.Tasks.Count; Random r = new Random(); foreach (TaskService taskService in compositionPlan.TaskServices) { double rand1 = (double)r.Next(0, 100) / 100; if (rand1 < mut) { List <WebService> webServices = taskCandidateServices .First(t => t.Task.Equals(taskService.Task)).WebServices; int randomIndex = r.Next(0, webServices.Count - 1); //if (taskService.WebService != webServices[randomIndex]) //{ taskService.WebService = webServices[randomIndex]; //} } else if (rand1 < DpsoConfig.Omega) { break; } else if (rand1 < DpsoConfig.C1 + DpsoConfig.Omega) { taskService.WebService = compositionPlan.PBest.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService; } else { taskService.WebService = gBest.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService; } } compositionPlan.UpdatePBest(DpsoConfig); return(compositionPlan); }
public CompositionPlan Execute(CompositionRequest input, Action <string> display) { display("DPSO started...\n"); List <CompositionPlan> particles = input.CreateInitialPopulation().ToList(); particles.ForEach(p => p.PBest = p); particles.ForEach(p => p.Cost = p.CalculateCost(input.Config.QualityAttributeWeights)); CompositionPlan gBest = particles.GetGlobalBest(); using (System.IO.StreamWriter file = new System.IO.StreamWriter(input.Config.OutputFile)) { file.Flush(); DpsoConfig psoConfig = (DpsoConfig)input.Config; double c1_primary = psoConfig.C1; double c2_primary = psoConfig.C2; for (int i = 0; i < psoConfig.MaxIteration; i++) { psoConfig.C1 = ((psoConfig.MaxIteration - i) * c1_primary + (i * c2_primary)) / psoConfig.MaxIteration; psoConfig.C2 = ((psoConfig.MaxIteration - i) * c2_primary + (i * c1_primary)) / psoConfig.MaxIteration; particles.ForEach(p => { p.Move(gBest, psoConfig, input.TaskCandidateServices.ToList()); gBest = particles.GetGlobalBest(); }); display($"iteration: {i}, Cost: {gBest.Cost}"); file.WriteLine($"{i},{gBest.Cost}"); } } display($"DPSO Best Solution: {gBest}"); return(gBest); }
public static CompositionPlan Revolution(this CompositionPlan country, List <CompositionPlan> countries, double revolutionRate) { Random random = new Random(); double randomNumber = (double)random.Next(0, 100) / 100; if (randomNumber > revolutionRate) { int randomTaskIndex = random.Next(0, country.TaskServices.Count - 1); int randomCountryIndex = random.Next(0, countries.Count); if (!countries[randomCountryIndex].Equals(country)) { country.TaskServices[randomTaskIndex].WebService = countries[randomCountryIndex].TaskServices[randomTaskIndex].WebService; } } return(country); }
private static List <Empire <CompositionPlan> > JoinRandomly(this List <Empire <CompositionPlan> > empires, CompositionPlan country) { double sumNormalizedPowers = empires.Where(e => e.Colonies.Any()).Select(e => e.NormalizedPower).Sum(); double[] probabilities = new double[empires.Count - 1]; Random random = new Random(); for (int i = 0; i < probabilities.Length; i++) { double r = (double)random.Next(0, 100) / 100; probabilities[i] = (empires[i + 1].NormalizedPower / sumNormalizedPowers) - r; } double maxProbability = probabilities.Max(); int maxIndex = probabilities.ToList().IndexOf(maxProbability); empires[maxIndex + 1].Colonies.Add(country); return(empires); }
public static Empire <CompositionPlan> CustomAssimilate(this Empire <CompositionPlan> empire, CompositionPlan gBest, List <QualityAttributeWeight> attributeWeights, CompositionRequest request) { IcaConfig icaConfig = (IcaConfig)request.Config; foreach (CompositionPlan colony in empire.Colonies) { double revolutionRate = (double)1 / icaConfig.Tasks.Count; Random r = new Random(); foreach (TaskService taskService in colony.TaskServices) { double rand1 = (double)r.Next(0, 100) / 100; if (rand1 < revolutionRate) { List <WebService> webServices = request.TaskCandidateServices .First(t => t.Task.Equals(taskService.Task)).WebServices; int randomIndex = r.Next(0, webServices.Count - 1); taskService.WebService = webServices[randomIndex]; } else if (rand1 < icaConfig.Alpha) { if (taskService.WebService.Cost > empire.Imperialist.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService.Cost) { taskService.WebService = empire.Imperialist.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService; } } else if (rand1 < icaConfig.Alpha + icaConfig.Beta) { if (taskService.WebService.Cost > colony.PBest.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService.Cost) { taskService.WebService = colony.PBest.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService; } } else { if (taskService.WebService.Cost > gBest.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService.Cost) { taskService.WebService = gBest.TaskServices .First(t => t.Task.Equals(taskService.Task)).WebService; } } colony.UpdatePBest(icaConfig); } } return(empire); }