title: Genetic Algorithm implementation in C#
body: <p>I've recently started working with C# and I'm currently trying to implement a version of <a href="http://www.pg.gda.pl/~mkwies/dyd/geadocu/fcnfun7.html" rel="nofollow">GA to solve Schwefel’s function</a>(See code below). The code is based on a working Processing code that I built. </p>
  
  <p>The first generation(first 100 individuals) seems to work fine but after that the fitness function gets repetitive values. I'm sure I'm missing something here but does anyone know what might be the problem?</p>
  
  <pre><code>    public void button21_Click(object sender, EventArgs e)
      {
          Population p;
          // populationNum = 100;
          p = new Population();
          int gen = 0;
          while (gen &lt; 8000)
          {
              p.evolve();
          }
          ++gen;
      }
  
      //Class Genotype
      public partial class Genotype
      {
          public int[] genes;
  
          public Genotype()
          {
              genes = new int[2];
              for (int i = 0; i &lt; genes.Length; i++)
              {
                  Random rnd = new Random(int.Parse(Guid.NewGuid().ToString().Substring(0, 8), System.Globalization.NumberStyles.HexNumber));
                  //Random rnd = new Random(0);
                  int random = rnd.Next(256);
                  genes[i] = (int)random;
              }
          }
  
          public void mutate()
          {
              //5% mutation rate
              for (int i = 0; i &lt; genes.Length; i++)
              {
                  Random rnd = new Random(int.Parse(Guid.NewGuid().ToString().Substring(0, 8), System.Globalization.NumberStyles.HexNumber));
                  int random = rnd.Next(100);
                  if (random &lt; 5)
                  {
                      //Random genernd = new Random();
                      int generandom = rnd.Next(256);
                      genes[i] = (int)generandom;
                  }
              }
          }
      }
  
      static Genotype crossover(Genotype a, Genotype b)
      {
          Genotype c = new Genotype();
          for (int i = 0; i &lt; c.genes.Length; i++)
          {
              //50-50 chance of selection
              Random rnd = new Random(int.Parse(Guid.NewGuid().ToString().Substring(0, 8), System.Globalization.NumberStyles.HexNumber));
  
              float random = rnd.Next(0, 1);
              if (random &lt; 0.5)
              {
                  c.genes[i] = a.genes[i];
              }
              else
              {
                  c.genes[i] = b.genes[i];
              }
          }
          return c;
      }
  
  
      //Class Phenotype
      public partial class Phenotype
      {
          double i_x;
          double i_y;
  
          public Phenotype(Genotype g)
          {
              i_x = g.genes[0] * 500 / 256;
              i_y = g.genes[1] * 500 / 256;
          }
  
          public double evaluate()
          {
              double fitness = 0;
              fitness -= (-1.0*i_x * Math.Sin(Math.Sqrt(Math.Abs(i_x)))) + (-1.0*i_y * Math.Sin(Math.Sqrt(Math.Abs(i_y))));
              Console.WriteLine(fitness);
              return fitness;  
          }
      }
  
      //Class Individual
      public partial class Individual : IComparable&lt;Individual&gt;
      {
          public Genotype i_genotype;
          public Phenotype i_phenotype;
          double i_fitness;
  
          public Individual()
          {
              this.i_genotype = new Genotype();
              this.i_phenotype = new Phenotype(i_genotype);
              this.i_fitness = 0;
          }
  
          public void evaluate()
          {
              i_fitness = i_phenotype.evaluate();
          }
  
          int IComparable&lt;Individual&gt;.CompareTo(Individual objI)
          {
              Individual iToCompare = (Individual)objI;
              if (i_fitness &lt; iToCompare.i_fitness)
              {
                  return -1; //if I am less fit than iCompare return -1
              }
              else if (i_fitness &gt; iToCompare.i_fitness)
              {
                  return 1; //if I am fitter than iCompare return 1
              }
  
              return 0; // if we are equally return 0
          }
      }
  
      static Individual breed(Individual a, Individual b)
      {
          Individual c = new Individual();
          c.i_genotype = crossover(a.i_genotype, b.i_genotype);
          c.i_genotype.mutate();
          c.i_phenotype = new Phenotype(c.i_genotype);
          return c;
      }
  
      //Class Population
      public class Population
      {
          Individual[] pop;
          int populationNum = 100;
  
          public Population()
          {
              pop = new Individual[populationNum];
              for (int i = 0; i &lt; populationNum; i++)
              {
                  this.pop[i] = new Individual();
                  pop[i].evaluate();
              }
              Array.Sort(this.pop);
          }
  
          public void evolve()
          {
              Individual a = select();
              Individual b = select();
              //breed the two selected individuals
              Individual x = breed(a, b);
              //place the offspring in the lowest position in the population, thus replacing the previously weakest offspring
              pop[0] = x;
              //evaluate the new individual (grow)
              x.evaluate();
              //the fitter offspring will find its way in the population ranks
              Array.Sort(this.pop);
              //rnd = new Random(0);
          }
  
          Individual select()
          {
              Random rnd = new Random(int.Parse(Guid.NewGuid().ToString().Substring(0, 8), System.Globalization.NumberStyles.HexNumber));
              float random = rnd.Next(0, 1);
              //skew distribution; multiplying by 99.999999 scales a number from 0-1 to 0-99, BUT NOT 100
              //the sqrt of a number between 0-1 has bigger possibilities of giving us a smaller number
              //if we subtract that squares number from 1 the opposite is true-&gt; we have bigger possibilities of having a larger number
              int which = (int)Math.Floor(((float)populationNum - 1e-6) * (1.0 - Math.Pow(random, random)));
              return pop[which];
          }
      }
  </code></pre>