Exemplo n.º 1
0
 def codificarCromosoma(self, intervalo):
     self.cromosoma = ''
     #Recibe el intervalo y usa el extremo superior del mismo para calcular el numero de bits del cromosoma
     ultimoEnBin = "{0:b}".format(intervalo[-1])
     longitudCromosoma = len(ultimoEnBin)
     for x in range(longitudCromosoma):
         gen = Gen()
         self.cromosoma = self.cromosoma + gen.getAlelo()
Exemplo n.º 2
0
    def onClose(self, event):
        self.result = {'name': self.nameVar, 'io_intensive': self.ioIntensiveVar,
         'range': (int(self.startAddressVar), int(self.endAddressVar)),
         'count': int(self.ioCountVar), 'write_percent': float(self.writePercentageVar),
         'write_ran_percent': float(self.randomWritePercentageVar),
         'read_ran_percent': float(self.randomReadPercentageVar)}
        print(self.result)

        myGen = Gen(self.result)
        myGen.gen()
Exemplo n.º 3
0
def breed():

    # Select parent from the this generation
    selected_parents = select()

    # Add them to new generation
    new_generation = selected_parents[:]

    # Shuffle it to keep the variety of population
    shuffle(selected_parents)

    # Let them cross over to create 1 child each couple
    # The 1/4 population remain will be generate randomly
    children = []
    for i in range(0, len(selected_parents), 2):
        children += selected_parents[i].cross_over(selected_parents[i + 1])
        new_generation.append(Gen(life_time.get()))

    # Let the children mutate
    mutation(children)

    # Add children to new generation
    new_generation += children

    # Clear out the population
    walkers.clear()

    # Create new population from the selected gens
    for i in range(len(new_generation)):
        walkers.append(
            Walker(map_blocks, map_blocks[start_point[0]][start_point[1]],
                   new_generation[i], game_canvas))

    # Track the best walker
    walkers[0].best = True
 def __init__(self, screen, point):
     self.screen = screen
     self.generation = 1
     self.population_size = 50
     min_x = -screen[0] // 2
     self.jumpers = [
         JumpMan(screen=screen,
                 dna=Gen(random.randint(min_x, 0)),
                 point=point) for _ in range(self.population_size)
     ]
Exemplo n.º 5
0
def init_population():

    # Randomly create the initial population
    # Size of POPULATION_SIZE
    Walker.block_size = block_size.get()
    Walker.life_time = life_time.get()
    Walker.goal_point = goal_point
    population = []
    for i in range(population_size.get()):
        population.append(
            Walker(map_blocks, map_blocks[start_point[0]][start_point[1]],
                   Gen(life_time.get()), game_canvas))
    return population
Exemplo n.º 6
0
 def __init__(self, width, height):
     self.delay = 0.0000005
     self.screen = [width, height]
     self.wn = turtle.Screen()
     self.wn.title("Jump Man Game")
     self.wn.bgcolor("black")
     self.wn.setup(width=width, height=height)
     self.wn.tracer(0)
     self.roof = Roof(width, height)
     self.floor = Floor(width, height, self.roof.point)
     gen = Gen(0, 30, 20)
     # self.jump_man = JumpMan(screen=self.screen, dna=gen, point=self.floor.point)
     self.population = Population(screen=self.screen, point=self.floor.point)
Exemplo n.º 7
0
 def __init__(self):
     Gen.__init__(self, self.__class__.__name__)
Exemplo n.º 8
0
 def __init__(self, name):
     Gen.__init__(self, name)
     self.attrs['freq'] = 220.0
     self.attrs['phase'] = 0.0
     self.attrs['sync'] = 2.0
Exemplo n.º 9
0
from Gen import Gen

#2GB data, 20GB address range
myGen = Gen({
        'range': (1,0.5*1024*1024*1024//512),
        'count': 2*1024*1024*1024//4096,
        'write_percent': 0.5,
        'write_ran_percent': 0.67,
        'read_ran_percent': 0.67
    })
myGen.gen()


Exemplo n.º 10
0
# Ralph Pereira
# COSC3P71 Assignment 2
# TSP using a GA
###################################################################
#import statements
from Gen import Gen
import numpy as np
import csv
#create the two maps
b1 = Gen("berlin52.tsp", 0.0, 1.0)
d1 = Gen("dj38.tsp", 0.0, 1.0)
b2 = Gen("berlin52.tsp", 0.1, 1.0)
d2 = Gen("dj38.tsp", 0.1, 1.0)
b3 = Gen("berlin52.tsp", 0.0, 0.9)
d3 = Gen("dj38.tsp", 0.0, 0.9)
b4 = Gen("berlin52.tsp", 0.1, 0.9)
d4 = Gen("dj38.tsp", 0.1, 0.9)
b5 = Gen("berlin52.tsp", 0.05, 0.95)
d5 = Gen("dj38.tsp", 0.05, 0.95)


#main logic for the test file creatation
def CalculatePath(m, genCount, filename):
    #open the file with the file name provided
    wf = open(filename, "w")
    wf.write("Generation No.\tBest Distance\tAverage Distance\n")
    #create the maps and calculate the fitness
    fit = m.CalculateFitness(m.GetTO())
    bestOrder = m.FindBest(m.travelOrder)
    travelDistance = m.CalculateTotalDistance(m.GetTO())
    #run it for "genCount" amount of Generations
Exemplo n.º 11
0
def main():
    genA = Gen(None, 'genA')
    genB = Gen(None, 'genB')
    genC = Gen(None, 'genC')
    genD = Gen(None, 'genD')
    genE = Gen(None, 'genE')
    genF = Gen(None, 'genF')
    
    genA.add_patch_to(genB)
    genB.add_patch_to(genC)
    genB.add_patch_to(genD)
    genD.add_patch_to(genA)
    genD.add_patch_to(genE)
    
    Patch.dfs_patch_search(genA)
    for patch in Patch.patch_list:
        print patch
    
    genB.add_patch_to(genF)
    Patch.dfs_patch_search(genA)
    for patch in Patch.patch_list:
        print patch