public void Fitness()
        {
            string chromoShort = "G--A-A-T";
            var    list        = GetList(chromoShort);

            Assert.AreEqual(-13, DnaGeneticAlgorithm.Fitness(list, "GAAAAAAT", chromoShort.Replace("-", "")));
        }
 public void CalcFitness()
 {
     Assert.AreEqual(-13, DnaGeneticAlgorithm.CalcFitness("GAAAAAAT".ToCharArray(), "G--A-A-T".ToCharArray()));
     Assert.AreEqual(1, DnaGeneticAlgorithm.CalcFitness("GAAAAAAT".ToCharArray(), "GAA----T".ToCharArray()));
     Assert.AreEqual(-13, DnaGeneticAlgorithm.CalcFitness("G--A-A-T".ToCharArray(), "GAAAAAAT".ToCharArray()));
     Assert.AreEqual(1, DnaGeneticAlgorithm.CalcFitness("GAA----T".ToCharArray(), "GAAAAAAT".ToCharArray()));
 }
        public void SelectChoice()
        {
            List <Tuple <List <int>, int> > population = new List <Tuple <List <int>, int> >()
            {
                new Tuple <List <int>, int>(new List <int> {
                    1, 1, 1
                }, 36),
                new Tuple <List <int>, int>(new List <int> {
                    2, 2, 2
                }, 44),
                new Tuple <List <int>, int>(new List <int> {
                    3, 3, 3
                }, 14),
                new Tuple <List <int>, int>(new List <int> {
                    4, 4, 4
                }, 14),
                new Tuple <List <int>, int>(new List <int> {
                    5, 5, 5
                }, 56),
                new Tuple <List <int>, int>(new List <int> {
                    6, 6, 6
                }, 54),
            };

            Assert.AreEqual(1, DnaGeneticAlgorithm.SelectChoice(population, 0)[0]);
            Assert.AreEqual(2, DnaGeneticAlgorithm.SelectChoice(population, 37)[0]);
            Assert.AreEqual(6, DnaGeneticAlgorithm.SelectChoice(population, 217)[0]);
        }
        public void FitnessSum()
        {
            List <Tuple <List <int>, int> > population = new List <Tuple <List <int>, int> >()
            {
                new Tuple <List <int>, int>(new List <int> {
                    1, 1, 1
                }, 36),
                new Tuple <List <int>, int>(new List <int> {
                    2, 2, 2
                }, 44),
                new Tuple <List <int>, int>(new List <int> {
                    3, 3, 3
                }, 14),
                new Tuple <List <int>, int>(new List <int> {
                    4, 4, 4
                }, 14),
                new Tuple <List <int>, int>(new List <int> {
                    5, 5, 5
                }, 56),
                new Tuple <List <int>, int>(new List <int> {
                    6, 6, 6
                }, 54),
            };

            int fs = DnaGeneticAlgorithm.FitnessesSum(population);

            Assert.AreEqual(218, fs);
        }
        public void CalcFitness3()
        {
            string c1 = "TCTACGTACAAATGGTCCAGAAACGTTATGGCTAAAGTACGTACAATATCATGGGAGAATAGTCC-TCTTGA-GTAC-TA---AGA-GGACTCAGTTTACACCAGTGAGTCCAAGATAAGACTGCCTCTGGGTACAGCACGTCACAGTGTCACCACTTATAGACAGTCAGATTGGTAGTAGGTTCGCTCGGACCCCTCGCCGCGCGGAAGTGTAATGTCCGTCCG";
            string c2 = "-----------------------------------TCTACG-GCGACA-AAT-GGTG-CCCGACCTTCGTGATGTACTTAGCCGGACGAACTCAGTTTGCACCTGTGAGTCCAAGATAAGAGTGCCTCTGGGCGCAGCACGACTC-GT-T----ACGTA-AGA-GGACCCATT--T-G-CGAAT--AACGG-CGAAACG--AC-C---A-T-CGA--TCCAGAAA";

            Assert.AreEqual(-49, DnaGeneticAlgorithm.CalcFitness(c1.ToCharArray(), c2.ToCharArray()));
            Assert.AreEqual(-49, DnaGeneticAlgorithm.CalcFitness(c2.ToCharArray(), c1.ToCharArray()));
        }
        public void GetComparisonChromo()
        {
            string expectedResult = "ab--ef-hi-klmno-";
            var    list           = GetList(expectedResult);

            char[] newChrom = DnaGeneticAlgorithm.GetComparisonChromo(list, "abcdefghijklmnop", expectedResult.Replace("-", ""));
            Assert.AreEqual(expectedResult, new string(newChrom));
        }
        public void GenerateN()
        {
            var n = DnaGeneticAlgorithm.GenerateN(50, 10, 100);

            Assert.AreEqual(50, n.Count());

            n.ForEach(r => System.Diagnostics.Debug.WriteLine(string.Join(",", r)));
        }
 public void Generate_Single()
 {
     for (int i = 0; i < 1000; i++)
     {
         var r = DnaGeneticAlgorithm.Generate(10, 100);
         Assert.AreEqual(10, r.Count());
         Assert.IsFalse(r.Any(s => s >= 100));
         System.Diagnostics.Debug.WriteLine(string.Join(",", r));
     }
 }
        public void Mutate_Random()
        {
            var result = string.Join(",", DnaGeneticAlgorithm.Mutate(c1, 0.5, 100));

            Assert.AreNotEqual(string.Join(",", c1), result);

            for (int i = 0; i < 100; i++)
            {
                System.Diagnostics.Debug.WriteLine(string.Join(",", DnaGeneticAlgorithm.Mutate(c1, 0.5, 100)));
            }
        }
        public void Crossover_Random()
        {
            var result = string.Join(",", DnaGeneticAlgorithm.Crossover(c1, c2));

            Assert.AreNotEqual(string.Join(",", c1), result);
            Assert.AreNotEqual(string.Join(",", c2), result);

            for (int i = 0; i < 100; i++)
            {
                System.Diagnostics.Debug.WriteLine(string.Join(",", DnaGeneticAlgorithm.Crossover(c1, c2)));
            }
        }
 public void Run_GAAAAAAT()
 {
     var result = DnaGeneticAlgorithm.Run("GAAAAAAT", "GAAT", 0.6, 0.002);
 }
        public void Crossover_Reverse1()
        {
            var result = string.Join(",", DnaGeneticAlgorithm.Crossover(c1, c2, 1, true));

            Assert.AreEqual("3,6,7,14,15,23,45", result);
        }
        public void Crossover_Not_Reversed()
        {
            var result = string.Join(",", DnaGeneticAlgorithm.Crossover(c1, c2, 4, false));

            Assert.AreEqual("3,4,5,6,7,8,14", result);
        }