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