static void Main(string[] args)
{
List <Action> actions = new List <Action>();
void DisplayAction(string s) => Console.WriteLine(s);
IcaConfig icaConfig = GetIcaConfig();
PsoConfig psoConfig = GetPsoConfig();
DpsoConfig dpsoConfig = GetDpsoConfig();
IRequestGenerator requestGenerator = new QwsRequestGenerator();
Ica ica = new Ica();
CompositionRequest icaRequest = requestGenerator.Generate(icaConfig);
actions.Add(() => ica.Execute(icaRequest, DisplayAction));
// Pso pso = new Pso();
// CompositionRequest psoRequest = requestGenerator.Generate(psoConfig);
// actions.Add(() => pso.Execute(psoRequest, DisplayAction));
Dpso dpso = new Dpso();
CompositionRequest dpsoRequest = requestGenerator.Generate(dpsoConfig);
// actions.Add(() => dpso.Execute(dpsoRequest, DisplayAction));
for (var i = 0; i < actions.Count; i++)
{
Console.ForegroundColor = i % 2 == 0 ? ConsoleColor.Cyan : ConsoleColor.DarkYellow;
var a = actions[i];
a.Invoke();
}
}
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);
}
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 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);
}
// Launch a job with the specified input file, template and group, to the specified output file. It is hardcoded to PDF.
// Optionally wait until the job is complete before returning.
public static string ComposeJob(string TemplateName, string GroupName, string InputFilePath, string OutputFolder, bool WaitUntilFinished)
{
CompositionRequest request = new CompositionRequest();
CreateCompositionResponse resp = new CreateCompositionResponse();
request.GroupName = GroupName;
request.TemplateName = TemplateName;
request.Options = new JobOptions();
request.Options.OutputFormat = OutputFormat.PDF;
request.Options.UseImposition = true;
try
{
FPQueueWCFServiceClient myFPWcfService = new FPQueueWCFServiceClient();
request.Options.OutputFolder = OutputFolder;
/* Code below is optional to output every record to its own file.
* request.Options.NamedSettings = new KeyValue[]
* {
* new KeyValue { Name = "OutputSource", Value = "bychunk" },
* new KeyValue { Name = "RecordsPerChunk", Value = settings.RecordsPerFile.ToString()},
* new KeyValue { Name = "ReducedRecordsForPreview", Value = "6" }, // whatever you want here
* }; */
resp = myFPWcfService.CreateCompositionSession(request);
if (!String.IsNullOrEmpty(resp.Message))
{
return("Failed to create composition session: " + resp.Message);
}
if (!String.IsNullOrEmpty(InputFilePath))
{
AddCompositionComponentRequest compReq = new AddCompositionComponentRequest();
compReq.Type = FileType.InputData;
compReq.RemoteFilePath = InputFilePath;
compReq.CompositionID = resp.CompositionID;
compReq.ComponentType = FPCompositionComponentType.FromFile;
AddCompositionComponentResponse addResp = new AddCompositionComponentResponse();
addResp = myFPWcfService.AddCompositionFile(compReq);
if (!String.IsNullOrEmpty(addResp.Message))
{
return("Failed to add input file for composition " + resp.CompositionID + ": " + addResp.Message);
}
}
StartCompositionRequest startReq = new StartCompositionRequest();
StartCompositionResponse startResp = new StartCompositionResponse();
startReq.CompositionID = resp.CompositionID;
startResp = myFPWcfService.StartCompositionFromSession(startReq);
if (!String.IsNullOrEmpty(startResp.Message))
{
return("Failed to start composition " + resp.CompositionID + ": " + startResp.Message);
}
if (WaitUntilFinished)
{
while (true)
{
CompositionFilePathURLRequest compFilePathReq = new CompositionFilePathURLRequest();
compFilePathReq.CompositionID = resp.CompositionID;
CompositionStatus status = myFPWcfService.CheckCompositionStatus(compFilePathReq);
if (!String.IsNullOrEmpty(status.Message))
{
return("Failed to add get status of composition " + resp.CompositionID + ": " + status.Message);
}
switch (status.JobStatus)
{
case JobStatus.Cancelled:
case JobStatus.Failed:
case JobStatus.None:
return("Composition " + resp.CompositionID + ": " + status.JobStatus.ToString());
case JobStatus.Queueing:
case JobStatus.InProcess:
//continue;
// Here you can check status.PercentComplete for updates.
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1));
break;
case JobStatus.Done:
if (status.ReturnCode != 0)
{
return("Composition " + resp.CompositionID + " returned error: " + status.ReturnCode);
}
break;
}
}
}
return(""); // no error
}
catch (Exception ex)
{
return(ex.Message);
}
}
public static Empire <CompositionPlan> CustomAssimilate(this Empire <CompositionPlan> empire,
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 (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;
}
}
colony.Cost = colony.CalculateCost(icaConfig.QualityAttributeWeights);
}
}
return(empire);
}
public static Empire <CompositionPlan> Assimilate(this Empire <CompositionPlan> empire,
List <QualityAttributeWeight> attributeWeights, CompositionRequest request)
{
foreach (CompositionPlan colony in empire.Colonies)
{
List <double> mask = colony.GetMask();
for (int i = 0; i < colony.TaskServices.Count; i++)
{
TaskService taskService = colony.TaskServices[i];
if (mask[i] < taskService.WebService.Cost &&
colony.TaskServices[i].WebService.Cost > empire.Imperialist.TaskServices[i].WebService.Cost)
{
colony.TaskServices[i].WebService = empire.Imperialist.TaskServices[i]
.WebService;
//update colony's cost
colony.Cost = colony.CalculateCost(attributeWeights);
}
}
}
return(empire);
}
