pypharm 1.6.2__py3-none-any.whl → 1.6.3__py3-none-any.whl

PyPharm/algorithms/country_optimization_v3.py

@@ -1,428 +0,0 @@
-import random
-import numpy as np
-import copy
-from operator import attrgetter
-from math import ceil, cos, sin
-import graycode
-
-def rand_str():
-    s = 'qwertyuiopasdfghjklzxcvbnm'
-    k = np.random.choice(len(s), 8, replace=False)
-    res = ''
-    for ki in k:
-        res += s[ki]
-    return res
-
-def check_population(country):
-    return bool(country.population.size)
-
-vector_check_population = np.vectorize(check_population, signature='()->()')
-
-class Individual:
-
-    def __init__(self, gray_code, x_min, x_max, genes, function):
-
-        self.x_min = x_min
-        self.x_max = x_max
-        self.genes = genes
-        self.function = function
-        self.steps = (self.x_max - self.x_min) / (2 ** (self.genes) - 1)
-        self.gray_code = gray_code
-        self.f = self.function(self.real_x)
-        self.ep_n = 0
-
-    @property
-    def real_x(self):
-        decimal_x = []
-        gray_code = copy.deepcopy(self.gray_code)
-        for g in self.genes:
-            decimal_x.append(graycode.gray_code_to_tc(int(gray_code[:g], base=2)))
-            gray_code = gray_code[g:]
-        return self.x_min + self.steps * np.array(decimal_x)
-
-    @property
-    def decimal_x(self):
-        return (self.real_x - self.x_min) / self.steps
-
-    @classmethod
-    def generate_from_decimal(cls, decimal, x_min, x_max, genes, function):
-        gray_code = ''
-        decimal = np.clip(decimal, np.zeros(decimal.size), 2 ** (genes) - 1)
-        for i in range(len(decimal)):
-            s = '{:0' + str(genes[i]) + 'b}'
-            gray_code += s.format(graycode.tc_to_gray_code(int(decimal[i])))
-
-        return cls(gray_code, x_min, x_max, genes, function)
-
-    def mutation(self, max_mutation=1):
-        n = max(0, max_mutation - self.ep_n)
-        if n:
-            gray_code = copy.deepcopy(self.gray_code)
-            k = np.random.choice(len(gray_code), n, replace=False)
-            for ki in k:
-                b = bool(int(gray_code[ki]))
-                b = not b
-                b = str(int(b))
-                gray_code = gray_code[:ki] + b + gray_code[ki+1:]
-            return Individual(gray_code, self.x_min, self.x_max, self.genes, self.function)
-        else:
-            return self
-
-    @classmethod
-    def crossover(cls, individual1, individual2):
-        k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
-        while k[0] == k[1]:
-            k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
-        k = np.sort(k)
-        new_gray1 = individual1.gray_code[:k[0]] + individual2.gray_code[k[0]:k[1]] + individual1.gray_code[k[1]:]
-        new_gray2 = individual2.gray_code[:k[0]] + individual1.gray_code[k[0]:k[1]] + individual2.gray_code[k[1]:]
-        return [
-            cls(new_gray1, individual1.x_min, individual1.x_max, individual1.genes, individual1.function),
-            cls(new_gray2, individual1.x_min, individual1.x_max, individual1.genes, individual1.function),
-        ]
-
-    def __lt__(self, other):
-        return self.f < other.f
-
-    def __le__(self, other):
-        return self.f <= other.f
-
-    def __gt__(self, other):
-        return self.f > other.f
-
-    def __ge__(self, other):
-        return self.f >= other.f
-
-
-class Country:
-
-    def __init__(self, N, x_min, x_max, genes, function):
-        self.f = function
-        self.N = N
-        self.x_min = np.array(x_min)
-        self.x_max = np.array(x_max)
-        self.genes = np.array(genes)
-        self.name = rand_str()
-
-
-        local_xmin = np.random.randint(np.zeros(self.genes.size), 2 ** self.genes - 1)
-        local_xmax = np.random.randint(local_xmin, 2 ** self.genes)
-
-        self.rand_n_individual = np.vectorize(lambda x: x * self.random_individual(local_xmin, local_xmax), signature='()->(n)')
-        self.generate_population = np.vectorize(lambda decimal: Individual.generate_from_decimal(
-            decimal, self.x_min, self.x_max, self.genes, self.f), signature='(n)->()')
-
-        x = self.rand_n_individual(np.ones(self.N))
-        self.population = self.generate_population(x)
-
-
-        self.sort_population()
-        self.action = None
-        self.enemy = None
-        self.ally = None
-
-    def random_individual(self, x_min, x_max):
-        return np.random.randint(x_min, x_max)
-
-    @property
-    def best_function(self):
-        return self.population[0].f
-
-    def roulette_function(self, f_min, f_max):
-        return (f_max - self.population[0].f) / (f_max - f_min)
-
-    @property
-    def avg_function(self):
-        return sum([individual.f for individual in self.population]) / self.population.size
-
-    def sort_population(self):
-        self.population.sort()
-
-    def reproduction(self, n_min, n_max, f_min, f_max):
-        n = ceil((n_max - n_min) * (f_max - self.avg_function) / (f_max - f_min) + n_min)
-        n = np.clip(n, n_min, n_max)
-        # p2 = (1 - ti / t_max) * (self.avg_function - f_min) / (f_max - f_min)
-        new_individuals = []
-
-        for i in range(n):
-            if len(self.population) == 2 and self.population[0] == self.population[1]:
-                new_individuals.extend(Individual.crossover(self.population[0], self.population[1],
-                                                            self.x_min, self.x_max, self.genes, self.f))
-                continue
-            k1 = random.randint(0, len(self.population) - 1)
-            individual1 = self.population[k1]
-            k2 = k1
-            while k2 == k1:
-                k2 = random.randint(0, len(self.population) - 1)
-            individual2 = self.population[k2]
-            new_individuals += Individual.crossover(individual1, individual2)
-        self.population = np.append(self.population, np.array(new_individuals))
-        self.sort_population()
-
-    def extinction(self, m_min, m_max, f_min, f_max):
-        m = int((m_max - m_min) * (self.avg_function - f_min) / (f_max - f_min) + m_min)
-        m = np.clip(m, m_min, m_max)
-        self.population = self.population[:-m]
-
-    def extinction1(self, n):
-        if self.population.size < n:
-            return n - self.population.size
-        self.population = self.population[:n]
-        return 0
-
-    def select_action(self, countries):
-        self.action = random.randint(0, 3)
-        if self.action == 1:
-            ally_list = [country for country in countries if country.action is None and country != self]
-            if ally_list:
-                self.ally = ally_list.pop(random.randint(0, len(ally_list) - 1))
-                self.ally.action = 1
-                self.ally.ally = self
-            else:
-                self.action = random.choice([0, 3])
-        if self.action == 2:
-            enemy_list = [country for country in countries if country.action is None and country != self]
-            if enemy_list:
-                self.enemy = enemy_list.pop(random.randint(0, len(enemy_list) - 1))
-                self.enemy.action = 2
-                self.enemy.enemy = self
-            else:
-                self.action = random.choice([0, 3])
-
-    def epedemic(self, elite, dead, max_mutation):
-        if max_mutation < 1:
-            max_mutation = 1
-        n_elite = ceil(elite * len(self.population))
-        n_dead = ceil(dead * len(self.population))
-        self.population = self.population[:-n_dead]
-        for i in range(n_elite, self.population.size):
-            self.population[i] = self.population[i].mutation(max_mutation)
-        self.sort_population()
-        self.action = None
-
-    # def sabotage(self, n_copy):
-    #     for i in range(n_copy):
-    #         self.enemy.population.append(copy.copy(self.population[0]))
-    #     self.action = None
-    #     self.enemy = None
-
-    def motion(self):
-        x_best = self.population[0].decimal_x
-        for i in range(1, len(self.population)):
-            self.population[i] = Individual.generate_from_decimal(
-                self.population[i].decimal_x + np.int64(random.uniform(0, 2) * (x_best - self.population[i].decimal_x)), self.x_min, self.x_max, self.genes, self.f
-            )
-        self.sort_population()
-        self.action = None
-
-    @staticmethod
-    def trade(country1, country2, k):
-        if country1.population.size <= k or country2.population.size <= k:
-            k = min(country1.population.size, country2.population.size) // 2
-        indexes1 = np.random.choice(country1.population.size, k, replace=False)
-        indexes2 = np.random.choice(country2.population.size, k, replace=False)
-        country2.population = np.concatenate([country2.population, country1.population[indexes1]])
-        country1.population = np.concatenate([country1.population, country2.population[indexes2]])
-        country1.population = np.delete(country1.population, indexes1)
-        country2.population = np.delete(country2.population, indexes2)
-        country1.sort_population()
-        country2.sort_population()
-        country1.action = None
-        country2.action = None
-        country1.ally = None
-        country2.ally = None
-
-    @staticmethod
-    def war(country1, country2, l):
-        if country1.population.size <= l or country2.population.size <= l:
-            l = min(country1.population.size, country2.population.size)
-        indexes1 = np.random.choice(country1.population.size, l, replace=False)
-        indexes2 = np.random.choice(country2.population.size, l, replace=False)
-        war_list1 = country1.population[indexes1]
-        war_list2 = country2.population[indexes2]
-        country1.population = np.delete(country1.population, indexes1)
-        country2.population = np.delete(country2.population, indexes2)
-        wins1 = np.where(war_list1 > war_list2)
-        wins2 = np.where(war_list2 > war_list2)
-        if wins1[0].size > wins2[0].size:
-            np.concatenate([country1.population, war_list1])
-            np.concatenate([country1.population, war_list2])
-        elif wins2[0].size > wins1[0].size:
-            np.concatenate([country2.population, war_list1])
-            np.concatenate([country2.population, war_list2])
-        else:
-            np.concatenate([country1.population, war_list1])
-            np.concatenate([country2.population, war_list2])
-        country1.sort_population()
-        country2.sort_population()
-        country1.action = None
-        country2.action = None
-        country1.enemy = None
-        country2.enemy = None
-
-
-class CountriesAlgorithm:
-
-    def __init__(self, f, Xmin, Xmax, genes, M, N, n, m, k, l, ep, max_mutation, tmax, printing=False, memory_list=None):
-        self.f = f
-        self.Xmin = Xmin
-        self.Xmax = Xmax
-        self.n = n
-        self.genes = genes
-        self.m = m
-        self.k = k
-        self.M = M
-        self.N = N
-        self.l = l
-        self.ep = ep
-        self.max_mutation = max_mutation
-        self.tmax = tmax
-        self.countries = []
-        self.printing = printing
-        self.memory_list = memory_list
-        for i in range(M):
-            self.countries.append(Country(N, self.Xmin, self.Xmax, self.genes, self.f))
-
-    def start(self):
-        ti = 0
-        motion = 0
-        trade = 0
-        war = 0
-        epedemic = 0
-        if self.memory_list is not None:
-            self.memory_list[0] = False
-        while ti <= self.tmax:
-            ti += 1
-            for country in self.countries:
-                if country.action is None:
-                    country.select_action(self.countries)
-            for country in self.countries:
-                if country.action == 0:
-                    motion += 1
-                    country.motion(                    )
-                elif country.action == 1:
-                    trade += 1
-                    Country.trade(
-                        country1=country,
-                        country2=country.ally,
-                        k=self.k
-                    )
-                elif country.action == 2:
-                    war += 1
-                    Country.war(
-                        country1=country,
-                        country2=country.enemy,
-                        l=self.l
-                    )
-                elif country.action == 3:
-                    epedemic += 1
-                    country.epedemic(
-                        elite=self.ep[0],
-                        dead=self.ep[1],
-                        max_mutation=int((1 - ti / self.tmax) * self.max_mutation),
-                    )
-            indexes = np.where(vector_check_population(self.countries) == True)
-            self.countries = [self.countries[i] for i in indexes[0]]
-
-            self.countries = sorted(self.countries, key=attrgetter('avg_function'))
-            if not self.countries:
-                break
-            f_min = self.countries[0].avg_function
-            f_max = self.countries[-1].avg_function
-            if f_min == f_max:
-                self.countries = sorted(self.countries, key=attrgetter('best_function'))
-                result = self.countries[0].population[0]
-                break
-            e_individuals = []
-            for country in self.countries:
-                if len(country.population) == 1:
-                    e_individuals.append(country.population[0])
-                    continue
-                if country.population.size:
-                    country.reproduction(
-                        n_min=self.n[0],
-                        n_max=self.n[1],
-                        f_min=f_min,
-                        f_max=f_max
-                    )
-                    country.extinction(
-                        m_min=self.m[0],
-                        m_max=self.m[1],
-                        f_min=f_min,
-                        f_max=f_max
-                    )
-            self.countries = [country for country in self.countries if len(country.population)]
-            # self.countries = sorted(self.countries, key=attrgetter('best_function'))
-            # f_min = self.countries[0].best_function
-            # f_max = self.countries[-1].best_function
-            # s = sum(country.roulette_function(f_min, f_max) for country in self.countries if len(country.population) > 1)
-            # self.countries.reverse()
-            # for country in self.countries:
-            #     plus = 0
-            #     if len(country.population) >= 1:
-            #         res = country.extinction1(
-            #             max(self.N // 2, ceil(country.roulette_function(f_min, f_max) / s * self.N * self.M)) + plus
-            #         )
-            #         if res:
-            #             plus += res
-            #         else:
-            #             plus = 0
-            #
-            # indexes = np.where(vector_check_population(self.countries) == True)
-            # self.countries = [self.countries[i] for i in indexes[0]]
-
-            for individual in e_individuals:
-                random_country = self.countries[random.randint(0, len(self.countries) - 1)]
-                np.append(random_country.population, np.array([individual]))
-                random_country.sort_population()
-            self.countries = sorted(self.countries, key=attrgetter('best_function'))
-            if not self.countries:
-                break
-            result = self.countries[0].population[0]
-
-            if self.printing:
-                print(f"{ti}) Лучшее решение: {result.real_x} - {result.f}, Стран осталось: {len(self.countries)}, Движение/Обмен/Войны/Эпидемии: {motion}/{trade}/{war}/{epedemic}")
-                print(f"Общее количество особей: {sum([len(country.population) for country in self.countries])}")
-                print("++++++++++++++++++++++++++++++++++++++++++++++++++")
-                for i, country in enumerate(self.countries):
-                    print(f'{i + 1})', country.name, len(country.population), country.best_function, country.avg_function)
-                print("++++++++++++++++++++++++++++++++++++++++++++++++++")
-
-            if self.memory_list is not None:
-                self.memory_list[0] = ti
-                for i in range(len(result.real_x)):
-                    self.memory_list[i + 1] = float(result.real_x[i])
-                self.memory_list[-1] = float(result.f)
-
-        return (result.real_x, result.f, False, ti)
-
-
-
-def f(x):
-    return sum([(xi ** 4 - 16 * xi ** 2 + 5 *xi) / 2 for xi in x])
-#
-# k = 0
-# for i in range(100):
-CA = CountriesAlgorithm(
-    f=f,
-    Xmin=[-5.12 for i in range(20)],
-    Xmax=[5.12 for i in range(20)],
-    genes=[16 for i in range(20)],
-    M=20,
-    N=15,
-    n=[1, 10],
-    m=[3, 8],
-    k=8,
-    l=3,
-    ep=[0.2, 0.4],
-    max_mutation=16,
-    tmax=300,
-    printing=True,
-)
-r = CA.start()
-
-#     print(i, r[2], r[0], r[1])
-#     if r[2]:
-#         k += 1
-#
-# print(k/100)

PyPharm/algorithms/genetic_optimization.py

@@ -1,130 +0,0 @@
-import graycode
-import numpy as np
-import copy
-
-class Individual:
-
-    x_min = None
-    x_max = None
-    genes = None
-    function = None
-    gray_code = None
-    f = None
-
-    def __init__(self, gray_code, x_min, x_max, genes, function, mutation_chance=None, max_mutation=1):
-
-        self.x_min = x_min
-        self.x_max = x_max
-        self.genes = genes
-        self.function = function
-        self.steps = (self.x_max - self.x_min) / (2 ** (self.genes) - 1)
-        self.gray_code = gray_code
-        if mutation_chance is not None and np.random.random() < mutation_chance:
-            self.mutation(max_mutation)
-        self.f = self.function(self.real_x)
-
-    @property
-    def real_x(self):
-        decimal_x = []
-        gray_code = copy.deepcopy(self.gray_code)
-        for g in self.genes:
-            decimal_x.append(graycode.gray_code_to_tc(int(gray_code[:g], base=2)))
-            gray_code = gray_code[g:]
-        return self.x_min + self.steps * np.array(decimal_x)
-
-    @property
-    def decimal_x(self):
-        return (self.real_x - self.x_min) / self.steps
-
-    @classmethod
-    def generate_from_decimal(cls, decimal, x_min, x_max, genes, function):
-        gray_code = ''
-        decimal = np.clip(decimal, np.zeros(decimal.size), 2 ** (genes) - 1)
-        for i in range(len(decimal)):
-            s = '{:0' + str(genes[i]) + 'b}'
-            gray_code += s.format(graycode.tc_to_gray_code(int(decimal[i])))
-
-        return cls(gray_code, x_min, x_max, genes, function)
-
-    @classmethod
-    def crossover(cls, individual1, individual2, mutation_chance, max_mutation=1):
-        k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
-        while k[0] == k[1]:
-            k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
-        k = np.sort(k)
-        new_gray1 = individual1.gray_code[:k[0]] + individual2.gray_code[k[0]:k[1]] + individual1.gray_code[k[1]:]
-        new_gray2 = individual2.gray_code[:k[0]] + individual1.gray_code[k[0]:k[1]] + individual2.gray_code[k[1]:]
-        return [
-                cls(new_gray1, individual1.x_min, individual1.x_max, individual1.genes,
-                    individual1.function, mutation_chance, max_mutation),
-                cls(new_gray2, individual1.x_min, individual1.x_max, individual1.genes,
-                    individual1.function, mutation_chance, max_mutation),
-        ]
-
-    def mutation(self, max_mutation=1):
-        if max_mutation > 0:
-            n = 1 + np.random.randint(1, max_mutation)
-        else:
-            n = 1
-        k = np.random.choice(len(self.gray_code), n, replace=False)
-        for ki in k:
-            b = bool(int(self.gray_code[ki]))
-            b = not b
-            b = str(int(b))
-            self.gray_code = self.gray_code[:ki] + b + self.gray_code[ki+1:]
-
-    def __lt__(self, other):
-        return self.f < other.f
-
-    def __le__(self, other):
-        return self.f <= other.f
-
-    def __gt__(self, other):
-        return self.f > other.f
-
-    def __ge__(self, other):
-        return self.f >= other.f
-
-
-class GeneticAlgorithm:
-
-    def __init__(self, f, n, child_percent, mutation_chance, max_mutation, x_min, x_max, genes, t_max, printing=False):
-        self.f = f
-        self.n = n
-        self.child_percent = child_percent
-        self.mutation_chance = mutation_chance
-        self.max_mutation = max_mutation
-        self.x_min = np.array(x_min)
-        self.x_max = np.array(x_max)
-        self.genes = np.array(genes)
-        self.t_max = np.array(t_max)
-        self.printing = printing
-
-        self.rand_n_individual = np.vectorize(lambda x: x * self.random_individual(), signature='()->(n)')
-        self.generate_population = np.vectorize(lambda decimal: Individual.generate_from_decimal(
-            decimal, self.x_min, self.x_max, self.genes, self.f), signature='(n)->()')
-
-    def random_individual(self):
-        return np.random.randint(np.zeros(self.genes.size), 2 ** self.genes)
-
-    def start(self):
-        x = self.rand_n_individual(np.ones(self.n))
-        population = self.generate_population(x)
-        child_number = int(self.child_percent * self.n)
-
-        t = 0
-        while t <= self.t_max:
-            new_population = []
-            for i in range(child_number):
-                k = np.random.randint(0, self.n, 2)
-                while k[0] == k[1]:
-                    k = np.random.randint(0, self.n, 2)
-                new_population += Individual.crossover(population[k[0]], population[k[1]],
-                                                       self.mutation_chance, self.max_mutation)
-            population = np.append(population, np.array(new_population))
-            population.sort()
-            population = population[:self.n]
-            if self.printing:
-                print("Поколение {}: {} {}".format(t, population[0].real_x, population[0].f))
-            t += 1
-        return population[0].real_x

PyPharm/algorithms/gold_digger_optimization.py

@@ -1,127 +0,0 @@
-import numpy as np
-
-
-class GoldDigger:
-
-    def __init__(self, x, function):
-        self.x = x
-        self.f = function(self.x)
-        self.ep_n = 0
-
-    def __lt__(self, other):
-        return self.f < other.f
-
-    def __le__(self, other):
-        return self.f <= other.f
-
-    def __gt__(self, other):
-        return self.f > other.f
-
-    def __ge__(self, other):
-        return self.f >= other.f
-
-    def __add__(self, other):
-        return self.f + other.f
-
-    def __radd__(self, other):
-        return self.f + other
-
-    def __truediv__(self, other):
-        return self.f / other
-
-    def update_function(self, function):
-        self.f = function(self.x)
-
-    def new_sigma_digger(self, x_min, x_max, sigma, function):
-        new_x = np.array([self.x[i] + np.random.normal(0, (x_max[i] - x_min[i]) * sigma) for i in range(self.x.size)])
-        new_x = np.clip(new_x, x_min, x_max)
-        return GoldDigger(new_x, function)
-
-
-
-class GoldDiggersAlgorithm:
-
-    def __init__(self, f, n, k, l, u, a, b, sigma_b, sigma_e, Xmin, Xmax, m, t_max):
-        self.f = f
-        self.n = n
-        self.k = k
-        self.l = l
-        self.u = u
-        self.a = a
-        self.b = b
-        self.sigma_b = sigma_b
-        self.sigma_e = sigma_e
-        self.Xmin = np.array(Xmin)
-        self.Xmax = np.array(Xmax)
-        self.m = m
-        self.t_max = t_max
-        self.rand_mat = np.vectorize(lambda x: self.random_matrix(x, Xmin, Xmax), signature='()->(n)')
-        self.digger_init = np.vectorize(lambda x: GoldDigger(x, self.f), signature='(n)->()')
-
-    @staticmethod
-    def random_matrix(x, x_min, x_max):
-        return x * np.random.uniform(x_min, x_max)
-
-    def start(self):
-        x = self.rand_mat(np.ones(self.n))
-        population = self.digger_init(x)
-
-        t = 0
-        intervals = []
-        while t <= self.t_max:
-
-            x = self.rand_mat(np.ones(self.n))
-            in_interval = np.array([self.interval_in(xi, intervals) for xi in x])
-            if np.any(in_interval == True):
-                ind = np.where(in_interval == False)
-                new_x = x[ind]
-                if new_x.size:
-                    population = np.append(population, self.digger_init(new_x))
-                ind = np.where(in_interval == True)
-                r = np.random.rand(ind[0].size)
-                rand_ind = np.where(r <= self.a)
-                ind = (ind[0][rand_ind])
-                x = x[ind]
-                if x.size:
-                    population = np.append(population, self.digger_init(x))
-            else:
-                population = np.append(population, self.digger_init(x))
-
-            sigma = (((self.t_max - t) / self.t_max) ** self.m) * (self.sigma_b - self.sigma_e) + self.sigma_e
-
-            new_diggers = []
-            for digger in population:
-                for _ in range(self.k):
-                    new_diggers.append(digger.new_sigma_digger(self.Xmin, self.Xmax, sigma, self.f))
-            population = np.append(population, new_diggers)
-            population = np.sort(population)
-
-            worst_diggers = population[self.n:]
-            r = np.random.rand(worst_diggers.size)
-            ind = np.where(r <= self.b)
-            worst_diggers = worst_diggers[ind]
-            for digger in worst_diggers:
-                intervals.append(
-                    (digger.x - (self.Xmax - self.Xmin) * sigma, digger.x + (self.Xmax - self.Xmin)  * sigma)
-                )
-            if len(intervals) > self.u:
-                intervals = intervals[len(intervals) - self.u - 1:len(intervals) - 1]
-            population = population[:self.n]
-            print("Поколение {}: {} {}".format(t, population[0].x, population[0].f))
-            t += 1
-        return population[0].x
-
-    @staticmethod
-    def interval_in(x, intervals):
-        for interval in intervals:
-            res = [x[i] >= interval[0][i] and x[i] <= interval[1][i] for i in range(len(x))]
-            if any(res):
-                return True
-        return False
-
-
-def f(x):
-    return sum([(xi ** 4 - 16 * xi ** 2 + 5 *xi) / 2 for xi in x])
-
-# gda = GoldDiggersAlgorithm(f, 15, 10, 10, 50, 0.5, 0.5, 0.5, 0.000001, [-5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12], [5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12], 2, 300)
-# gda.start()