#-*- coding: utf-8 -*-
#Utilisation de Sympy pour faire des calculs avec des complexes
#Programme créé par Martine Arrou-Vignod Août 2015

#bibliothèques pouvant être utiles 
%matplotlib inline

from math import * 
# Pour l'algèbre linéaire
import numpy as np
import numpy.linalg as la#Pour tracer des courbes
#Pour tracer des courbes
import matplotlib.pyplot as plt

#pour faire du calcul formel
from sympy import *

#Pour pouvoir utilser mathjax pour écrire des formules 
init_printing(use_latex='mathjax')

#Ecriture d'un nombre complexe sous forme cartésienne
z=sqrt(3)+6*I
z

#Ecriture d'un nombre complexe sous forme trigonométrique
z=3*exp(I*pi/6)
z

#Défintion des variables utiles dans les calculs et de leur type 
x,y,z,t,a,b,c,d,teta,r =symbols("x y z t a b c d teta,r",real=True)
k,n,p,l=symbols("k n p l",integer=True)

####Déclaration des fonctions utiles  

def argumentz(z1):
    return simplify(arg(z1))

#-----------------
def modulez(z1):
    return simplify(abs(z1))
#-----------------
#renvoie la forme cartésienne d'un produit z1*z2
def multiz(z1,z2):
    mul=z1*z2
    mul=simplify(mul.expand(complex=True))
    return mul 
#-----------------
#renvoie la forme cartésienne d'un nombre quelconque de complexes
def multizn(*z):
    mul=1
    for k in range(len(z)):
        mul=mul*z[k]
    mul=simplify(mul.expand(complex=True))
  
    return mul 
#-----------------
#renvoie la forme cartésienne d'un quotient z1*z2

def divz(z1,z2):
    if modulez(z2) !=0 :
        quo=z1*conjugate(z2)
        quo=quo.expand(complex=True)
        quo=quo/(modulez(z2)**2)
        quo=simplify(quo.expand(complex=True))
        return quo
    else :
        return "erreur: division  par zéro"
def inversez(z1):
    return divz(1,z1)
#-----------------#
 
#renvoie le nombre z1*z2, son module, son argument
#Si z2=1 renvoie le nombre complexe z1, son module, son argument
def multiplicationz(z1,z2):
    argumentmul=argumentz(z1)+argumentz(z2)
    mulc=multiz(z1,z2)
    mulc=mulc.expand(complex=true)
    modulemul=modulez(mulc)
    modulemul=modulemul.expand(basic=true)
    argumentmul=argumentmul.expand(basic=true)
    return mulc,modulemul,argumentmul

def argumentproduit(*z):
    argumentmul=0
    for k in range(len(z)):
        argumentmul=argumentmul+arg(z[k])
    argumentmul=simplify(argumentmul.expand(complex=true))
    return argumentmul

def moduleproduit(*z):
    resultat=simplify(abs(multizn(*z)))
    return resultat

#renvoie le nombre z1/z2, son module, son argument        
def divisionz(z1,z2):
    if modulez(z2) !=0 :
        modulequo=modulez(z1)/modulez(z2)
        argumentquo=argumentz(z1)-argumentz(z2)
        quoz=divz(z1,z2)
        return quoz,modulequo, argumentquo
 

  
#renvoie le nombre z1, son module, son argument        
def formesz(z1):
    forme=multiplicationz(z1,1)
    return forme

argumentz((1+I)**3*(1-I)**5)

modulez((1+I)**3*(1-I)**5)
formesz(((1+I)**3*(1-I)**5))

z=2*exp(-I*pi/4)
z=z.expand(complex=true)
z

z1=2*exp(-I*pi/4)
z2=2*exp(-I*pi/3)
z3=6*exp(-I*pi/6)
z4=1+I
z5=3+3*I
z=multizn(z1,z2,z3,z4,inversez(z5))
z

teta=argumentproduit(z1,z2,z3,z4,inversez(z5))
teta

mo=moduleproduit(z1,z2,z3,z4,inversez(z5))
mo

zi=inversez(z5)
zi

z2=a+I*b
z1=c+I*d
z3=r*exp(I*t)
z4=multizn(z2,z1,z3)
moduleproduit(z2,z1,z3)

#partie réelle de z4
re(simplify(z4))

teta=argumentz(z4)
teta

zc=re(simplify(z4))+I*im(simplify(z4))
zc

#Affiche le nombre sous forme cartésienne et déterminer son module et son argument
print("(forme cartésienne, module, argument)")
z=formesz(4+4*I)
z

z1=3+3*sqrt(3)
z2=4*(1-I)
quotient=divisionz(z1,z2)
print("(forme cartésienne, module, argument)")
quotient

print("forme cartésienne")
quotient[0]

print("module")
quotient[1]

print("argument")
quotient[2]

z1=1+I*1
z2=3*sqrt(3)+3*I
z3=1-I
produit=multiplicationz(z1,z2)
produit

res=multiz(produit[0],z3)
res

resn=multiplicationz(res,1)
resn

res2=multiz(z3,multiz(z1,z2))
res2=multiplicationz(res2,1)
res2

res3=multizn(z3,z1,z2)
res3=multiplicationz(res3,1)
res3

zi=divisionz(a+I*b,c+I*d)

zi

z=x+I*y
Zc=divisionz(z-2*I,z+I)
Zc

re(Zc[0])+I*im(Zc[0])

solve(im(Zc[0]))

solve(re(Zc[0]))