Klasa macierzy liczb zespolonych. Przeciążanie operatowów.

Witam
Mam problem z klasą macierzy liczb zespolonych.
Nie działa mi przeciążanie operatorów +,-,*.
Jak poprawnie to zrobić?

class zcomplex:
    def __init__(self,real=1,imag=0):
        self.real=real
        self.imag=imag
    def __repr__(self):
        return f'<r:{self.real} i:{self.imag}>'
    def display(self):
        print(self)

class zmatrix:
    def __init__(self, real=0 ,imag=0, rows=3):
        self.rows=rows
        self.tab=[[zcomplex(real,imag) for _ in range(rows)] for _ in range(self.rows)]
    def __repr__(self):
        return '\n'.join(' '.join(str(c) for c in self.tab[i]) for i in range(self.rows))
    def display(self):
        print(self)
def __add__(self,other):
    tmp=zmatrix(self,0,0,rows)
    for i in range(self.rows):
        for j in range(self.rows):
            tmp.tab[i][j]= self.tab[i][j] + other.tab[i][j]
    return tmp

def __sub__(self,other):
    tmp=zmatrix(self,0,0,rows)
    for i in range(self.rows):
        for j in range(self.rows):
            tmp.tab[i][j]= self.tab[i][j] - other.tab[i][j]
    return tmp

def __mul__(self,other):
    tmp=zmatrix(self,0,0,rows)
    for i in range(self.rows):
        for j in range(self.rows):
            for k in range(self.rows):
                tmp.tab[i][j]+= self.tab[i][j] * other.tab[i][j]
    return tmp

W przypadku gdy robię to w jednej klasie wszystko działa.

class zcomplex:
def __init__(self,rows,real,imag):
    self.rows=rows
    self.real=real
    self.imag=imag
    self.tab=[[complex(self.real,self.imag)]*self.rows for i in range(rows)]
    
def __add__(self,other):
    tmp=zcomplex(self.rows,0,0)
    for i in range(self.rows):
        for j in range(self.rows):
            tmp.tab[i][j]= self.tab[i][j] + other.tab[i][j]
    return tmp

def __sub__(self,other):
    tmp=zcomplex(self.rows,0,0)
    for i in range(self.rows):
        for j in range(self.rows):
            tmp.tab[i][j]= self.tab[i][j] - other.tab[i][j]
    return tmp

def __mul__(self,other):
    tmp=zcomplex(self.rows,0,0)
    for i in range(self.rows):
        for j in range(self.rows):
            for k in range(self.rows):
                tmp.tab[i][j]+= self.tab[i][j] * other.tab[i][j]
    return tmp

def prm(self):
    for i in range(self.rows):
        print(self.tab[i])
    print('')

Liczby zespolone są w Pythonie wbudowane, piszesz a +jb, gdzie a, b to floaty. Jak, w ogóle nie działa, podaj przykład, co się dzieje, jak wykonujesz operacje na obiektach.

self.tab[i][j] + other.tab[i][j]

element tab jest typu zcomplex i nie ma operatora add, musisz utworzyć je w obu miejscach

class zcomplex:
    def __init__(self,real=1,imag=0):
        self.real=real
        self.imag=imag
    def __repr__(self):
        return f'<r:{self.real} i:{self.imag}>'
    def display(self):
        print(self)
    def __add__(self, other):
      return zcomplex(real + other.real, imag + other.imag)
   // I tak dalej

Zmieniłem teraz swoją klasę ale mam komunikat:
File "<string>", line 51, in <module>
File "<string>", line 30, in add
TypeError: init() takes from 1 to 4 positional arguments but 5 were given

class zcomplex:
    def __init__(self,real=1,imag=0):
        self.real=real
        self.imag=imag
        
    def __repr__(self):
        return f'<r:{self.real} i:{self.imag}>'
        
    def display(self):
        print(self)
    
    def __add__(self, other):
        return zcomplex(self.real + other.real, self.imag + other.imag)
    
    def __mul__(self,other):
            return zcomplex(self.real * other.real - self.imag * other.imag , self.imag* other.real + self.real * other.imag)

class zmatrix(zcomplex):
    def __init__(self, real=0 ,imag=0, rows=3):
        self.rows=rows
        self.tab=[[zcomplex(real,imag) for _ in range(rows)] for _ in range(self.rows)]
        
    def __repr__(self):
        return '\n'.join(' '.join(str(c) for c in self.tab[i]) for i in range(self.rows))
        
    def display(self):
        print
        
    def __add__(self,other):
        tmp=zmatrix(self,0,0,self.rows)
        for i in range(self.rows):
            for j in range(self.rows):
                tmp.tab[i][j]= self.tab[i][j] + other.tab[i][j]
        return tmp


    def __mul__(self,other):
        tmp=zmatrix(self,0,0,rows)
        for i in range(self.rows):
            for j in range(self.rows):
                for k in range(self.rows):
                    tmp.tab[i][j]+= self.tab[i][j] * other.tab[i][j]
        return tmp
    
a=zmatrix(1,2,3)
a.display()
print(' ')
b=zmatrix(1,2,3)
a.display()

c=a+b
c.display

d=a*b
d.display()

Pisałem Ci, że liczby zespolone są wbudowane, sprawdź taki sposób:

class zmatrix:
    def __init__(self, cn = 0 + 0j, rows=3):
        self.rows=rows
        self.tab=[[cn for _ in range(rows)] for _ in range(self.rows)]

    def __repr__(self):
        return '\n'.join(' '.join(str(c) for c in self.tab[i]) for i in range(self.rows))

    def display(self):
        print

    def __add__(self,other):
        tmp=zmatrix(0 + 0j, self.rows)
        for i in range(self.rows):
            for j in range(self.rows):
                tmp.tab[i][j]= self.tab[i][j] + other.tab[i][j]
        return tmp

    def __mul__(self,other):
        tmp=zmatrix(0 + 0j, self.rows)
        for i in range(self.rows):
            for j in range(self.rows):
                for k in range(self.rows):
                    tmp.tab[i][j]+= self.tab[i][j] * other.tab[i][j]
        return tmp

def main():
	cm1 = zmatrix(1, 2)
	cm2 = zmatrix(1, 2)
	print(cm1 + cm2)
	print(cm1 * cm2)

Przepraszam, że dopiero teraz ale wszystko działa. Dzięki wielkie za pomoc.