Replaced Dictionary with IList and Adapted Code to it

BotMaster3000 · BotMaster3000 · commit 43b4376beae2 · 2019-04-12T20:46:30.000+02:00
This is because the HashTables in the Dictionary are auto-adjusting the Keys in a way that it could mess up the Algorithm, and when using foreach to, for example, read out the best 10 networks to display them or so, it would then sometimes return random 10 networks in the foreach
diff --git a/NeuralBotMasterFramework/NeuralBotMasterFramework/Interfaces/IBreedingPoolGenerator.cs b/NeuralBotMasterFramework/NeuralBotMasterFramework/Interfaces/IBreedingPoolGenerator.cs
@@ -8,6 +8,6 @@ namespace NeuralBotMasterFramework.Interfaces
 {
     public interface IBreedingPoolGenerator
     {
-        List<IWeightedNetwork> GenerateBreedingPool(Dictionary<IWeightedNetwork, double> networksAndFitness);
+        List<IWeightedNetwork> GenerateBreedingPool(IList<KeyValuePair<IWeightedNetwork, double>> networksAndFitness);
     }
 }
diff --git a/NeuralBotMasterFramework/NeuralBotMasterFramework/Interfaces/IGeneticAlgorithm.cs b/NeuralBotMasterFramework/NeuralBotMasterFramework/Interfaces/IGeneticAlgorithm.cs
@@ -24,7 +24,7 @@ public interface IGeneticAlgorithm
         double[][] CurrentInput { get; }
         double[][] CurrentExpected { get; }
 
-        Dictionary<IWeightedNetwork, double> NetworksAndFitness { get; }
+        IList<KeyValuePair<IWeightedNetwork, double>> NetworksAndFitness { get; }
         void SetupTest(double[][] input, double[][] expected);
         void PropagateAllNetworks();
         void SortByFitness();
diff --git a/NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/Algorithms/GeneticAlgorithm.cs b/NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/Algorithms/GeneticAlgorithm.cs
@@ -17,7 +17,7 @@ public class GeneticAlgorithm : IGeneticAlgorithm
         public int RandomNetworkAmount { get; set; }
         public double MutationRate { get; set; }
         public double MutationChance { get; set; }
-        public Dictionary<IWeightedNetwork, double> NetworksAndFitness { get; private set; } = new Dictionary<IWeightedNetwork, double>();
+        public IList<KeyValuePair<IWeightedNetwork, double>> NetworksAndFitness { get; private set; } = new List<KeyValuePair<IWeightedNetwork, double>>();
         public int InputNodes { get; }
         public int HiddenNodes { get; }
         public int HiddenLayers { get; }
@@ -51,7 +51,7 @@ private void AddNewNetworks(int amount)
 
         private void AddNewNetwork()
         {
-            NetworksAndFitness.Add(new WeightedNetwork(InputNodes, HiddenLayers, HiddenNodes, OutputNodes) { ID = internalIdCounter}, 0);
+            NetworksAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(new WeightedNetwork(InputNodes, HiddenLayers, HiddenNodes, OutputNodes) { ID = internalIdCounter }, 0));
             ++internalIdCounter;
         }
 
@@ -66,10 +66,10 @@ public void PropagateAllNetworks()
             ResetAllFitnesses();
             for (int inputIndex = 0; inputIndex < CurrentInput.Length; inputIndex++)
             {
-                foreach (IWeightedNetwork network in NetworksAndFitness.Keys)
+                foreach (KeyValuePair<IWeightedNetwork, double> networkAndFitness in NetworksAndFitness)
                 {
-                    network.SetInput(CurrentInput[inputIndex]);
-                    network.Propagate();
+                    networkAndFitness.Key.SetInput(CurrentInput[inputIndex]);
+                    networkAndFitness.Key.Propagate();
                 }
                 if (CurrentExpectedIsSet())
                 {
@@ -85,17 +85,17 @@ private bool CurrentExpectedIsSet()
 
         private void ResetAllFitnesses()
         {
-            Dictionary<IWeightedNetwork, double> tempNetworkAndFitness = new Dictionary<IWeightedNetwork, double>();
-            foreach (IWeightedNetwork network in NetworksAndFitness.Keys)
+            IList<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitness = new List<KeyValuePair<IWeightedNetwork, double>>();
+            foreach (KeyValuePair<IWeightedNetwork, double> networkAndFitness in NetworksAndFitness)
             {
-                tempNetworkAndFitness.Add(network, 0);
+                tempNetworkAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(networkAndFitness.Key, 0));
             }
             NetworksAndFitness = tempNetworkAndFitness;
         }
 
         private void CalculateFitnesses(double[] expected)
         {
-            Dictionary<IWeightedNetwork, double> tempNetworkAndFitness = new Dictionary<IWeightedNetwork, double>();
+            IList<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitness = new List<KeyValuePair<IWeightedNetwork, double>>();
             foreach (KeyValuePair<IWeightedNetwork, double> networkAndFitness in NetworksAndFitness)
             {
                 double fitness = networkAndFitness.Value;
@@ -104,14 +104,14 @@ private void CalculateFitnesses(double[] expected)
                 {
                     fitness += 1 / (Math.Pow(output[i] - expected[i], 2) + 1);
                 }
-                tempNetworkAndFitness.Add(networkAndFitness.Key, fitness);
+                tempNetworkAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(networkAndFitness.Key, fitness));
             }
             NetworksAndFitness = tempNetworkAndFitness;
         }
 
         public void SortByFitness()
         {
-            NetworksAndFitness = NetworksAndFitness.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value);
+            NetworksAndFitness = NetworksAndFitness.OrderByDescending(x => x.Value).ToList();
         }
 
         public void BreedBestNetworks()
@@ -123,13 +123,13 @@ public void BreedBestNetworks()
 
         private void RemoveUnneccessaryNetworks()
         {
-            List<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitnessToKeep = NetworksAndFitness.Take(NetworksToKeep).ToList();
-            NetworksAndFitness = tempNetworkAndFitnessToKeep.ToDictionary(x => x.Key, x => x.Value);
+            IList<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitnessToKeep = NetworksAndFitness.Take(NetworksToKeep).ToList();
+            NetworksAndFitness = tempNetworkAndFitnessToKeep.ToList();
         }
 
         private void BreedNewNetworks()
         {
-            List<IWeightedNetwork> networkAndLikelinesToBreed = GetBreedingPool();
+            IList<IWeightedNetwork> networkAndLikelinesToBreed = GetBreedingPool();
             AddNewNetworks(RandomNetworkAmount);
             BreedNetworks(networkAndLikelinesToBreed);
         }
@@ -139,13 +139,13 @@ private List<IWeightedNetwork> GetBreedingPool()
             return PoolGenerator.GenerateBreedingPool(NetworksAndFitness);
         }
 
-        private void BreedNetworks(List<IWeightedNetwork> networkAndLikelinesToBreed)
+        private void BreedNetworks(IList<IWeightedNetwork> networkAndLikelinesToBreed)
         {
             while (NetworksAndFitness.Count < TotalNetworks)
             {
                 int networkIndex = RandomNumberGenerator.GetNextNumber(0, networkAndLikelinesToBreed.Count - 1);
                 IWeightedNetwork network = BreedNewNetwork(networkAndLikelinesToBreed[networkIndex]);
-                NetworksAndFitness.Add(network, 0);
+                NetworksAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(network, 0));
             }
         }
 
@@ -214,18 +214,18 @@ private void MutateNetwork(IWeightedNetwork network)
 
         public double[] GetFitnesses()
         {
-            return NetworksAndFitness.Values.ToArray();
+            return NetworksAndFitness.Select(x => x.Value).ToArray();
         }
 
         public void SetFitnesses(double[] fitnesses)
         {
             ThrowIfArgumentDoesNotHaveCorrectLength(fitnesses, TotalNetworks);
 
-            Dictionary<IWeightedNetwork, double> tempFitnessAndValues = new Dictionary<IWeightedNetwork, double>();
+            IList<KeyValuePair<IWeightedNetwork, double>> tempFitnessAndValues = new List<KeyValuePair<IWeightedNetwork, double>>();
             for (int i = 0; i < fitnesses.Length; ++i)
             {
                 IWeightedNetwork network = NetworksAndFitness.ElementAt(i).Key;
-                tempFitnessAndValues.Add(network, fitnesses[i]);
+                tempFitnessAndValues.Add(new KeyValuePair<IWeightedNetwork, double>(network, fitnesses[i]));
             }
             NetworksAndFitness = tempFitnessAndValues;
         }
@@ -240,18 +240,20 @@ private void ThrowIfArgumentDoesNotHaveCorrectLength(double[] array, int expecte
 
         public void SetFitness(int networkIndex, double fitness)
         {
-            SetFitness(NetworksAndFitness.Keys.ElementAt(networkIndex), fitness);
+            SetFitness(NetworksAndFitness.Select(x => x.Key).ElementAt(networkIndex), fitness);
         }
 
         public void SetFitness(IWeightedNetwork network, double fitness)
         {
             ThrowIfNetworkNotInDictionary(network);
-            NetworksAndFitness[network] = fitness;
+            KeyValuePair<IWeightedNetwork, double> temp = NetworksAndFitness.FirstOrDefault(x => x.Key == network);
+            int index = NetworksAndFitness.IndexOf(temp);
+            NetworksAndFitness[index] = new KeyValuePair<IWeightedNetwork, double>(network, fitness);
         }
 
         private void ThrowIfNetworkNotInDictionary(IWeightedNetwork network)
         {
-            if (!NetworksAndFitness.Keys.Contains(network))
+            if (!NetworksAndFitness.Select(x => x.Key).Contains(network))
             {
                 throw new ArgumentException($"Network not found inside {nameof(NetworksAndFitness)}");
             }
diff --git a/NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/PoolGenerators/FitnessBasedPoolGenerator.cs b/NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/PoolGenerators/FitnessBasedPoolGenerator.cs
@@ -10,10 +10,10 @@ namespace NeuralBotMasterFramework.Logic.PoolGenerators
 {
     public class FitnessBasedPoolGenerator : IBreedingPoolGenerator
     {
-        public List<IWeightedNetwork> GenerateBreedingPool(Dictionary<IWeightedNetwork, double> networksAndFitness)
+        public List<IWeightedNetwork> GenerateBreedingPool(IList<KeyValuePair<IWeightedNetwork, double>> networksAndFitness)
         {
             List<IWeightedNetwork> poolList = new List<IWeightedNetwork>();
-            double[] fitnesses = MultiplyUntilBiggerThanOne(networksAndFitness.Values.ToArray());
+            double[] fitnesses = MultiplyUntilBiggerThanOne(networksAndFitness.Select(x => x.Value).ToArray());
             int totalFitness = (int)Math.Round(fitnesses.Sum(), 0, MidpointRounding.AwayFromZero);
             for (int networkIndex = 0; networkIndex < networksAndFitness.Count; ++networkIndex)
             {
diff --git a/NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/PoolGenerators/IndexBasedPoolGenerator.cs b/NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/PoolGenerators/IndexBasedPoolGenerator.cs
@@ -9,12 +9,12 @@ namespace NeuralBotMasterFramework.Logic.PoolGenerators
 {
     public class IndexBasedPoolGenerator : IBreedingPoolGenerator
     {
-        public List<IWeightedNetwork> GenerateBreedingPool(Dictionary<IWeightedNetwork, double> networksAndFitness)
+        public List<IWeightedNetwork> GenerateBreedingPool(IList<KeyValuePair<IWeightedNetwork, double>> networksAndFitness)
         {
             List<IWeightedNetwork> poolList = new List<IWeightedNetwork>();
             for (int networkIndex = 0; networkIndex < networksAndFitness.Count; ++networkIndex)
             {
-                IWeightedNetwork currentNetwork = networksAndFitness.Keys.ElementAt(networkIndex);
+                IWeightedNetwork currentNetwork = networksAndFitness.Select(x => x.Key).ElementAt(networkIndex);
                 for (int i = 0; i < networksAndFitness.Count - networkIndex; ++i)
                 {
                     poolList.Add(currentNetwork);
diff --git a/NeuralBotMasterFramework/NeuralBotMasterFrameworkTests/Logic/Algorithms/GeneticAlgorithmTests.cs b/NeuralBotMasterFramework/NeuralBotMasterFrameworkTests/Logic/Algorithms/GeneticAlgorithmTests.cs
@@ -107,7 +107,7 @@ public void PropagateAllNetworksTest()
         {
             Algorithm.SetupTest(Input, Expected);
             Algorithm.PropagateAllNetworks();
-            foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Keys)
+            foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Select(x => x.Key))
             {
                 foreach (IWeightedNode node in network.OutputLayer.Nodes)
                 {
@@ -121,7 +121,7 @@ public void PropagateAllNetworksTest_NoExpectedInput()
         {
             Algorithm.SetupTest(Input);
             Algorithm.PropagateAllNetworks();
-            foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Keys)
+            foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Select(x => x.Key))
             {
                 foreach (IWeightedNode node in network.OutputLayer.Nodes)
                 {
@@ -142,7 +142,7 @@ public void SortByFitnessTest()
             double previousHighestNumber = Algorithm.NetworksAndFitness.FirstOrDefault().Value;
             for (int i = 1; i < Algorithm.NetworksAndFitness.Count; ++i)
             {
-                double currentValue = Algorithm.NetworksAndFitness.Values.ElementAt(i);
+                double currentValue = Algorithm.NetworksAndFitness.Select(x => x.Value).ElementAt(i);
                 Assert.IsTrue(previousHighestNumber > currentValue);
                 previousHighestNumber = currentValue;
             }
@@ -161,7 +161,7 @@ public void BreedBestNetworksTest()
             Algorithm.BreedBestNetworks();
 
             Assert.AreEqual(TOTAL_NETWORKS, Algorithm.NetworksAndFitness.Count);
-            foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Keys)
+            foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Select(x => x.Key))
             {
                 Assert.IsNotNull(network);
             }
@@ -210,7 +210,7 @@ private double[] GetRandomDoubleArray(int totalValues)
         public void SetFitness_IWeightedNetworkAsParameter()
         {
             double newValue = RandomNumberGenerator.GetNextDouble();
-            IWeightedNetwork network = Algorithm.NetworksAndFitness.Keys.ElementAt(0);
+            IWeightedNetwork network = Algorithm.NetworksAndFitness.Select(x => x.Key).ElementAt(0);
             Algorithm.SetFitness(network, newValue);
             Assert.AreEqual(newValue, Algorithm.NetworksAndFitness.FirstOrDefault(x => x.Key == network).Value);
         }
@@ -229,7 +229,7 @@ public void SetFitness_NetworkIndexAsParameter()
             int index = RandomNumberGenerator.GetNextNumber(0, Algorithm.NetworksAndFitness.Count);
             double newFitnessValue = RandomNumberGenerator.GetNextDouble();
             Algorithm.SetFitness(index, newFitnessValue);
-            KeyValuePair<IWeightedNetwork, double> networkAndFitness = Algorithm.NetworksAndFitness.ElementAt(index);
+            KeyValuePair<IWeightedNetwork, double> networkAndFitness = Algorithm.NetworksAndFitness[index];
             Assert.AreEqual(newFitnessValue, networkAndFitness.Value);
         }
     }
diff --git a/NeuralBotMasterFramework/NeuralBotMasterFrameworkTests/Logic/PoolGenerators/FitnessBasedPoolGeneratorTests.cs b/NeuralBotMasterFramework/NeuralBotMasterFrameworkTests/Logic/PoolGenerators/FitnessBasedPoolGeneratorTests.cs
@@ -30,7 +30,7 @@ public void GenerateBreedingPoolTest()
             algorithm.PropagateAllNetworks();
             algorithm.SortByFitness();
             FitnessBasedPoolGenerator generator = new FitnessBasedPoolGenerator();
-            List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToDictionary(x => x.Key, x => x.Value));
+            List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToList());
             Assert.IsTrue(networkList.Count > 0);
         }
 
@@ -40,7 +40,7 @@ public void GenerateBreedingPool_ZeroFitnessScore_ShouldIgnoreZeroFitnesses()
         {
             algorithm.SetFitness(0, 100);
             IBreedingPoolGenerator generator = new FitnessBasedPoolGenerator();
-            List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToDictionary(x => x.Key, x => x.Value));
+            List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToList());
             Assert.IsTrue(networkList.Count > 0);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ namespace NeuralBotMasterFramework.Interfaces`
`8`	`8`	`{`
`9`	`9`	`public interface IBreedingPoolGenerator`
`10`	`10`	`{`
`11`		`- List<IWeightedNetwork> GenerateBreedingPool(Dictionary<IWeightedNetwork, double> networksAndFitness);`
	`11`	`+ List<IWeightedNetwork> GenerateBreedingPool(IList<KeyValuePair<IWeightedNetwork, double>> networksAndFitness);`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public class GeneticAlgorithm : IGeneticAlgorithm`
`17`	`17`	`public int RandomNetworkAmount { get; set; }`
`18`	`18`	`public double MutationRate { get; set; }`
`19`	`19`	`public double MutationChance { get; set; }`
`20`		`- public Dictionary<IWeightedNetwork, double> NetworksAndFitness { get; private set; } = new Dictionary<IWeightedNetwork, double>();`
	`20`	`+ public IList<KeyValuePair<IWeightedNetwork, double>> NetworksAndFitness { get; private set; } = new List<KeyValuePair<IWeightedNetwork, double>>();`
`21`	`21`	`public int InputNodes { get; }`
`22`	`22`	`public int HiddenNodes { get; }`
`23`	`23`	`public int HiddenLayers { get; }`
`@@ -51,7 +51,7 @@ private void AddNewNetworks(int amount)`
`51`	`51`
`52`	`52`	`private void AddNewNetwork()`
`53`	`53`	`{`
`54`		`- NetworksAndFitness.Add(new WeightedNetwork(InputNodes, HiddenLayers, HiddenNodes, OutputNodes) { ID = internalIdCounter}, 0);`
	`54`	`+ NetworksAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(new WeightedNetwork(InputNodes, HiddenLayers, HiddenNodes, OutputNodes) { ID = internalIdCounter }, 0));`
`55`	`55`	`++internalIdCounter;`
`56`	`56`	`}`
`57`	`57`
`@@ -66,10 +66,10 @@ public void PropagateAllNetworks()`
`66`	`66`	`ResetAllFitnesses();`
`67`	`67`	`for (int inputIndex = 0; inputIndex < CurrentInput.Length; inputIndex++)`
`68`	`68`	`{`
`69`		`- foreach (IWeightedNetwork network in NetworksAndFitness.Keys)`
	`69`	`+ foreach (KeyValuePair<IWeightedNetwork, double> networkAndFitness in NetworksAndFitness)`
`70`	`70`	`{`
`71`		`- network.SetInput(CurrentInput[inputIndex]);`
`72`		`- network.Propagate();`
	`71`	`+ networkAndFitness.Key.SetInput(CurrentInput[inputIndex]);`
	`72`	`+ networkAndFitness.Key.Propagate();`
`73`	`73`	`}`
`74`	`74`	`if (CurrentExpectedIsSet())`
`75`	`75`	`{`
`@@ -85,17 +85,17 @@ private bool CurrentExpectedIsSet()`
`85`	`85`
`86`	`86`	`private void ResetAllFitnesses()`
`87`	`87`	`{`
`88`		`- Dictionary<IWeightedNetwork, double> tempNetworkAndFitness = new Dictionary<IWeightedNetwork, double>();`
`89`		`- foreach (IWeightedNetwork network in NetworksAndFitness.Keys)`
	`88`	`+ IList<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitness = new List<KeyValuePair<IWeightedNetwork, double>>();`
	`89`	`+ foreach (KeyValuePair<IWeightedNetwork, double> networkAndFitness in NetworksAndFitness)`
`90`	`90`	`{`
`91`		`- tempNetworkAndFitness.Add(network, 0);`
	`91`	`+ tempNetworkAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(networkAndFitness.Key, 0));`
`92`	`92`	`}`
`93`	`93`	`NetworksAndFitness = tempNetworkAndFitness;`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`private void CalculateFitnesses(double[] expected)`
`97`	`97`	`{`
`98`		`- Dictionary<IWeightedNetwork, double> tempNetworkAndFitness = new Dictionary<IWeightedNetwork, double>();`
	`98`	`+ IList<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitness = new List<KeyValuePair<IWeightedNetwork, double>>();`
`99`	`99`	`foreach (KeyValuePair<IWeightedNetwork, double> networkAndFitness in NetworksAndFitness)`
`100`	`100`	`{`
`101`	`101`	`double fitness = networkAndFitness.Value;`
`@@ -104,14 +104,14 @@ private void CalculateFitnesses(double[] expected)`
`104`	`104`	`{`
`105`	`105`	`fitness += 1 / (Math.Pow(output[i] - expected[i], 2) + 1);`
`106`	`106`	`}`
`107`		`- tempNetworkAndFitness.Add(networkAndFitness.Key, fitness);`
	`107`	`+ tempNetworkAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(networkAndFitness.Key, fitness));`
`108`	`108`	`}`
`109`	`109`	`NetworksAndFitness = tempNetworkAndFitness;`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`public void SortByFitness()`
`113`	`113`	`{`
`114`		`- NetworksAndFitness = NetworksAndFitness.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value);`
	`114`	`+ NetworksAndFitness = NetworksAndFitness.OrderByDescending(x => x.Value).ToList();`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`public void BreedBestNetworks()`
`@@ -123,13 +123,13 @@ public void BreedBestNetworks()`
`123`	`123`
`124`	`124`	`private void RemoveUnneccessaryNetworks()`
`125`	`125`	`{`
`126`		`- List<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitnessToKeep = NetworksAndFitness.Take(NetworksToKeep).ToList();`
`127`		`- NetworksAndFitness = tempNetworkAndFitnessToKeep.ToDictionary(x => x.Key, x => x.Value);`
	`126`	`+ IList<KeyValuePair<IWeightedNetwork, double>> tempNetworkAndFitnessToKeep = NetworksAndFitness.Take(NetworksToKeep).ToList();`
	`127`	`+ NetworksAndFitness = tempNetworkAndFitnessToKeep.ToList();`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`private void BreedNewNetworks()`
`131`	`131`	`{`
`132`		`- List<IWeightedNetwork> networkAndLikelinesToBreed = GetBreedingPool();`
	`132`	`+ IList<IWeightedNetwork> networkAndLikelinesToBreed = GetBreedingPool();`
`133`	`133`	`AddNewNetworks(RandomNetworkAmount);`
`134`	`134`	`BreedNetworks(networkAndLikelinesToBreed);`
`135`	`135`	`}`
`@@ -139,13 +139,13 @@ private List<IWeightedNetwork> GetBreedingPool()`
`139`	`139`	`return PoolGenerator.GenerateBreedingPool(NetworksAndFitness);`
`140`	`140`	`}`
`141`	`141`
`142`		`- private void BreedNetworks(List<IWeightedNetwork> networkAndLikelinesToBreed)`
	`142`	`+ private void BreedNetworks(IList<IWeightedNetwork> networkAndLikelinesToBreed)`
`143`	`143`	`{`
`144`	`144`	`while (NetworksAndFitness.Count < TotalNetworks)`
`145`	`145`	`{`
`146`	`146`	`int networkIndex = RandomNumberGenerator.GetNextNumber(0, networkAndLikelinesToBreed.Count - 1);`
`147`	`147`	`IWeightedNetwork network = BreedNewNetwork(networkAndLikelinesToBreed[networkIndex]);`
`148`		`- NetworksAndFitness.Add(network, 0);`
	`148`	`+ NetworksAndFitness.Add(new KeyValuePair<IWeightedNetwork, double>(network, 0));`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`@@ -214,18 +214,18 @@ private void MutateNetwork(IWeightedNetwork network)`
`214`	`214`
`215`	`215`	`public double[] GetFitnesses()`
`216`	`216`	`{`
`217`		`- return NetworksAndFitness.Values.ToArray();`
	`217`	`+ return NetworksAndFitness.Select(x => x.Value).ToArray();`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`public void SetFitnesses(double[] fitnesses)`
`221`	`221`	`{`
`222`	`222`	`ThrowIfArgumentDoesNotHaveCorrectLength(fitnesses, TotalNetworks);`
`223`	`223`
`224`		`- Dictionary<IWeightedNetwork, double> tempFitnessAndValues = new Dictionary<IWeightedNetwork, double>();`
	`224`	`+ IList<KeyValuePair<IWeightedNetwork, double>> tempFitnessAndValues = new List<KeyValuePair<IWeightedNetwork, double>>();`
`225`	`225`	`for (int i = 0; i < fitnesses.Length; ++i)`
`226`	`226`	`{`
`227`	`227`	`IWeightedNetwork network = NetworksAndFitness.ElementAt(i).Key;`
`228`		`- tempFitnessAndValues.Add(network, fitnesses[i]);`
	`228`	`+ tempFitnessAndValues.Add(new KeyValuePair<IWeightedNetwork, double>(network, fitnesses[i]));`
`229`	`229`	`}`
`230`	`230`	`NetworksAndFitness = tempFitnessAndValues;`
`231`	`231`	`}`
`@@ -240,18 +240,20 @@ private void ThrowIfArgumentDoesNotHaveCorrectLength(double[] array, int expecte`
`240`	`240`
`241`	`241`	`public void SetFitness(int networkIndex, double fitness)`
`242`	`242`	`{`
`243`		`- SetFitness(NetworksAndFitness.Keys.ElementAt(networkIndex), fitness);`
	`243`	`+ SetFitness(NetworksAndFitness.Select(x => x.Key).ElementAt(networkIndex), fitness);`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`public void SetFitness(IWeightedNetwork network, double fitness)`
`247`	`247`	`{`
`248`	`248`	`ThrowIfNetworkNotInDictionary(network);`
`249`		`- NetworksAndFitness[network] = fitness;`
	`249`	`+ KeyValuePair<IWeightedNetwork, double> temp = NetworksAndFitness.FirstOrDefault(x => x.Key == network);`
	`250`	`+ int index = NetworksAndFitness.IndexOf(temp);`
	`251`	`+ NetworksAndFitness[index] = new KeyValuePair<IWeightedNetwork, double>(network, fitness);`
`250`	`252`	`}`
`251`	`253`
`252`	`254`	`private void ThrowIfNetworkNotInDictionary(IWeightedNetwork network)`
`253`	`255`	`{`
`254`		`- if (!NetworksAndFitness.Keys.Contains(network))`
	`256`	`+ if (!NetworksAndFitness.Select(x => x.Key).Contains(network))`
`255`	`257`	`{`
`256`	`258`	`throw new ArgumentException($"Network not found inside {nameof(NetworksAndFitness)}");`
`257`	`259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,10 +10,10 @@ namespace NeuralBotMasterFramework.Logic.PoolGenerators`
`10`	`10`	`{`
`11`	`11`	`public class FitnessBasedPoolGenerator : IBreedingPoolGenerator`
`12`	`12`	`{`
`13`		`- public List<IWeightedNetwork> GenerateBreedingPool(Dictionary<IWeightedNetwork, double> networksAndFitness)`
	`13`	`+ public List<IWeightedNetwork> GenerateBreedingPool(IList<KeyValuePair<IWeightedNetwork, double>> networksAndFitness)`
`14`	`14`	`{`
`15`	`15`	`List<IWeightedNetwork> poolList = new List<IWeightedNetwork>();`
`16`		`- double[] fitnesses = MultiplyUntilBiggerThanOne(networksAndFitness.Values.ToArray());`
	`16`	`+ double[] fitnesses = MultiplyUntilBiggerThanOne(networksAndFitness.Select(x => x.Value).ToArray());`
`17`	`17`	`int totalFitness = (int)Math.Round(fitnesses.Sum(), 0, MidpointRounding.AwayFromZero);`
`18`	`18`	`for (int networkIndex = 0; networkIndex < networksAndFitness.Count; ++networkIndex)`
`19`	`19`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,12 @@ namespace NeuralBotMasterFramework.Logic.PoolGenerators`
`9`	`9`	`{`
`10`	`10`	`public class IndexBasedPoolGenerator : IBreedingPoolGenerator`
`11`	`11`	`{`
`12`		`- public List<IWeightedNetwork> GenerateBreedingPool(Dictionary<IWeightedNetwork, double> networksAndFitness)`
	`12`	`+ public List<IWeightedNetwork> GenerateBreedingPool(IList<KeyValuePair<IWeightedNetwork, double>> networksAndFitness)`
`13`	`13`	`{`
`14`	`14`	`List<IWeightedNetwork> poolList = new List<IWeightedNetwork>();`
`15`	`15`	`for (int networkIndex = 0; networkIndex < networksAndFitness.Count; ++networkIndex)`
`16`	`16`	`{`
`17`		`- IWeightedNetwork currentNetwork = networksAndFitness.Keys.ElementAt(networkIndex);`
	`17`	`+ IWeightedNetwork currentNetwork = networksAndFitness.Select(x => x.Key).ElementAt(networkIndex);`
`18`	`18`	`for (int i = 0; i < networksAndFitness.Count - networkIndex; ++i)`
`19`	`19`	`{`
`20`	`20`	`poolList.Add(currentNetwork);`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ public void PropagateAllNetworksTest()`
`107`	`107`	`{`
`108`	`108`	`Algorithm.SetupTest(Input, Expected);`
`109`	`109`	`Algorithm.PropagateAllNetworks();`
`110`		`- foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Keys)`
	`110`	`+ foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Select(x => x.Key))`
`111`	`111`	`{`
`112`	`112`	`foreach (IWeightedNode node in network.OutputLayer.Nodes)`
`113`	`113`	`{`
`@@ -121,7 +121,7 @@ public void PropagateAllNetworksTest_NoExpectedInput()`
`121`	`121`	`{`
`122`	`122`	`Algorithm.SetupTest(Input);`
`123`	`123`	`Algorithm.PropagateAllNetworks();`
`124`		`- foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Keys)`
	`124`	`+ foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Select(x => x.Key))`
`125`	`125`	`{`
`126`	`126`	`foreach (IWeightedNode node in network.OutputLayer.Nodes)`
`127`	`127`	`{`
`@@ -142,7 +142,7 @@ public void SortByFitnessTest()`
`142`	`142`	`double previousHighestNumber = Algorithm.NetworksAndFitness.FirstOrDefault().Value;`
`143`	`143`	`for (int i = 1; i < Algorithm.NetworksAndFitness.Count; ++i)`
`144`	`144`	`{`
`145`		`- double currentValue = Algorithm.NetworksAndFitness.Values.ElementAt(i);`
	`145`	`+ double currentValue = Algorithm.NetworksAndFitness.Select(x => x.Value).ElementAt(i);`
`146`	`146`	`Assert.IsTrue(previousHighestNumber > currentValue);`
`147`	`147`	`previousHighestNumber = currentValue;`
`148`	`148`	`}`
`@@ -161,7 +161,7 @@ public void BreedBestNetworksTest()`
`161`	`161`	`Algorithm.BreedBestNetworks();`
`162`	`162`
`163`	`163`	`Assert.AreEqual(TOTAL_NETWORKS, Algorithm.NetworksAndFitness.Count);`
`164`		`- foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Keys)`
	`164`	`+ foreach (IWeightedNetwork network in Algorithm.NetworksAndFitness.Select(x => x.Key))`
`165`	`165`	`{`
`166`	`166`	`Assert.IsNotNull(network);`
`167`	`167`	`}`
`@@ -210,7 +210,7 @@ private double[] GetRandomDoubleArray(int totalValues)`
`210`	`210`	`public void SetFitness_IWeightedNetworkAsParameter()`
`211`	`211`	`{`
`212`	`212`	`double newValue = RandomNumberGenerator.GetNextDouble();`
`213`		`- IWeightedNetwork network = Algorithm.NetworksAndFitness.Keys.ElementAt(0);`
	`213`	`+ IWeightedNetwork network = Algorithm.NetworksAndFitness.Select(x => x.Key).ElementAt(0);`
`214`	`214`	`Algorithm.SetFitness(network, newValue);`
`215`	`215`	`Assert.AreEqual(newValue, Algorithm.NetworksAndFitness.FirstOrDefault(x => x.Key == network).Value);`
`216`	`216`	`}`
`@@ -229,7 +229,7 @@ public void SetFitness_NetworkIndexAsParameter()`
`229`	`229`	`int index = RandomNumberGenerator.GetNextNumber(0, Algorithm.NetworksAndFitness.Count);`
`230`	`230`	`double newFitnessValue = RandomNumberGenerator.GetNextDouble();`
`231`	`231`	`Algorithm.SetFitness(index, newFitnessValue);`
`232`		`- KeyValuePair<IWeightedNetwork, double> networkAndFitness = Algorithm.NetworksAndFitness.ElementAt(index);`
	`232`	`+ KeyValuePair<IWeightedNetwork, double> networkAndFitness = Algorithm.NetworksAndFitness[index];`
`233`	`233`	`Assert.AreEqual(newFitnessValue, networkAndFitness.Value);`
`234`	`234`	`}`
`235`	`235`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public void GenerateBreedingPoolTest()`
`30`	`30`	`algorithm.PropagateAllNetworks();`
`31`	`31`	`algorithm.SortByFitness();`
`32`	`32`	`FitnessBasedPoolGenerator generator = new FitnessBasedPoolGenerator();`
`33`		`- List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToDictionary(x => x.Key, x => x.Value));`
	`33`	`+ List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToList());`
`34`	`34`	`Assert.IsTrue(networkList.Count > 0);`
`35`	`35`	`}`
`36`	`36`
`@@ -40,7 +40,7 @@ public void GenerateBreedingPool_ZeroFitnessScore_ShouldIgnoreZeroFitnesses()`
`40`	`40`	`{`
`41`	`41`	`algorithm.SetFitness(0, 100);`
`42`	`42`	`IBreedingPoolGenerator generator = new FitnessBasedPoolGenerator();`
`43`		`- List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToDictionary(x => x.Key, x => x.Value));`
	`43`	`+ List<IWeightedNetwork> networkList = generator.GenerateBreedingPool(algorithm.NetworksAndFitness.Take(NETWORKS_TO_KEEP).ToList());`
`44`	`44`	`Assert.IsTrue(networkList.Count > 0);`
`45`	`45`	`}`
`46`	`46`