def test_generation_enfant_non_hybride(self): pere = generate_scorpion() mere = generate_scorpion() enfant = generation_enfant(pere, mere, 0) assert len(enfant) == 10 assert scorpion_identique(enfant, pere) | scorpion_identique( enfant, mere)
def selection_parents_tournoi(info_scorpion_energie_portee_note): """ Fonction selectionnant les parents à l'aide d'un algorithme de selection par tournoi. :param info_scorpion_energie_portee_note: liste d'info scorpion de longueur n :type info_scorpion_energie_portee_note: liste_info[scorpion, energie, portee, note] :return: scorpions parents :rtype: scorpion[n] .. seealso:: :func:`src.Metier.genetique.duel` """ population_parent = [] while len(population_parent) < len(info_scorpion_energie_portee_note): scorpion_note_1 = choice(info_scorpion_energie_portee_note) scorpion_note_2 = generate_scorpion_null() continuer = 1 while continuer: scorpion_note_2 = choice(info_scorpion_energie_portee_note) if scorpion_identique(scorpion_note_1[0], scorpion_note_2[0]) == 0: continuer = 0 winner = duel(scorpion_note_1, scorpion_note_2) population_parent.append(winner) return population_parent
def test_duel_scorpion2_meilleur(self): liste_info_scorpion1 = [self.scorpion1, 0, 0, 0] liste_info_scorpion2 = [self.scorpion2, 0, 0, 1] scorpion_gagnant = duel(liste_info_scorpion1, liste_info_scorpion2) assert len(scorpion_gagnant) == 10 assert scorpion_identique(scorpion_gagnant, self.scorpion2)
def generer_generation_suivante(info_scorpion_energie_portee_note, chance_to_hybrid, chance_to_mutate): """ Fonction qui genere la generation suivante de scorpion. A partir d'une liste de longueur n d'info scorpion de la forme [scorpion, energie, portee, note]. On va sélectionner n parent grâce à un algorithme de selection par tournoi à 1 étage. Puis on formera des couples qui genereront 2 enfants avec une chance d'hybridation. Chaque enfant aura ensuite une chance de muter. :param info_scorpion_energie_portee_note: tableau d'info :type info_scorpion_energie_portee_note: liste[scorpion, energie, portee, note] :param chance_to_hybrid: coefficient d'hybridation :type chance_to_hybrid: float :param chance_to_mutate: coefficient de mutation :return: tableau de scorpion :rtype: scorpion[n] .. seealso:: :func:`src.Tools.selection_parents_tournoi` .. seealso:: :func:`src.Tools.scorpion_identique` .. seealso:: :func:`src.Tools.generer_enfants` .. seealso:: :func:`src.Tools.mutation_individu` """ population_parent = selection_parents_tournoi( info_scorpion_energie_portee_note) population_enfant = [] population_count = len(population_parent) while len(population_enfant) < population_count: id_parent1 = randrange(0, population_count - 1, 1) id_parent2 = 0 continuer = 1 while continuer: id_parent2 = randrange(0, population_count - 1, 1) if id_parent2 != id_parent1: identique = scorpion_identique(population_parent[id_parent1], population_parent[id_parent2]) if identique == 0: continuer = 0 enfant1, enfant2 = generer_enfants(population_parent[id_parent1], population_parent[id_parent2], chance_to_hybrid) enfant1 = mutation_individu(enfant1, chance_to_mutate) enfant2 = mutation_individu(enfant2, chance_to_mutate) population_enfant.append(enfant1) population_enfant.append(enfant2) return population_enfant
def test_generate_scorpion_null(self): scorpion_null = TestScorpion.generate_scorpion_null() scorpion_null2 = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1] assert len(scorpion_null) == 10 assert len(scorpion_null2) == 10 assert scorpion_identique(scorpion_null, scorpion_null2) == 1
def test_scorpions_identique(self): scorpion2 = TestScorpion.generate_scorpion_null() assert scorpion_identique(self.scorpion, self.scorpion) == 1 assert scorpion_identique(scorpion2, self.scorpion) == 0