public void Genetic_Algorithm_With_Order_Initialization()
        {
            // Parent Generation - initial Generation
            Generation generation = Initialization_With_Order();

            Evaluate_Population(generation);
            GenerationCollection.Add(generation);

            // Childs Generation
            int        Individual_1 = 0;
            Individual New_Individual;
            Generation NewGeneration;

            for (int n = 0; n < NumberOfGeneration; n++)
            {
                NewGeneration = (Generation)generation.Clone();
                double tempcost = 0;
                string msg      = "";
                for (int i = 0; i < generation.People.Count; i++)
                {
                    tempcost += (double)(1 / generation.People[i].fitness);
                    generation.People[i].cost = tempcost;
                    msg += i.ToString() + generation.People[i].cost.ToString() + "  " + (1 / generation.People[i].fitness).ToString() + Environment.NewLine;
                }

                for (int i = 0; i < UpdatePercentage; i++)
                {
                    Individual_1 = RouletteSelection(generation);

                    New_Individual = GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_1);
                    New_Individual = Mutation(New_Individual);

                    NewGeneration.People.ElementAt(generation.People.Count - 1 - i).chromosome = null;

                    NewGeneration.People.RemoveAt(generation.People.Count - 1 - i);
                    NewGeneration.People.Insert(generation.People.Count - 1 - i, New_Individual);
                    New_Individual.fitness = CalcFitness(New_Individual);
                }
                SortByFitness(NewGeneration);
                GenerationCollection.Add(NewGeneration);

                Initialization_Order_Fitness.Add(NewGeneration.People[0].fitness);

                generation = NewGeneration;

                if (NewGeneration.People[0].fitness <= 0)
                {
                    break;
                }
            }
        }
        public void Genetic_Algorithm_With_RandomInitalization()
        {
            Individual Random_individual;

            // Parent Generation
            Generation generation = Initialization();

            Evaluate_Population(generation);
            GenerationCollection.Add(generation);

            // Childs Generations
            int        Individual_1 = 0;
            int        Individual_2 = 0;
            Individual New_Individual;
            Generation NewGeneration;

            for (int n = 0; n < NumberOfGeneration; n++)
            {
                NewGeneration = (Generation)generation.Clone();
                double tempcost = 0;
                string msg      = "";
                for (int i = 0; i < generation.People.Count; i++)
                {
                    tempcost += (double)(1 / generation.People[i].fitness);
                    generation.People[i].cost = tempcost;
                    msg += i.ToString() + generation.People[i].cost.ToString() + "  " + (1 / generation.People[i].fitness).ToString() + Environment.NewLine;
                }

                for (int i = 0; i < UpdatePercentage; i++)
                {
                    Individual_1 = RouletteSelection(generation);
                    Individual_2 = RouletteSelection(generation);
                    while (Individual_1 == Individual_2)
                    {
                        Individual_2 = RouletteSelection(generation);
                    }


                    // New_Individual = GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(0);
                    if (rand.NextDouble() < 0.5)
                    {
                        New_Individual = CrossOver(GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_1), GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_2));
                    }
                    else if (rand.NextDouble() < 0.6)
                    {
                        New_Individual = CrossOver2(GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_1), GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_2));
                    }
                    else
                    {
                        New_Individual               = GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(0);
                        Random_individual            = new Individual();
                        Random_individual.chromosome = New_Individual.chromosome.OrderBy(x => rand.Next()).ToList();
                        Random_individual.fitness    = New_Individual.fitness;
                        New_Individual               = (Individual)Random_individual.Clone();
                        Random_individual            = null;
                    }

                    NewGeneration.People.ElementAt(generation.People.Count - 1 - i).chromosome = null;

                    NewGeneration.People.RemoveAt(generation.People.Count - 1 - i);
                    NewGeneration.People.Insert(generation.People.Count - 1 - i, New_Individual);
                    New_Individual.fitness = CalcFitness(New_Individual);
                }
                SortByFitness(NewGeneration);
                GenerationCollection.Add(NewGeneration);

                Initialization_Random_Fitness.Add(NewGeneration.People[0].fitness);

                generation = NewGeneration;

                if (NewGeneration.People[0].fitness <= 0)
                {
                    break;
                }
            }
        }
        public void Genetic_Algorithm()
        {
            Individual Random_individual;

            // Parent Generation
            Generation generation = Initialization();

            Evaluate_Population(generation);
            GenerationCollection.Add(generation);

            // Childs Generations
            int        Individual_1 = 0;
            int        Individual_2 = 0;
            Individual New_Individual;
            Generation NewGeneration;

            int NO_Generation            = 0;
            int Draw_Each_Num_Generation = Convert.ToInt32(ProgramSettings.Default.DrawEachNumGeneration);

            int Free_in_Generation = 0;

            if (MainForm.Rectangles.Count < 50)
            {
                Free_in_Generation = 1000;
            }
            else if (MainForm.Rectangles.Count < 100)
            {
                Free_in_Generation = 500;
            }
            else if (MainForm.Rectangles.Count < 200)
            {
                Free_in_Generation = 300;
            }
            else if (MainForm.Rectangles.Count < 400)
            {
                Free_in_Generation = 100;
            }
            else if (MainForm.Rectangles.Count < 1000)
            {
                Free_in_Generation = 75;
            }
            else
            {
                Free_in_Generation = 30;
            }

            while (true)
            {
                IS_Finished = false;

                NO_Generation++;
                int GenFree = 0;
                if (NO_Generation % Free_in_Generation == 0)
                {
                    for (int i = GenFree; i < GenerationCollection.Count - 2; i++)
                    {
                        for (int j = 1; j < GenerationCollection[i].People.Count; j++)
                        {
                            for (int k = 0; k < GenerationCollection[i].People[j].chromosome.Count; k++)
                            {
                                GenerationCollection[i].People[j].chromosome[k] = null;
                                GenerationCollection[i].People[j].chromosome.RemoveAt(k);
                                k = 0;
                            }
                            GenerationCollection[i].People[j] = null;
                            GenerationCollection[i].People.RemoveAt(j);
                            j = 1;
                        }
                    }
                    GenFree += 1000;
                    GC.Collect();
                }
                NewGeneration = (Generation)generation.Clone();
                double tempcost = 0;
                string msg      = "";
                for (int i = 0; i < generation.People.Count; i++)
                {
                    tempcost += (double)(1 / generation.People[i].fitness);
                    generation.People[i].cost = tempcost;
                    msg += i.ToString() + generation.People[i].cost.ToString() + "  " + (1 / generation.People[i].fitness).ToString() + Environment.NewLine;
                }

                totalFitness = 0;
                for (int i = 0; i < generation.People.Count; i++)
                {
                    totalFitness += generation.People[i].fitness;
                }

                for (int i = 0; i < NumOfIndividualToUpdate; i++)
                {
                    Individual_1 = RouletteWheelSelection(totalFitness, generation);
                    Individual_2 = RouletteWheelSelection(totalFitness, generation);

                    if (rand.NextDouble() < 0.5)
                    {
                        New_Individual = CrossOver(GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_1), GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_2));
                    }
                    else if (rand.NextDouble() < 0.6)
                    {
                        New_Individual = CrossOver2(GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_1), GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(Individual_2));
                    }
                    else
                    {
                        New_Individual               = GenerationCollection[GenerationCollection.Count - 1].People.ElementAt(0);
                        Random_individual            = new Individual();
                        Random_individual.chromosome = New_Individual.chromosome.OrderBy(x => rand.Next()).ToList();
                        Random_individual.fitness    = New_Individual.fitness;
                        New_Individual               = (Individual)Random_individual.Clone();
                        Random_individual            = null;
                    }

                    if (rand.NextDouble() < 0.8)
                    {
                        New_Individual = Mutation(New_Individual);
                    }

                    NewGeneration.People.ElementAt(generation.People.Count - 1 - i).chromosome = null;

                    NewGeneration.People.RemoveAt(generation.People.Count - 1 - i);
                    NewGeneration.People.Insert(generation.People.Count - 1 - i, New_Individual);
                    New_Individual.fitness = CalcFitness(New_Individual);
                }
                SortByFitness(NewGeneration);

                if (EnterNewIndividualcheckBox.Checked)
                {
                    int sizeofNew = (20 * Convert.ToInt32(ProgramSettings.Default.PopulationSize)) / 100;

                    NewGeneration.People.RemoveRange(NewGeneration.People.Count - 1 - sizeofNew, sizeofNew);

                    Individual Randomindividual = null;

                    for (int i = 0; i < sizeofNew; i++)
                    {
                        Randomindividual            = new Individual();
                        Randomindividual.chromosome = NewGeneration.People[0].chromosome.OrderBy(x => rand.Next()).ToList();
                        Randomindividual.fitness    = CalcFitness(Randomindividual);
                        New_Individual = (Individual)Randomindividual.Clone();

                        NewGeneration.People.Insert(NewGeneration.People.Count - 1, New_Individual);

                        Random_individual = null;
                    }
                    SortByFitness(NewGeneration);
                }

                GenerationCollection.Add(NewGeneration);

                generation = NewGeneration;

                MethodInvoker action = delegate
                {
                    numberGenerationLabel.Text = NO_Generation.ToString();
                    bestFitnesslabel.Text      = (Math.Round((GenerationCollection[GenerationCollection.Count - 1].People[0].fitness + Area_MainRectangle) / Area_MainRectangle, 3)).ToString() + " %" + "  -  " + GenerationCollection[GenerationCollection.Count - 1].People[0].fitness;
                };
                numberGenerationLabel.BeginInvoke(action);

                Draw_Each_Num_Generation = Convert.ToInt32(ProgramSettings.Default.DrawEachNumGeneration);
                if (NO_Generation % Draw_Each_Num_Generation == 0)
                {
                    MethodInvoker action2 = delegate
                    {
                        Draw_Packing(NewGeneration.People[0]);
                    };
                    PictureBoxDraw.BeginInvoke(action2);
                }

                if (NewGeneration.People[0].fitness <= 0)
                {
                    break;
                }
            }
            IS_Finished = true;

            MethodInvoker action3 = delegate
            {
                numberGenerationLabel.Text       = NO_Generation.ToString();
                PlayPausetoolStripButton.Checked = false;
                toolStripProgressBar1.Visible    = false;
                toolStripStatusLabel1.Visible    = false;

                toolStripDropDownButton1.Enabled         = true;
                DrawCharttoolStripButton.Enabled         = true;
                BestPolishtoolStripButton.Enabled        = true;
                CrossoverMutationtoolStripButton.Enabled = true;
                Compare2toolStripButton.Enabled          = true;

                MainForm.stopWatch.Stop();

                TimeSpan ts = MainForm.stopWatch.Elapsed;
                TimeElapsedlabel.Text = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
                                                      ts.Hours, ts.Minutes, ts.Seconds,
                                                      ts.Milliseconds / 10);


                Draw_Packing(GenerationCollection[GenerationCollection.Count - 1].People[0]);
            };

            numberGenerationLabel.BeginInvoke(action3);
            MainForm.oThread.Abort();
        }