Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

Почему код ничего не выводит from fractions import Fraction import math class Drob: def…

  1. User

    Почему код ничего не выводит

    from fractions import Fraction import math

    class Drob: def init(self, ch=0, zn=1): # Инициализация числителя и знаменателя self.chisl = ch self.znam = zn

    def get_ch(self):
        # Получение числителя
        return self.chisl
    
    def get_zn(self):
        # Получение знаменателя
        return self.znam
    
    def set_ch(self, new_ch):
        # Установка нового числителя
        self.chisl = new_ch
    
    def set_zn(self, new_zn):
        # Установка нового знаменателя
        self.znam = new_zn
    
    # Метод возвращает представление дроби в виде цепной дроби
    def chain_drob(self):
        vect = []
        celoe = self.chisl // self.znam
        ostat = self.chisl % self.znam
        r_i = self.chisl
        r_j = self.znam
        vect.append(celoe)
        print(f"{r_i} = {celoe} * {r_j} + {ostat}")
        while ostat != 0:
            r_i, r_j = r_j, ostat
            celoe = r_i // ostat
            ostat = r_i % ostat
            print(f"{r_i} = {celoe} * {r_j} + {ostat}")
            vect.append(celoe)
        return vect
    
    # Метод для нахождения подходящих дробей
    def get_podhod_drob(self, v):
        vP, vQ = [], []
        for i in range(len(v)):
            if i == 0:
                P = v[0]
                Q = 1
            elif i == 1:
                P = v[0] * v[1] + 1
                Q = v[1]
            else:
                P = v[i] * vP[i - 1] + vP[i - 2]
                Q = v[i] * vQ[i - 1] + vQ[i - 2]
            vP.append(P)
            vQ.append(Q)
            print(f"P{i} = {vP[i]} Q{i} = {vQ[i]}")
        return vP, vQ
    
    # Метод для расчета значений на основе расширенного алгоритма Евклида
    def main_calculations(self, start_matr, a):
        iter = 0
        res = Drob()
        ui_2, ui_1, vi_2, vi_1 = start_matr[0], start_matr[2], start_matr[1], start_matr[3]
        bi_2 = self.get_ch()
        bi_1 = self.get_zn()
        print(f"{'i':>2} {'bi':>5} {'ai':>3} {'ui':>5} {'vi':>5}")
        for ai in [-1] + a:
            if iter == 0:
                bi, ui, vi = bi_2, ui_2, vi_2
            elif iter == 1:
                bi, ui, vi = bi_1, ui_1, vi_1
            else:
                bi = -bi_1 * ai + bi_2
                ui = ui_1 * ai + ui_2
                vi = vi_1 * ai + vi_2
                bi_2, ui_2, vi_2 = bi_1, ui_1, vi_1
                bi_1, ui_1, vi_1 = bi, ui, vi
            print(f"{iter - 2:>2} {bi:>5} {'-' if iter < 2 else ai:>3} {ui:>5} {vi:>5}")
            res.set_ch(ui)
            res.set_zn(vi)
            iter += 1
    
        if res.get_zn() < 0:
            res.set_ch(-res.get_ch())
            res.set_zn(abs(res.get_zn()))
        return res
    
    # Операции над дробями
    def sub(self, a, right_oper):
        # Вычитание дробей
        start_matr = [
            -right_oper.get_ch(), right_oper.get_zn(),
            right_oper.get_zn(), 0
        ]
        return self.main_calculations(start_matr, a)
    
    def add(self, a, right_oper):
        # Сложение дробей
        start_matr = [
            right_oper.get_ch(), right_oper.get_zn(),
            right_oper.get_zn(), 0
        ]
        return self.main_calculations(start_matr, a)
    
    def mult(self, a, right_oper):
        # Умножение дробей
        start_matr = [
            0, right_oper.get_zn(),
            right_oper.get_ch(), 0
        ]
        return self.main_calculations(start_matr, a)
    
    def div(self, a, right_oper):
        # Деление дробей
        start_matr = [
            0, right_oper.get_ch(),
            right_oper.get_zn(), 0
        ]
        return self.main_calculations(start_matr, a)
    
    def scalar_mult_1(self, arr_drA, arr_drB, size):
        # Расчет скалярного произведения новой арифметикой
        res = Drob()
        for i in range(size):
            cur_res = arr_drA[i].mult(arr_drA[i].chain_drob(), arr_drB[i])
            print("------------------------------")
            print(f"Iteration # {i}: {cur_res.get_ch()} / {cur_res.get_zn()}")
            if i == 0:
                res = cur_res
            else:
                res = res.add(res.chain_drob(), cur_res)
            print(f"Intermediate sum: {res.get_ch()} / {res.get_zn()}")
            print("------------------------------")
        return res
    

    def scalar_mult_2(vect1, vect2, size): # Расчет скалярного произведения обычной арифметикой res = 0 for i in range(size): res += vect1[i] * vect2[i] return res

    Пример использования:

    arr_a = [Drob(1, 2), Drob(2, 3), Drob(5, 12)]
    arr_b = [Drob(6, 4), Drob(3, 1), Drob(10, 13)]
    r = arr_a[0].scalar_mult_1(arr_a, arr_b, len(arr_a))
    print(f"Результат скалярного произведения (новые дроби): {r.get_ch()} / {r.get_zn()}")
    print(f"Результат скалярного произведения в виде числа с плавающей точкой (новые дроби): {float(r.get_ch()) / float(r.get_zn())}")
    
    v_a = [1/2, 2/3, 5/12]
    v_b = [6/4, 3/1, 10/13]
    res = scalar_mult_2(v_a, v_b, len(v_a))
    print(f"Результат скалярного произведения (арифметика чисел с плавающей точкой): {res}")
    
  2. Assistant

    Вы написали код внутри определения класса Drob, поэтому код выполняется как часть определения класса, и если вы не вызовете какой-либо метод класса или не создадите экземпляр класса, ничего не будет выполнено.

    Чтобы заставить ваш код выполняться, вам нужно поместить исполняемые строки вне определения класса, например, в конце файла:

    # ... (код класса Drob)
    
    # Пример использования (выносим из определения класса):
    arr_a = [Drob(1, 2), Drob(2, 3), Drob(5, 12)]
    arr_b = [Drob(6, 4), Drob(3, 1), Drob(10, 13)]
    r = arr_a[0].scalar_mult_1(arr_a, arr_b, len(arr_a))
    print(f"Результат скалярного произведения (новые дроби): {r.get_ch()} / {r.get_zn()}")
    print(f"Результат скалярного произведения в виде числа с плавающей точкой (новые дроби): {float(r.get_ch()) / float(r.get_zn())}")
    
    v_a = [1/2, 2/3, 5/12]
    v_b = [6/4, 3/1, 10/13]
    res = scalar_mult_2(v_a, v_b, len(v_a))
    print(f"Результат скалярного произведения (арифметика чисел с плавающей точкой): {res}")
    

    Скопируйте исполняемый код в конец файла после определения класса Drob, и ваша программа начнет выводить результаты в консоль.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.