Переделка программы

class korobka(): 
    def __init__(self,x=0,y=0): 
        self.x = x 
        self.y = y 
        if x > 0 and y > 0: 
            print("Розмеры для коробки:: " + "\nA = ", x," см." "\nB = ", y," см.") 
            print("\nУспешно") 
        else: 
            print("Неудача:)") 
    def obiem(self): 
        x = 12
        y = -(4 * self.x + 4 * self.y) 
        proizv = self.x * self.y 
        D = ((y 2) - 4 * x * proizv) (1 / 2) 
        x1 = ((-1 * y) + D) / (2 * x) 
        x2 = ((-1 * y) - D) / (2 * x) 
        print("\nКорни: ", round(x1,2), " ; ",round(x2,2), "\n") 
        if x1 * 2 < self.x and x1 * 2 < self.y: 
            print("1 Корень подходит под коробку  Ответ:", x1) 
            print("\nОбьём = ", self.a * self.b * round(x1,2)) 
            print("\nРазмеры коробки   ", "A =",self.x,"B =",self.b,"H =",x1) 
        else: 
            print("\n1 корень не подходит под коробку\n") 
        if x2 * 2 < self.x and x2 * 2 < self.y: 
            print("2 корень подходит под коробку\n\nОтвет:", x2) 
            print("\nОбЬём = ", ((self.x-(2*x2)) * (self.y-(2*x2)) * round(x2,2)),"куб см") 
            print("\nРозмеры коробки   ", "\nA =",self.x-(2*x2),"\nB =",self.y-(2*x2),"\nH =",x2) 
        else: 
            print("\n2 корень подходит  под коробку\n") 
test = korobka(18,10) 
test.obiem()

import random
from typing import Tuple, List
import numpy as np
import matplotlib.pyplot as plt
 
class Genome:
    values = np.array([])
    fitness = None
 
    def __init__(self, low: int, high: int, volume: int):
        self.low = low
        self.high = high
        self.volume = volume
 
    @classmethod
    def random_init(cls, size: int, low: int, high: int, volume: int):
        self = cls(low, high, volume)
        self.values = self.random_values(size)
        return self
 
    def random_values(self, size: int) -> np.array:
        tmp = np.random.uniform(self.low, self.high, size - 1)
        return np.array([tmp[0], tmp[1], self.volume / tmp[0] / tmp[1]])
 
    def __eq__(self, other):
        return np.array_equal(self.values, other.values)
 
    def __lt__(self, other):
        return self.fitness < other.fitness
 
    def __str__(self):
        return f'({self.values}, fitness={self.fitness}'
    
    def __repr__(self): 
        return str(self)
    
class GeneticAlgorithm:
    def __init__(self,
                 population_size: int,
                 genome_size: int,
                 volume: int,
                 value_range: Tuple[int, int],
                 max_iterations: int):
        self.population = self.create_population(population_size, genome_size, value_range, volume)
        self.calc_fitness()
        self.max_iterations = max_iterations
        self.best_gene = self.population[0]
 
    @staticmethod
    def create_population(population_size: int, genome_size: int, value_range: Tuple[int, int], volume) -> list:
        return [Genome.random_init(genome_size, *value_range, volume) for _ in range(population_size)]
 
    def solve(self) -> np.array:
        for iteration in range(self.max_iterations):
            for genome in self.population:
                if genome.fitness < self.best_gene.fitness:
                    self.best_gene = genome
 
            self.population = self.get_new_population()
            self.calc_fitness()
        return self.best_gene
 
    def get_new_population(self) -> List[Genome]:
        genome = self.population[0] 
        if False not in list(map(lambda g: g == genome, self.population)):
            return self.create_population(len(self.population), len(genome.values), (genome.low, genome.high), genome.volume)
 
        new_population = []
        fittest_half = self.select_fittest_half()
 
        for _ in range(len(self.population) - 1):
            parents = np.random.choice(fittest_half, 2)
            new_genome = self.mating(parents)
            new_population.append(new_genome)
            
        new_population.append(self.best_gene)
        
        return new_population
 
    def calc_fitness(self):
        for genome in self.population:
            genome.fitness = genome.values[0] * genome.values[1] * 2 + genome.values[2] * genome.values[1] * 2 + genome.values[0] * genome.values[2]
 
    def select_fittest_half(self) -> list:
        return sorted(self.population)[:(len(self.population) // 2)]
 
    @staticmethod
    def mating(parents: List[Genome]) -> Genome:
        if np.random.randint(0, 1) == 1:
            parents = (parents[1], parents[0])
 
        parent = parents[0]
        genome_size = len(parent.values)
 
        pivot_1 = np.random.randint(0, genome_size)
        pivot_2 = np.random.randint(0, genome_size)
 
        new_genome = Genome(parent.low, parent.high, parent.volume)
        new_genome.values = np.array([
            parents[0].values[pivot_1],
            parents[1].values[pivot_2], 
            parent.volume / parents[0].values[pivot_1] / parents[1].values[pivot_2]
        ])
        return new_genome
 
def main():
    genetic_algo = GeneticAlgorithm(
        population_size=10,
        genome_size=3,
        volume=15,
        value_range=(1, 15),
        max_iterations=10000,
    )
 
    genome = genetic_algo.solve()
 
    print(f'Min square value: {genome.fitness:0.2f}')
    print(genome.values)
 
if __name__ == '__main__':
    main()