예제 #1
0
        public void Mutation(int nombreMutation)
        {
            int i = 0;

            while (i < nombreMutation)
            {
                Random       r           = new Random();
                int          randomIndex = r.Next(0, mageneration.Count);
                Chemin       chemin      = mageneration[randomIndex];
                List <Ville> mesVilles   = new List <Ville>(chemin.MesVilles);
                int          nombreVille = mesVilles.Count;
                int          indexVille1 = r.Next(0, nombreVille);
                int          indexVille2 = r.Next(0, nombreVille);

                while (indexVille2 == indexVille1)
                {
                    indexVille2 = r.Next(nombreVille);
                }
                List <Ville> resultVilles = Swap(mesVilles, indexVille1, indexVille2);
                Chemin       cheminFinal  = new Chemin(resultVilles);
                if (comparerChemin(cheminFinal, mapopulation) == 0)
                {
                    mapopulation.Add(cheminFinal);
                    i++;
                }
            }
        }
예제 #2
0
        /*
         * Changement de position de deux villes dans une liste (mutation)
         */
        public List <Chemin> Echanger(List <Chemin> chemins, int coefficient)
        {
            List <Chemin> newchemins = new List <Chemin>();

            for (int i = 0; i < chemins.Count; i++)
            {
                for (int j = 0; j < coefficient; j++)
                {
                    //on calcule les index
                    int indexA = 0;
                    int indexB = 0;
                    do
                    {
                        indexA = rnd.Next(chemins[i].Villes.Count);
                        indexB = rnd.Next(chemins[i].Villes.Count);
                    } while (indexA == indexB);

                    //Pour chaque chemin on permute deux villes
                    List <Ville> villes = chemins[i].Villes;
                    Ville        tmp    = villes[indexA];
                    villes[indexA] = villes[indexB];
                    villes[indexB] = tmp;
                    Chemin chemin = new Chemin(villes);
                    newchemins.Add(chemin);
                }
            }
            return(newchemins);
        }
예제 #3
0
        public int comparerChemin(Chemin chemin, List <Chemin> maListe)
        {
            var cnt = from c in maListe
                      where c.ToString() == chemin.ToString()
                      select c;

            return(cnt.Count());
        }
예제 #4
0
        public void CrossOver(int nombreCross)
        {
            for (int index = 0; index < nombreCross; index++)
            {
                int taille     = mageneration[0].MesVilles.Count;
                int partition1 = taille / 2;

                List <Ville>  CrossVille    = new List <Ville>();
                List <Chemin> CrossChemin   = new List <Chemin>();
                List <Ville>  portionDroite = new List <Ville>();

                Random r            = new Random();
                int    nombreChemin = 2;
                int    randomIndex1 = r.Next(0, mageneration.Count);

                Chemin chemin1 = mageneration[randomIndex1];
                Chemin chemin2;
                CrossChemin.Add(chemin1);

                while (nombreChemin != 1)
                {
                    int randomIndex2 = r.Next(0, mageneration.Count);
                    if (randomIndex2 != randomIndex1)
                    {
                        chemin2 = mageneration[randomIndex2];
                        CrossChemin.Add(chemin2);
                        nombreChemin--;
                    }
                }

                for (int i = 0; i < partition1; i++)
                {
                    CrossVille.Add(CrossChemin[0].MesVilles[i]);
                }

                for (int i = partition1; i < taille; i++)
                {
                    CrossVille.Add(CrossChemin[1].MesVilles[i]);
                    portionDroite.Add(CrossChemin[0].MesVilles[i]);
                }

                List <Ville> VillesDoublons = VerifierDouble(CrossVille);

                List <Ville> resultVilles = CheminSansDoublon(VillesDoublons, portionDroite, CrossVille);

                Chemin resultChemin = new Chemin(resultVilles);

                if (comparerChemin(resultChemin, mapopulation) == 0)
                {
                    mapopulation.Add(resultChemin);
                }
            }
        }
예제 #5
0
        public void GeneratePremierGeneration()
        {
            int combinaisons = FirstGeneration;

            while (combinaisons != 0)
            {
                Chemin chemin = new Chemin(lesVilles.OrderBy(a => Guid.NewGuid()).ToList());
                if (comparerChemin(chemin, mageneration) == 0)
                {
                    mageneration.Add(chemin);
                    combinaisons--;
                }
            }
        }
예제 #6
0
        /*
         *
         */
        public List <Chemin> GenererXOver(List <Chemin> chemins, int pivot, int coefficient)
        {
            // chemin affiché 2 fois dans --> réxecuter
            // rajouter un test pour que le pivot ne soit pas superieur au nombre de ville de chemin
            // Faut faire une boucle pour faire fonctionnéé le x over plusieurs fois
            List <Chemin> resultat = new List <Chemin>();

            for (int i = 0; i < coefficient * chemins.Count; i++)
            {
                int    indexChemin1;
                int    indexChemin2;
                Chemin ch;

                do
                {
                    List <Ville> villesXover = new List <Ville>();
                    do
                    {
                        //choisir deux chemins aléatoirement de la liste
                        indexChemin1 = rnd.Next(chemins.Count);
                        indexChemin2 = rnd.Next(chemins.Count);
                    }while (indexChemin1 == indexChemin2);
                    int tailleVilleXover = chemins[indexChemin1].Villes.Count;
                    var nPremieresVilles = chemins[indexChemin1].Villes.Take(pivot);

                    var nSecondesVilles = chemins[indexChemin2].Villes.Skip(pivot);
                    foreach (Ville item in nPremieresVilles)
                    {
                        villesXover.Add(item);
                    }
                    foreach (Ville item in nSecondesVilles)
                    {
                        villesXover.Add(item);
                    }
                    //villesXover.AddRange(nPremieresVilles);
                    //villesXover.AddRange(nSecondesVilles);

                    ch = new Chemin(villesXover);
                }while (ch.ContientDoublons());
                resultat.Add(ch);
            }
            return(resultat);
        }
예제 #7
0
        public Chemin GetMeilleurCheminDeLaPopulation()
        {
            Chemin top = null;

            foreach (Generation gs in this.mesGenerations)
            {
                foreach (Chemin c in gs.Get_generation)
                {
                    if (top is null)
                    {
                        top = c;
                    }
                    else
                    {
                        if (c.Score < top.Score)
                        {
                            top = c;
                        }
                    }
                }
            }
            return(top);
        }
예제 #8
0
        /*
         * Générer une liste des chemins à partir d'une liste des villes
         */
        public List <Chemin> GenererChemins(int nbGeneration, List <Ville> villes)
        {
            List <Chemin> chemins = new List <Chemin>();

            if (nbGeneration <= factoriel(villes.Count))
            {
                int i = 0;
                do
                {
                    var nouveauChemin = new Chemin(melanger(villes));
                    if (!chemins.Contains(nouveauChemin))
                    {
                        chemins.Add(nouveauChemin);
                        i++;
                    }
                } while (i < nbGeneration);
            }
            else
            {
                throw new System.ArgumentException("erreur: le nombre de combinaisons possibles " +
                                                   "est inferieur au nombre de combinaisons demandées");
            }
            return(chemins);
        }