import math as math

class Complexe:

    # on peut définir des paramètres par défaut, 
    # si aucun n'est fourni, alors on donne la valeur 0
    def __init__(self,r=0,i=0):
        # il n'y a que 2 attributs (choix personnel), 
        # on garde la forme algébrique du complexe
        self.re = r
        self.im = i
        
    def partie_reelle(self):
        """ renvoie un réel """
        return self.re

    def partie_imaginaire(self):
        """ renvoie un réel """
        return self.im

    def en_chaine(self):
        """ renvoie une chaîne de caractères structurées """
        # utilisation d'un formatage
        if self.re==0:
            return "imaginaire pur : {} i".format(self.im)
        if self.im==0:
            return "réel : {}".format(self.re)
        return "{} + {} * i".format(self.re,self.im)
    
    def module(self):
        """ renvoie le module du complexe """
        return math.sqrt(self.re**2 + self.im**2)

    def argument(self):
        """ renvoie l'argument entre 0 et 2 pi """
        # cas d'un imaginaire pur
        if self.re==0:
            if self.im>0:
                return math.pi/2
            elif self.im<0:
                return 3*math.pi/2
            else:
                return 0 # cas pathologique de (0,0)
        # atan renvoie une valeur entre -pi/2 et pi/2    
        # il faut donc faire attention au quadrant    
        if self.re<0:
            return math.atan(self.im/self.re)+math.pi # dans les quadrants 2 et 3
        elif self.im<0:
            return math.atan(self.im/self.re)+2*math.pi # dans le quadrant 4
        else:
            return math.atan(self.im/self.re) # dans le quadrant 1

    def conjugue(self):
        """ modifie l'instance, donne le conjugué """
        self.im = -self.im

    def forme_trigo(self,mod,arg):
        """ modifie l'instance quand on fournit module et argument """
        self.re = mod*math.cos(arg)
        self.im = mod*math.sin(arg)

    def puissance(self,r):
        """ modifie l'instance, en renvoyant self^r """
        self.forme_trigo(self.module()**r,r*self.argument())

    def racines(self,n):
        """ renvoie la liste des n racines n-ièmes """
        temp=[]
        m=(self.module())**(1/n)
        a=(self.argument())/n
        z=Complexe()
        for k in range(0,n):
            z.forme_trigo(m,a+k*2*math.pi/n)
            # on construit à chaque fois, un nouveau complexe à mettre dans le tableau
            # la commande temp.append(z) donnerait n copies du même "pointeur"
            # il faut alloué la place en mémoire pour n complexes
            # donc on utilise n fois Complexe()
            temp.append(Complexe(z.re,z.im))
        return temp

    def inverse(self):
        """ modifie l'instance en renvoyant 1/z """
        if self.re==0 and self.im==0:
            print("inverse de 0")
        else:
            m=(self.module())**2
            self.re = self.re/m
            self.im = -self.im/m

    def additionner(self,z):
        """ modifie l'instance en lui ajoutant z """
        self.re += z.re
        self.im += z.im
    
    def soustraire(self,z):
        """ modifie l'instance en lui soustrayant z """
        self.re -= z.re
        self.im -= z.im

    def multiplier(self,z):
        """ modifie l'instance en la multipliant par z """
        # attention à ne pas assigner self.re directement sa nouvelle valeur
        reel = self.re * z.re - self.im * z.im
        imag = self.im * z.re + self.re * z.im
        self.re = reel
        self.im = imag

    def diviser(self,z):
        """ modifie l'instance en la multipliant par z """
        if z.re==0 and z.im==0:
            print("division par 0")
        else:
            temp=Complexe(z.re,z.im)
            temp.inverse()
            self.multiplier(temp)
         
# operators "overloading" , surcharge d'opérateurs classiques

    def __add__(self,z):
        """ renvoie la somme de deux complexes """
        # on doit construire un nouveau complexe
        return Complexe(self.re + z.re, self.im + z.im)

    def __sub__(self,z):
        return Complexe(self.re - z.re, self.im - z.im)

    def __mul__(self,z):
        return Complexe(self.re * z.re - self.im * z.im, self.im * z.re + self.re * z.im)

    def __truediv__(self,z): 
        z.conjugue()/z.module()**2
        return 0

    def __neg__(self):
        return Complexe(-self.re,-self.im)

    def __pow__(self,r): 
        temp = Complexe()
        temp.forme_trigo(self.module()**r,r*self.argument())
        return temp

    def __eq__(self,z): 
        if self.re==z.re and self.im==z.im:
            return True
        else:
            return False

# quelques test en classe
w = Complexe(12,5)
print("****", w.en_chaine())

# test de la fonction argument, dans tous les cas
z = Complexe(1,1)
print("Q1 pi/4 ",math.pi/4, z.argument())
z = Complexe(-1,1)
print("Q2 3pi/4 ",3*math.pi/4, z.argument())
z = Complexe(-1,-1)
print("Q3 5pi/4 ",5*math.pi/4, z.argument())
z = Complexe(1,-1)
print("Q4 7pi/4 ",7*math.pi/4, z.argument())

# sans paramarètres, valeurs par défaut
z = Complexe()  # idem Complexe(0,0)
z.forme_trigo(math.sqrt(2),math.pi/4)
print("forme trigo.",z.en_chaine())

# conjugué
z=Complexe(500,1000)
z.conjugue()
print("conjugué ",z.en_chaine())

# puissance
z = Complexe(2,1)
z.puissance(212)
print("puissance ",z.en_chaine())

# inverse
z1=Complexe(2,4)
z1.inverse()
z2=Complexe(2,4)
print("inverse ?",(z1*z2).en_chaine())

# attention aux "copies" !

z1=Complexe(2,4)
z2=z1 # comme pour les listes, z2 n'est qu'un alias vers le même objet...
z1.inverse()
print("n'est pas 1 ?!#",(z1*z2).en_chaine())

# addition
z = Complexe(2,1)
z2 = Complexe(3,4)
z.additionner(z2)
print("addition ",z.en_chaine())

# soustraction
z = Complexe(2,1)
z2 = Complexe(3,4)
z.soustraire(z2)
print("soustraction ",z.en_chaine())

# multiplication
z = Complexe(2,1)
z2 = Complexe(3,4)
z.multiplier(z2)
print("multiplication ",z.en_chaine())

# division
z = Complexe(2,1)
z2 = Complexe(3,4)
print("division ",z.en_chaine())
z.diviser(z2)
print("division ",z.en_chaine())
print("division ",z2.en_chaine())

# definition du +
z = Complexe(2,1)
z2 = Complexe(3,4)
w=z+z2
print("le nouveau +... ({}) + ({}) ={}".format(z.en_chaine(),z2.en_chaine(),w.en_chaine()))

# definition du -
w=-z
print(w.en_chaine())

# definition du **
z=Complexe(0,1)
temp=Complexe()
for i in range(0,4):
    temp += z**(i/4)
print(temp.en_chaine())

# somme des racines n-ièmes d'un complexe vaut 0
z=Complexe(-2,4)
temp=Complexe()  # contient 0 
for x in z.racines(8):
    print(x.en_chaine())
    temp += x
print("la somme des racines ", temp.en_chaine())

# attention quand on ne crèe une nouvelle instance 
print("================")
z1=Complexe(2,4)
z2=z1 # z2 est un alias de z1, ils pointent tous deux vers le même objet
z1.conjugue()
print(z1.en_chaine())
print(z2.en_chaine())


