def _mutationAndRecombination(self, particle, index, psize):
a = index
b = index
c = index
k = index
self.prev_features.append(particle.copyCoord())
newc = universe.getOrigin()
while a == index:
a = np.random.uniform(0, 1) * (psize - 1)
while b == index or b == a:
b = np.random.uniform(0, 1) * (psize - 1)
while c == index or b == c or c == a:
c = np.random.uniform(0, 1) * (psize - 1)
lp = particles.particles()
for i in range(universe.dimension()):
if np.random.uniform(0, 1) < self.data.mutation_factor:
newc[i] = particle[i]
else:
newc[i] = lp[math.floor(a)][i] + self.data.mutation_factor * \
(lp[math.floor(b)][i] + lp[math.floor(c)][i])
# ensure values are inbound
newc.inbounds()
particle.position(newc)
def algorithm(self):
m = len(particles.particles())
lp = particles.particles()
data = self.data
tmp = []
for _ in particles.particles():
tmp.append(universe.getOrigin())
# create the table of info
printHeader('Iteration', 'Fitness', 'Elapsed')
dimension = universe.dimension()
for iteration in range(data.iterations):
selection = self._rouletteSelection(particles.particles())
for p in range(0, math.floor(m/2), 2):
crossover_index = math.floor(np.random.uniform(high=dimension))
for k in range(dimension):
if k < crossover_index:
tmp[p][k] = lp[selection[p]][k]
tmp[p+1][k] = lp[selection[p+1]][k]
else:
tmp[p][k] = lp[selection[p+1]][k]
tmp[p+1][k] = lp[selection[p]][k]
if m % 2 == 0:
cross_index = math.floor(np.random.uniform(high=dimension))
for k in range(dimension):
if k < cross_index:
tmp[m-1][k]= lp[selection[m-1]][k]
else:
tmp[m-1][k]= lp[selection[0]][k]
# It performs the mutation
for coord in tmp:
if np.random.uniform(0, 1) <= data.mutation_probability:
index = math.floor(np.random.uniform(high=dimension))
coord.uniformRandom(index)
# changes the generation
for j in range(m):
lp[j].position(tmp[j])
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
# information output
printInfo(iteration,
self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def algorithm(self):
m = len(particles.particles())
lp = particles.particles()
data = self.data
# create the table of info
printHeader('Iteration', 'Fitness', 'Elapsed')
dimension = universe.dimension()
for iteration in range(data.iterations):
summ = 0
best = particles.getBestCoordinate()
for p in particles.particles():
rand = np.random.uniform(0, 1)
part = p
p.coordinate = rand * (best - p.coordinate)
p.coordinate.inbounds()
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
for particle in particles.particles():
summ += particle.fitness
bestc = particles.getBestCoordinate()
radius = particles.getBestFitness() / summ
for p in particles.particles():
dist = p.coordinate.euclideanDistance(bestc)
if dist < radius:
p.coordinate.uniformRandom()
p.fitness = sys.maxsize
# information output
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def algorithm(self):
# extract darwin parametrs from dict
data = self.data
# create the table of info
printHeader('Iteration', 'fitness', 'elapsed')
dimension = universe.dimension()
for iteration in range(self.data.iterations):
for p in particles.particles():
self._updateParticleVelocity(p, dimension)
self._updateParticlePosition(p, dimension)
p.coordinate.inbounds()
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
# information output
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def algorithm(self):
printHeader('Iteration', 'fitness', 'elapsed')
dimension = universe.dimension()
for iteration in range(self.data.iterations):
self.iteration = iteration
for p in particles.particles():
self._setBatFrequency(p)
self._updateBatVelocity(p, dimension)
p.coordinate.inbounds()
prob = np.random.uniform(0, 1)
if prob > p.pulse_rate:
best = particles.getBestCoordinate()
p.last_coordinate = copy.deepcopy(p.coordinate)
p.position(best)
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))
def algorithm(self):
m = particles.total()
lp = particles.particles()
data = self.data
# create the table of info
printHeader('Iteration', 'Fitness', 'Elapsed')
dimension = universe.dimension()
for iteration in range(data.iterations):
self.prev_features = []
for i, p in enumerate(particles.particles()):
self._mutationAndRecombination(p, i, particles.total())
start_time = time.time()
yield iteration
elapsed_time = time.time() - start_time
# information output
printInfo(iteration, self.data.iterations,
particles.getBestFitness(),
datetime.timedelta(seconds=elapsed_time))