DALGLI0/main.py

import itertools


class Poly:

    def __init__(self, int_mod, elements):
        self.elements = {}
        self.int_mod = int_mod

        i = len(elements) - 1
        for e in reversed(elements):
            self.elements[f"x{i}"] = e % self.int_mod
            i -= 1

    def __str__(self):
        str_form = ""
        deg = len(self.elements) - 1

        for e in self.elements:

            if self.elements[e] >= 0:
                if e != f"x{deg}":
                    str_form += "+ "
            else:
                str_form += "- "

            str_form += str(abs(self.elements[e]))

            if e != "x0":
                str_form += e[0] + "^" + e[1:] + " "

        return str_form

    def __mul__(self, other):

        assert self.int_mod == other.int_mod

        elements = {}

        for e in self.elements:
            for f in other.elements:
                coefficient = self.elements[e] * other.elements[f]
                degree = f"x{int(e[1:])+int(f[1:])}"

                if elements.get(f"{degree}") is None:
                    elements[degree] = coefficient % self.int_mod
                else:
                    elements[degree] += coefficient % self.int_mod

        return Poly(self.int_mod, list(reversed(list(elements.values()))))

    def __mod__(self, other):
        elements = {}

    def __pow__(self, power, modulo=None):
        poly = Poly(self.int_mod, list(reversed(list(self.elements.values()))))

        for i in range(power - 1):
            poly *= poly

        return poly

    def __add__(self, other):

        assert self.int_mod == other.int_mod

        elements = self.elements.copy()

        for f in other.elements:
            if f in elements:
                elements[f] += other.elements[f]
            else:
                elements[f] = other.elements[f]

        els = {}
        for i in reversed(range(len(elements))):
            els[f"x{i}"] = elements[f"x{i}"]

        return Poly(self.int_mod, list(reversed(list(els.values()))))

    def __sub__(self, other):

        assert self.int_mod == other.int_mod

        elements = self.elements.copy()

        for e in other.elements:
            if e in elements:
                elements[e] -= other.elements[e]
            else:
                elements[e] = -other.elements[e]

        els = {}
        for i in reversed(range(len(elements))):
            els[f"x{i}"] = elements[f"x{i}"]

        return Poly(self.int_mod, list(reversed(list(els.values()))))

    def __truediv__(self, other):

        if self.int_mod != other.int_mod:
            raise Exception("Different modulo")

        if other.is_empty():
            raise ZeroDivisionError("Polynomial is empty")

        fdeg = len(self.elements) - 1
        sdeg = len(other.elements) - 1

        while not other.is_empty():
            coefficient = self.elements[f"x{fdeg}"] / other.elements[f"x{sdeg}"]
            coefficient %= self.int_mod
            degree = fdeg - sdeg

            # print(self.elements["x2"])
            # break

    def is_empty(self):

        for e in self.elements:
            if self.elements[e] != 0:
                return False

        return True


class PolyIntField:

    def __init__(self, int_mod, poly_mod):
        self.int_modulo = int_mod
        self.poly_modulo = Poly(int_mod, poly_mod)
        product = list(itertools.product([x for x in range(0, int_mod)],
                                         repeat=len(poly_mod) - 1))

        self.elements = []
        for p in product:
            p = list(p)
            p = [x % int_mod for x in p]
            self.elements.append(Poly(int_mod, p))


    def get_nilpotents(self):
        nilpotents = []

        # for element in self.elements:



if __name__ == "__main__":
    p = Poly(5, [-4, 0, -2, 1])
    # print(p)
    # c = p * p
    # print(c.elements)
    # print(c)
    # print(p ** 2)

    # print(p)
    # print(d)
    # print(p)
    # print(p + d)
    d = Poly(5, [-3, 1])
    g = Poly(5, [1, 2, 1])
    print(d)
    print(g)
    print()

    # print()
    # print(g ** 2)
    # print(d)
    # print(g)
    # # c = d * g
    # print(g * d)
    # print(d * g)
    # print(g + d)
    # print(d + g)
    # print(d)
    # print(g)
    print(g - d)
    print(d - g)

    print()
    print(d + g)
    print(g + d)
    # print(d)
    # print(g)
    # print(g - d)
    # print(p / d)
    # print(p.elements[0])
    # a = PolyIntField(3, [1, 1, 2, 2])
    # for e in a.elements:
    #     print(e.elements)

    # print()
    # print(a.elements[4])
    # print(a.elements[8])
    # print(a.elements[4] * a.elements[8])
    # a.elements[3] / a.elements[1]