Объясни что делает даннный код и как он работает 

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}")