def run(self, number_iterations, rn=[]):
"""Run method
Args:
number_iterations (int): Number of iterations.
Returns:
Population: Final population.
"""
if len(rn) == 0:
self.rn = self.generate_rn(number_iterations)
else:
assert number_iterations == len(rn)
assert len(rn[0]) == self.cantVars
assert len(rn[0][0]) == 2
self.rn = rn
for i in range(number_iterations):
if i > 0:
self.population = self.nextPopulation(self.population)
self.population = JayaClasic(self.population.size(),
self.listVars,
self.functionToEvaluate,
listConstraints=self.listConstraints,
population=self.population).run(
1, [self.rn[i]])
return self.population
def test_first_iteration(self):
"""Tests first iteration."""
listVars = [VariableFloat(-100.0, 100.0) for i in range(2)]
ja = JayaClasic(5, listVars, sphere, population=self.population)
bw = ja.run(1, self.rs1).getBestAndWorst()
assert bw['best_value'] == 113.0
assert len(bw['best_solution']) == 2
assert all([a == b for a, b in zip(bw['best_solution'], [-8.0, 7.0])])
assert truncate(bw['worst_value'], 1) == 3997.7
assert len(bw['worst_solution']) == 2
assert all(
[a == b for a, b in zip(bw['worst_solution'], [-44.12, 45.29])])
def test_second_iteration(self):
"""Tests second iteration."""
listVars = [VariableFloat(-100.0, 100.0) for i in range(2)]
ja = JayaClasic(5, listVars, sphere, population=self.population)
bw = ja.run(2, self.rs2).getBestAndWorst()
assert truncate(bw['best_value'], 2) == 7.78
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 3) == 2.787
assert truncate(bw['best_solution'][1], 3) == -0.097
assert truncate(bw['worst_value'], 2) == 2381.13
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 3) == -37.897
assert truncate(bw['worst_solution'][1], 3) == 30.739
def test_second_iteration(self):
"""Tests second iteration."""
listVars = [VariableFloat(-5.12, 5.12) for i in range(2)]
ja = JayaClasic(5, listVars, rastrigin, population=self.population)
bw = ja.run(2, self.rs2).getBestAndWorst()
assert truncate(bw['best_value'], 9) == 2.108371360
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 9) == 0.982105143
assert truncate(bw['best_solution'][1], 9) == -0.974135755
assert truncate(bw['worst_value'], 8) == 26.25808866
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 10) == 2.4303683434
assert truncate(bw['worst_solution'][1], 10) == -1.0337930258
def test_third_iteration(self):
"""Tests third iteration."""
listVars = [VariableFloat(-5.12, 5.12) for i in range(2)]
ja = JayaClasic(5, listVars, rastrigin, population=self.population)
bw = ja.run(3, self.rs3).getBestAndWorst()
assert truncate(bw['best_value'], 7) == 0.2150036
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 9) == -0.031679095
assert truncate(bw['best_solution'][1], 10) == -0.0091367952
assert truncate(bw['worst_value'], 8) == 24.79038297
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 9) == 2.415885711
assert truncate(bw['worst_solution'][1], 9) == -0.040158575
def test_first_iteration(self):
"""Tests first iteration."""
listVars = [VariableFloat(-5.12, 5.12) for i in range(2)]
ja = JayaClasic(5, listVars, rastrigin, population=self.population)
bw = ja.run(1, self.rs1).getBestAndWorst()
assert truncate(bw['best_value'], 9) == 2.108371360
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 9) == 0.982105143
assert truncate(bw['best_solution'][1], 9) == -0.974135755
assert truncate(bw['worst_value'], 9) == 36.785779376
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 2) == 5.12
assert truncate(bw['worst_solution'][1], 11) == -1.84339288493
def test_first_iteration(self):
"""Tests first iteration."""
listVars = [VariableFloat(-5.0, 5.0) for i in range(2)]
ja = JayaClasic(
5,
listVars,
himmelblau,
population=self.population,
listConstraints=[himmelblauConstraintOne, himmelblauConstraintTwo])
bw = ja.run(1, self.rs1).getBestAndWorst()
assert truncate(bw['best_value'], 3) == 11.890
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 3) == 3.845
assert truncate(bw['best_solution'][1], 3) == -1.038
assert truncate(bw['worst_value'], 3) == 77.710
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 3) == 0.191
assert truncate(bw['worst_solution'][1], 3) == 2.289
def test_first_iteration(self, monkeypatch):
"""Tests first iteration."""
def rn():
self.index += 1
return self.rn[self.index - 1]
monkeypatch.setattr(np.random, 'rand', rn)
listVars = [VariableFloat(-100.0, 100.0) for i in range(2)]
ja = JayaClasic(5, listVars, sphere, population=self.population)
bw = ja.run(1).getBestAndWorst()
assert bw['best_value'] == 113.0
assert len(bw['best_solution']) == 2
assert all([a == b for a, b in zip(bw['best_solution'], [-8.0, 7.0])])
assert truncate(bw['worst_value'], 1) == 3997.7
assert len(bw['worst_solution']) == 2
assert all(
[a == b for a, b in zip(bw['worst_solution'], [-44.12, 45.29])])
def test_second_iteration(self, monkeypatch):
"""Tests second iteration."""
def rn():
self.index += 1
return self.rn[self.index - 1]
monkeypatch.setattr(np.random, 'rand', rn)
listVars = [VariableFloat(-100.0, 100.0) for i in range(2)]
ja = JayaClasic(5, listVars, sphere, population=self.population)
bw = ja.run(2).getBestAndWorst()
assert truncate(bw['best_value'], 2) == 7.78
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 3) == 2.787
assert truncate(bw['best_solution'][1], 3) == -0.097
assert truncate(bw['worst_value'], 2) == 2381.13
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 3) == -37.897
assert truncate(bw['worst_solution'][1], 3) == 30.739
def test_third_iteration(self, monkeypatch):
"""Tests third iteration."""
def rn():
self.index += 1
return self.rn[self.index - 1]
monkeypatch.setattr(np.random, 'rand', rn)
listVars = [VariableFloat(-5.12, 5.12) for i in range(2)]
ja = JayaClasic(5, listVars, rastrigin, population=self.population)
bw = ja.run(3).getBestAndWorst()
assert truncate(bw['best_value'], 7) == 0.2150036
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 9) == -0.031679095
assert truncate(bw['best_solution'][1], 10) == -0.0091367952
assert truncate(bw['worst_value'], 8) == 24.79038297
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 9) == 2.415885711
assert truncate(bw['worst_solution'][1], 9) == -0.040158575
def test_second_iteration(self, monkeypatch):
"""Tests second iteration."""
def rn():
self.index += 1
return self.rn[self.index - 1]
monkeypatch.setattr(np.random, 'rand', rn)
listVars = [VariableFloat(-5.12, 5.12) for i in range(2)]
ja = JayaClasic(5, listVars, rastrigin, population=self.population)
bw = ja.run(2).getBestAndWorst()
assert truncate(bw['best_value'], 9) == 2.108371360
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 9) == 0.982105143
assert truncate(bw['best_solution'][1], 9) == -0.974135755
assert truncate(bw['worst_value'], 8) == 26.25808866
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 10) == 2.4303683434
assert truncate(bw['worst_solution'][1], 10) == -1.0337930258
def test_first_iteration(self, monkeypatch):
"""Tests first iteration."""
def rn():
self.index += 1
return self.rn[self.index - 1]
monkeypatch.setattr(np.random, 'rand', rn)
listVars = [VariableFloat(-5.12, 5.12) for i in range(2)]
ja = JayaClasic(5, listVars, rastrigin, population=self.population)
bw = ja.run(1).getBestAndWorst()
assert truncate(bw['best_value'], 9) == 2.108371360
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 9) == 0.982105143
assert truncate(bw['best_solution'][1], 9) == -0.974135755
assert truncate(bw['worst_value'], 9) == 36.785779376
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 2) == 5.12
assert truncate(bw['worst_solution'][1], 11) == -1.84339288493
def test_first_iteration(self, monkeypatch):
"""Tests first iteration."""
def rn():
self.index += 1
return self.rn[self.index - 1]
monkeypatch.setattr(np.random, 'rand', rn)
listVars = [VariableFloat(-5.0, 5.0) for i in range(2)]
ja = JayaClasic(
5,
listVars,
himmelblau,
population=self.population,
listConstraints=[himmelblauConstraintOne, himmelblauConstraintTwo])
bw = ja.run(1).getBestAndWorst()
assert truncate(bw['best_value'], 3) == 11.890
assert len(bw['best_solution']) == 2
assert truncate(bw['best_solution'][0], 3) == 3.845
assert truncate(bw['best_solution'][1], 3) == -1.038
assert truncate(bw['worst_value'], 3) == 77.710
assert len(bw['worst_solution']) == 2
assert truncate(bw['worst_solution'][0], 3) == 0.191
assert truncate(bw['worst_solution'][1], 3) == 2.289
class JayaSelfAdaptive(JayaBase):
"""Jaya Self-adaptive class
Args:
listVars (list): Range list.
functionToEvaluate (funtion): Function to minimize or maximize.
listConstraints (list, optional): Constraint list. Defaults to [].
"""
def __init__(self,
listVars,
functionToEvaluate,
listConstraints=[],
population=None):
super(JayaSelfAdaptive, self).__init__(len(listVars) * 10,
listVars,
functionToEvaluate,
listConstraints,
population=population)
def nextPopulation(self, population):
"""New population.
Returns:
Population: Next population.
"""
numOldSolutions = population.size()
r = 1 + (np.random.rand() - 0.5)
numNewSolutions = round(numOldSolutions * r)
if numNewSolutions == numOldSolutions:
return population
else:
newPopulation = Population(self.minimax, solutions=[])
if numNewSolutions < numOldSolutions:
if numNewSolutions < self.cantVars:
numNewSolutions = self.cantVars
if self.minimax:
for solution in population.sorted()[-numNewSolutions:]:
newPopulation.solutions.append(solution)
else:
for solution in population.sorted()[:numNewSolutions]:
newPopulation.solutions.append(solution)
elif numNewSolutions > numOldSolutions:
for solution in population.solutions:
newPopulation.solutions.append(solution)
if self.minimax:
begin = numOldSolutions - numNewSolutions
for solution in population.sorted()[begin:]:
newPopulation.solutions.append(solution)
else:
limit = numNewSolutions - numOldSolutions
for solution in population.sorted()[:limit]:
newPopulation.solutions.append(solution)
return newPopulation
def run(self, number_iterations, rn=[]):
"""Run method
Args:
number_iterations (int): Number of iterations.
Returns:
Population: Final population.
"""
if len(rn) == 0:
self.rn = self.generate_rn(number_iterations)
else:
assert number_iterations == len(rn)
assert len(rn[0]) == self.cantVars
assert len(rn[0][0]) == 2
self.rn = rn
for i in range(number_iterations):
if i > 0:
self.population = self.nextPopulation(self.population)
self.population = JayaClasic(self.population.size(),
self.listVars,
self.functionToEvaluate,
listConstraints=self.listConstraints,
population=self.population).run(
1, [self.rn[i]])
return self.population
def main():
# Vars
listVars = [VariableFloat(-500.0, 500.0) for i in range(30)]
print("RUN: JayaClasic")
ja = JayaClasic(100, listVars, schwefel)
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print("RUN: Self-adaptive Jaya Algorithm")
ja = JayaSelfAdaptive(listVars, schwefel)
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print("RUN: Quasi-oppositional Based Jaya (QO-Jaya) Algorithm")
ja = JayaQuasiOppositional(100, listVars, schwefel)
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print("RUN: Self-adaptive Multi-population (SAMP) Jaya Algorithm")
ja = JayaSAMP(100, listVars, schwefel)
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print("RUN: Self-adaptive Multi-population Elitist (SAMPE) Jaya " +
"Algorithm MultiProcess")
ja = JayaSAMPE(100, listVars, schwefel)
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
def main():
print("RUN: JayaClasic")
listVars = [VariableFloat(-6.0, 6.0) for i in range(2)]
ja = JayaClasic(
100, listVars, himmelblau,
listConstraints=[himmelblauConstraintOne, himmelblauConstraintTwo])
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print("RUN: Self-adaptive Jaya Algorithm")
listVars = [VariableFloat(-6.0, 6.0) for i in range(2)]
ja = JayaSelfAdaptive(
listVars, himmelblau,
listConstraints=[himmelblauConstraintOne, himmelblauConstraintTwo])
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print("RUN: Quasi-oppositional Based Jaya (QO-Jaya) Algorithm")
listVars = [VariableFloat(-6.0, 6.0) for i in range(2)]
ja = JayaQuasiOppositional(
100, listVars, himmelblau,
listConstraints=[himmelblauConstraintOne, himmelblauConstraintTwo])
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print("RUN: Self-adaptive Multi-population (SAMP) Jaya Algorithm")
listVars = [VariableFloat(-6.0, 6.0) for i in range(2)]
ja = JayaSAMP(
100, listVars, himmelblau,
listConstraints=[himmelblauConstraintOne, himmelblauConstraintTwo])
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
print(
"RUN: Self-adaptive Multi-population Elitist (SAMPE) Jaya " +
"Algorithm MultiProcess")
listVars = [VariableFloat(-6.0, 6.0) for i in range(2)]
ja = JayaSAMPE(
100, listVars, himmelblau,
listConstraints=[himmelblauConstraintOne, himmelblauConstraintTwo])
print(ja.run(100).getBestAndWorst())
print("--------------------------------------------------------------")
