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

PyPharm/algorithms/genetic_optimization.py

@@ -1,130 +1,130 @@
-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
+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 +1,127 @@
-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)
+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()