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