Added Methods GetFitnesses, SetFitnesses and a overloaded SetFitness and implemented them

Author: BotMaster3000

NeuralBotMasterFramework/NeuralBotMasterFramework/Interfaces/IGeneticAlgorithm.cs

@@ -26,5 +26,9 @@ public interface IGeneticAlgorithm
         void PropagateAllNetworks();
         void SortByFitness();
         void BreedBestNetworks();
+        double[] GetFitnesses();
+        void SetFitnesses(double[] fitnesses);
+        void SetFitness(int networkIndex, double fitness);
+        void SetFitness(IWeightedNetwork network, double fitness);
     }
 }

NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/Algorithms/GeneticAlgorithm.cs

@@ -206,5 +206,50 @@ private void MutateNetwork(IWeightedNetwork network)
                 }
             }
         }
+
+        public double[] GetFitnesses()
+        {
+            return NetworksAndFitness.Values.ToArray();
+        }
+
+        public void SetFitnesses(double[] fitnesses)
+        {
+            ThrowIfArgumentDoesNotHaveCorrectLength(fitnesses, TotalNetworks);
+
+            Dictionary<IWeightedNetwork, double> tempFitnessAndValues = new Dictionary<IWeightedNetwork, double>();
+            for (int i = 0; i < fitnesses.Length; ++i)
+            {
+                IWeightedNetwork network = NetworksAndFitness.ElementAt(i).Key;
+                tempFitnessAndValues.Add(network, fitnesses[i]);
+            }
+            NetworksAndFitness = tempFitnessAndValues;
+        }
+
+        private void ThrowIfArgumentDoesNotHaveCorrectLength(double[] array, int expectedArrayLength)
+        {
+            if (array.Length != expectedArrayLength)
+            {
+                throw new ArgumentException($"Argument-Length not valid: Expected: {expectedArrayLength} Actual: {array.Length}");
+            }
+        }
+
+        public void SetFitness(int networkIndex, double fitness)
+        {
+            SetFitness(NetworksAndFitness.Keys.ElementAt(networkIndex), fitness);
+        }
+
+        public void SetFitness(IWeightedNetwork network, double fitness)
+        {
+            ThrowIfNetworkNotInDictionary(network);
+            NetworksAndFitness[network] = fitness;
+        }
+
+        private void ThrowIfNetworkNotInDictionary(IWeightedNetwork network)
+        {
+            if (!NetworksAndFitness.Keys.Contains(network))
+            {
+                throw new ArgumentException($"Network not found inside {nameof(NetworksAndFitness)}");
+            }
+        }
     }
 }

NeuralBotMasterFramework/NeuralBotMasterFrameworkTests/Logic/Algorithms/GeneticAlgorithmTests.cs

@@ -20,6 +20,8 @@ public class GeneticAlgorithmTests
         private const int HIDDEN_LAYERS = 3;
         private const int OUTPUT_NODES = 3;
 
+        private readonly GeneticAlgorithm Algorithm = new GeneticAlgorithm(TOTAL_NETWORKS, INPUT_NODES, HIDDEN_NODES, HIDDEN_LAYERS, OUTPUT_NODES);
+
         private double[][] Input = new double[][]
         {
             new double[]
@@ -52,7 +54,6 @@ public class GeneticAlgorithmTests
             },
         };
 
-        private readonly GeneticAlgorithm Algorithm = new GeneticAlgorithm(TOTAL_NETWORKS, INPUT_NODES, HIDDEN_NODES, HIDDEN_LAYERS, OUTPUT_NODES);
 
         [TestMethod]
         public void ConstructorTest()
@@ -165,5 +166,71 @@ public void BreedBestNetworksTest()
                 Assert.IsNotNull(network);
             }
         }
+
+        [TestMethod]
+        public void SetAndGetFitnesses_CorrectFitnessAmount()
+        {
+            double[] fitnessValues = GetRandomDoubleArray(TOTAL_NETWORKS);
+            Algorithm.SetFitnesses(fitnessValues);
+            double[] resultFitnesses = Algorithm.GetFitnesses();
+
+            Assert.AreEqual(fitnessValues.Length, resultFitnesses.Length);
+            for (int i = 0; i < fitnessValues.Length; i++)
+            {
+                Assert.AreEqual(fitnessValues[i], resultFitnesses[i]);
+            }
+        }
+
+        [TestMethod]
+        public void SetFitnesses_MoreFitnessesThanNetworks_ShouldThrowException()
+        {
+            double[] fitnessValues = GetRandomDoubleArray(TOTAL_NETWORKS + 5);
+            Assert.ThrowsException<ArgumentException>(() => Algorithm.SetFitnesses(fitnessValues), "No Exception when more Fitness-Values than Networks");
+        }
+
+        [TestMethod]
+        public void SetFitnesses_LessFitnessesThanNetworks_ShouldThrowException()
+        {
+            const int TOTAL_DOUBLE_VALUES = TOTAL_NETWORKS - 5;
+            double[] fitnessValues = GetRandomDoubleArray(TOTAL_DOUBLE_VALUES >= 0 ? TOTAL_DOUBLE_VALUES : 0);
+            Assert.ThrowsException<ArgumentException>(() => Algorithm.SetFitnesses(fitnessValues), "No Exception when more Fitness-Values than Networks");
+        }
+
+        private double[] GetRandomDoubleArray(int totalValues)
+        {
+            double[] array = new double[totalValues];
+            for (int i = 0; i < array.Length; ++i)
+            {
+                array[i] = RandomNumberGenerator.GetNextDouble();
+            }
+            return array;
+        }
+
+        [TestMethod]
+        public void SetFitness_IWeightedNetworkAsParameter()
+        {
+            double newValue = RandomNumberGenerator.GetNextDouble();
+            IWeightedNetwork network = Algorithm.NetworksAndFitness.Keys.ElementAt(0);
+            Algorithm.SetFitness(network, newValue);
+            Assert.AreEqual(newValue, Algorithm.NetworksAndFitness.FirstOrDefault(x => x.Key == network).Value);
+        }
+
+        [TestMethod]
+        public void SetFitness_IWeightedNetworkAsParameter_NetworkNotFound_ShouldThrowArgumentException()
+        {
+            double newValue = RandomNumberGenerator.GetNextDouble();
+            IWeightedNetwork network = new WeightedNetwork(INPUT_NODES, HIDDEN_LAYERS, HIDDEN_NODES, OUTPUT_NODES);
+            Assert.ThrowsException<ArgumentException>(() => Algorithm.SetFitness(network, newValue), "No Exception when Network not found");
+        }
+
+        [TestMethod]
+        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);
+            Assert.AreEqual(newFitnessValue, networkAndFitness.Value);
+        }
     }
 }