Added an option to prune the organisms in the leaderboard, removing those that are obviously not optimal (we have all the inspirationals of that organism plus some extra, while having worse score).

Author: Luaancz

SalemOptimizer/EvaluationState.cs

@@ -32,5 +32,18 @@ public int GetValue(ProficiencyKind kind)
         }
 
         public int Inspiration { get; set; }
+
+        public bool IsSupersetOf(EvaluationState state)
+        {
+            bool anyBigger = false;
+
+            for (var i = 0; i < inspirationalUses.Length; i++)
+            {
+                if (inspirationalUses[i] < state.inspirationalUses[i]) return false;
+                if (inspirationalUses[i] > state.inspirationalUses[i]) anyBigger = true;
+            }
+
+            return anyBigger;
+        }
     }
 }

SalemOptimizer/Leaderboard.cs

@@ -8,26 +8,37 @@ namespace SalemOptimizer
 {
     public class Leaderboard
     {
-        private int slots = 5;
+        private readonly int slots;
+        private readonly bool prune;
         private Organism[] organisms;
 
         private double worst = double.MaxValue;
 
-        public Leaderboard(int slots)
+        public Leaderboard(int slots, bool prune)
         {
             this.slots = slots;
-            this.organisms = new Organism[slots];
+            this.prune = prune;
+            this.organisms = new Organism[0];
         }
 
         public void AddOrganism(Organism organism)
         {
-            if (organism.Solution.CostTotal < worst)
+            if (organism.Solution.CostTotal < worst || organisms.Length < slots)
             {
-                organisms = 
+                var tmp =
                     organisms
-                    .Union(new [] { organism.Clone() })
+                    .Union(new[] { organism.Clone() })
                     .GroupBy(i => i == null ? null : i.ToString())
-                    .Select(i => i.First())
+                    .Select(i => i.First());
+
+                if (prune)
+                {
+                    var tmp2 = tmp.ToArray();
+                    tmp = tmp.Where(j => !tmp2.Any(i => i.Solution.CostTotal < j.Solution.CostTotal && j.IsSupersetOf(i)));
+                }
+
+                organisms =
+                    tmp
                     .OrderBy(i => i == null ? double.MaxValue : i.Solution.CostTotal)
                     .Take(slots)
                     .ToArray();

SalemOptimizer/MainForm.Designer.cs

@@ -150,6 +150,8 @@ private async Task FindSolution(bool useLastBest)
 
                 UseWaitCursor = true;
 
+                var prune = cbxPrune.Checked;
+
                 var problem =
                     new Problem()
                     .Add(ProficiencyKind.ArtsAndCrafts, nudArtsAndCrafts.Value)
@@ -172,29 +174,25 @@ private async Task FindSolution(bool useLastBest)
 
                 cancellationTokenSource = new CancellationTokenSource();
 
-                var solvers = Enumerable.Range(1, 4).Select(i => Task.Run(() => new Solver(problem, availableInspirationals, cancellationTokenSource.Token, useLastBest ? bestOrganisms : null).Solve())).ToArray();
+                var solvers = Enumerable.Range(1, 4).Select(i => Task.Run(() => new Solver(problem, availableInspirationals, cancellationTokenSource.Token, useLastBest ? bestOrganisms : null).Solve(prune))).ToArray();
 
                 var best = await Task.WhenAll(solvers);
 
                 // Aggregate the best results and fill them into the results control
-                var bestOfAll =
-                    best
-                    .SelectMany(i => i)
-                    .Select(i => new { Name = i.ToString(), Organism = i, Solution = i.Solution })
-                    .GroupBy(i => i.Name)
-                    .Select(i => i.First())
-                    .OrderBy(i => i.Solution.CostTotal)
-                    .Take(5)
-                    .ToArray();
-
-                bestOrganisms = bestOfAll.Select(i => i.Organism.Clone()).ToArray();
+                var leaderboard = new Leaderboard(5, prune);
+
+                foreach (var organism in best.SelectMany(i => i)) leaderboard.AddOrganism(organism);
+
+                var bestOfAll = leaderboard.GetBest();
+
+                bestOrganisms = bestOfAll.Select(i => i.Clone()).ToArray();
 
                 lvSolutions.Items.Clear();
 
                 foreach (var organism in bestOfAll)
                 {
                     var lvi = new ListViewItem();
-                    lvi.Text = organism.Name;
+                    lvi.Text = organism.ToString();
                     lvi.ForeColor = organism.Solution.IncompletenessPenalty == 0 ? Color.Green : Color.Red;
                     lvi.SubItems.Add(organism.Solution.CostTotal.ToString("###,###,###"));
                     lvSolutions.Items.Add(lvi);

SalemOptimizer/MainForm.cs

@@ -11,35 +11,43 @@ public class Organism
         private Problem problem;
 
         public SolutionInformation Solution = new SolutionInformation { CostTotal = int.MaxValue };
+        private EvaluationState lastEvaluation;
 
         public Organism(Solver solver, Problem problem)
         {
             this.solver = solver;
             this.problem = problem;
 
             root = new InspirationalBranch(solver) { LeftNode = new InspirationalBranch(solver), RightNode = new InspirationalBranch(solver) };
-            Solution = Evaluate(root, problem);
+            lastEvaluation = new EvaluationState();
+            Solution = Evaluate(root, lastEvaluation, problem);
         }
 
+        public bool IsSupersetOf(Organism organism)
+        {
+            if (lastEvaluation == null || organism.lastEvaluation == null) return false;
+
+            return lastEvaluation.IsSupersetOf(organism.lastEvaluation);
+        }
+
         public override string ToString()
         {
             return root.GetNames();
         }
 
-        public static SolutionInformation Evaluate(InspirationalBranch root, Problem problem)
+        private static SolutionInformation Evaluate(InspirationalBranch root, EvaluationState state, Problem problem)
         {
-            EvaluationState engine = new EvaluationState();
-            root.Evaluate(engine);
+            root.Evaluate(state);
 
             var cost = new SolutionInformation();
 
             // Add the total inspiration cost
-            cost.InspirationTotal += engine.Inspiration;
+            cost.InspirationTotal += state.Inspiration;
 
             // Add extra cost for incomplete solutions
             foreach (var needed in problem.Proficiencies)
             {
-                cost.IncompletenessPenalty += Math.Max(0d, needed.Value - engine.GetValue(needed.Key)) * 1000;
+                cost.IncompletenessPenalty += Math.Max(0d, needed.Value - state.GetValue(needed.Key)) * 1000;
             }
 
             cost.CostTotal = cost.InspirationTotal + cost.IncompletenessPenalty;
@@ -54,16 +62,21 @@ public void Tick()
             clone = (InspirationalBranch)root.Clone();
             clone.Mutate();
 
-            var engineNew = new EvaluationState();
-            var engineOld = new EvaluationState();
+            var stateNew = new EvaluationState();
+            var stateOld = new EvaluationState();
 
-            var newResult = Evaluate(clone, problem);
-            var oldResult = Evaluate(root, problem);
+            var newResult = Evaluate(clone, stateNew, problem);
+            var oldResult = Evaluate(root, stateOld, problem);
 
             if (newResult.CostTotal < oldResult.CostTotal || Helper.Mutate(10))
             {
                 root = clone;
                 Solution = newResult;
+                lastEvaluation = stateNew;
+            }
+            else 
+            {
+                lastEvaluation = stateOld;
             }
         }
 
@@ -72,6 +85,7 @@ public Organism Clone()
             Organism clone = new Organism(solver, problem);
             clone.root = this.root.Clone();
             clone.Solution = this.Solution;
+            clone.lastEvaluation = lastEvaluation;
             return clone;
         }
 
@@ -83,7 +97,9 @@ public Organism MakeCrossOver(Organism father)
             motherDna.LeftNode = fatherDna.LeftNode;
             motherDna.RightNode = fatherDna.RightNode;
 
-            child.Solution = Evaluate(child.root, problem);
+            var state = new EvaluationState();
+            child.Solution = Evaluate(child.root, state, problem);
+            child.lastEvaluation = state;
             return child;
         }
 

SalemOptimizer/Organism.cs

@@ -32,6 +32,6 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.4.0.0")]
-[assembly: AssemblyFileVersion("1.4.0.0")]
-[assembly: AssemblyInformationalVersion("26. 1. 2015")]
+[assembly: AssemblyVersion("1.5.0.0")]
+[assembly: AssemblyFileVersion("1.5.0.0")]
+[assembly: AssemblyInformationalVersion("29. 1. 2015")]

SalemOptimizer/Properties/AssemblyInfo.cs

@@ -24,9 +24,9 @@ public Solver(Problem problem, Inspirational[] availableInspirationals, Cancella
 
         public Inspirational[] AvailableInspirationals { get { return availableInspirationals; } }
 
-        public Organism[] Solve()
+        public Organism[] Solve(bool prune)
         {
-            var leaderboard = new Leaderboard(5);
+            var leaderboard = new Leaderboard(5, prune);
 
             var organisms = new List<Organism>();
             var generations = 0;