TP1 nombres complexes¶

Comment définir des nombres complexes avec python?

In [1]:
z = -1.3 + 2.1j
z
Out[1]:
(-1.3+2.1j)
In [2]:
a, b = -1.3, 2.1
a + bj # cette écriture n'est pas bonne

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[2], line 2
      1 a, b = -1.3, 2.1
----> 2 a + bj # cette écriture n'est pas bonne

NameError: name 'bj' is not defined
In [3]:
a+b*1j
Out[3]:
(-1.3+2.1j)
In [4]:
complex(a,b)
Out[4]:
(-1.3+2.1j)

Pour obtenir les parties réelles et imaginaires d'un nombre complexe on utilise les méthodes z.real et z.imag

In [5]:
z.real
Out[5]:
-1.3
In [6]:
z.imag
Out[6]:
2.1

Q-1) Calculer sur feuille les parties réelles et imaginaires des nombres complexes¶

$$ z_1 = \frac{1-2i}{3+i},\qquad z_2 = \frac{2+i}{2-i},\qquad\text{et}\qquad z_3 = \frac{(1-4i)(1-i)}{(1+i)^2}.$$

Faire les calculs avec Python et vérifier que vous obtenez bien le même résultat (ou trouvez l'erreur)¶

Pour les calcul à la main, on a $$ z_1 = \frac{1-7i}{10} ,\qquad z_2 = \frac{3+4i}{5},\qquad z_3 = \frac{-5 + 3i}{2} $$

Puis avec python:

In [7]:
z1 = (1-2j)/(3+1j)
In [8]:
z1.real, z1.imag
Out[8]:
(0.1, -0.7000000000000001)
In [9]:
1/10, 7/10
Out[9]:
(0.1, 0.7)
In [10]:
z2 = (2+1j)/(2-1j)
In [11]:
z2.real, z2.imag
Out[11]:
(0.6, 0.8)
In [12]:
3/5, 4/5
Out[12]:
(0.6, 0.8)
In [13]:
z3 = (1-4j)*(1-1j)/(1+1j)**2
In [14]:
z3.real, z3.imag
Out[14]:
(-2.5, 1.5)
In [15]:
-5/2, 3/2
Out[15]:
(-2.5, 1.5)

Q-2) Rappeler ce qu’est le module d’un nombre complexe. Créer une fonction module(z) qui calcule ce module.¶

Pour un nombre complexe $z=x+iy$, son module est donné par

$$ |z| = \sqrt{x^2 + y^2} $$

In [16]:
import numpy as np # on utilise numpy pour calculer la racine carrée
In [17]:
def module(z):
    r = np.sqrt(z.real**2 + z.imag**2)
    return r
In [18]:
module(z)
Out[18]:
np.float64(2.4698178070456938)

Bien évidemment, une opération aussi courante est déjà préprogrammée et on pourra calculer le module à l’aide de la fonction np.abs. On peut obtenir également un argument en radiant grâce à la fonction np.angle.

In [19]:
np.abs(z) # fct numpy pour calculer le module d'un nombre complexe
Out[19]:
np.float64(2.469817807045694)

Q-3) Déterminer le module et l’argument en degrés du nombre complexe du nombre complexe $1/2 - i\sqrt{3}/2$. On pourra utiliser np.pi pour avoir une valeur de $\pi$ et np.sqrt pour la racine carrée¶

Ici on a $z = e^{-i\pi/3}$. Son module est donc de 1 et son argument est $-\pi/3$, soit $-60$ degrés

In [20]:
from numpy import pi # avec cette syntaxe on n'a pas besoin du prefixe np. (np.pi) pour appeller pi
In [21]:
pi
Out[21]:
3.141592653589793
In [22]:
z = 1/2 - np.sqrt(3)/2*1j
In [23]:
np.abs(z) # pour le module de z
Out[23]:
np.float64(1.0)
In [24]:
np.angle(z) # pour l'angle, mais en radian
Out[24]:
np.float64(-1.0471975511965976)
In [25]:
-pi/3
Out[25]:
-1.0471975511965976
In [26]:
np.angle(z, deg=True) # l'angle en degrés
Out[26]:
np.float64(-59.99999999999999)

Q-4) Rappeler ce qu’est le conjugué d’un nombre complexe. Créer une fonction conjug(z) qui calcule le conjugué.¶

Pour un nombre complexe $z=x+iy$, le conjugué de $z$ est donné par

$$ \bar z = x-iy $$

In [27]:
def conjug(z):
    return z.real - z.imag*1j
In [28]:
conjug(z)
Out[28]:
np.complex128(0.5+0.8660254037844386j)

De nouveau, une opération si courante est préprogrammée et on peut obtenir le conjugué du nombre z par z.conjugate() (noter la nécessité des parenthèses). On peut mettre des nombres complexes dans des tableaux Numpy ce qui est très avantageux car alors on peut utiliser la même syntaxe que si on manipulait des nombres complexes normaux et le résultat est que le calcule s’effectue composante par composante

In [29]:
z.conjugate() # fct numpy pour calculer le conjugué d'un nombre complexe
Out[29]:
np.complex128(0.5+0.8660254037844386j)

Q-5) Créer un tableau Numpy de nombres complexes très simple grâce à la cellule suivante¶

In [30]:
t = np.array([1j, 1+1j, complex(-1/2, np.sqrt(3)/2)])

Tester les commandes t.real, t.imag, t.conjugate(), np.abs(t), np.angle(t).¶

In [31]:
t.real # donne les parties réelles
Out[31]:
array([ 0. ,  1. , -0.5])
In [32]:
t.imag # donne les parties imaginaires
Out[32]:
array([1.       , 1.       , 0.8660254])
In [33]:
t.conjugate() # donne les conjugués des nombres complexes
Out[33]:
array([ 0. -1.j       ,  1. -1.j       , -0.5-0.8660254j])
In [34]:
np.abs(t) # donne les modules
Out[34]:
array([1.        , 1.41421356, 1.        ])
In [35]:
np.angle(t) # donne les angles (ici en radian)
Out[35]:
array([1.57079633, 0.78539816, 2.0943951 ])

visualisation de quelques opérations sur les nombres complexes¶

On termine par essayer de visualiser quelques opérations sur les nombres complexes. On commence par créer une une fonction de visualisation par le code suivant.

In [36]:
import matplotlib.pyplot as plt
def visualiser(t, couleur='b'):
    plt.plot(t.real, t.imag, 'x'+couleur)
In [37]:
visualiser(t)
No description has been provided for this image

Cette fonction permet d’afficher dans le plan complexe les nombres (complexes) contenus dans t sous la forme de petites croix de couleurs. La couleur par défaut est bleue mais on peut la changer en passant comme argument ’r’ (attention aux quotes), ’g’, ’y’, ’k’ pour avoir différentes couleurs. On pourra également utiliser la visualisation suivante :

In [38]:
def visualiser_fleches(depart, fin):
    plt.quiver(depart.real, depart.imag, (fin-depart).real, (fin-depart).imag, 
               angles='xy', scale_units='xy', scale=1)
In [39]:
def faire_grille(N):
    h = 4/(N-1)
    ind = np.indices((N, N))
    t = -2+h*ind[0]+(-2+h*ind[1])*1j
    return t.flatten()
In [40]:
grille = faire_grille(5) # crée une grille 5x5 de point de C centréee en (0,0)
visualiser(grille)
No description has been provided for this image
In [41]:
visualiser_fleches(0., t[0]) # crée une fléche de (0,0) au point t[0]
No description has been provided for this image

Q-6) Illustrer graphiquement l’effet géométrique de la fonction¶

$$ z\longmapsto \Big(\frac{1}{2}-\frac{\sqrt{3}}{2}i\Big)z$$

In [42]:
# fct produisant la transformation
def fct1(z):
    return complex(1/2, -np.sqrt(3)/2)*z
In [43]:
# transformation de la grille 
z1 = fct1(grille)

# visualisation de la grille transformée
visualiser(grille)
visualiser(z1, 'r')
for u,v in zip(grille, z1):
    visualiser_fleches(u, v)
No description has been provided for this image

Q-7) Illustrer graphiquement l’effet géométrique de la fonction¶

$$ z\longmapsto 2z.$$

In [44]:
# fct produisant la transformation
def fct2(z):
    return 2*z
In [45]:
# transformation de la grille 
z2 = fct2(grille)

# visualisation de la grille transformée
visualiser(grille)
visualiser(z2, 'r')
for u,v in zip(grille, z2):
    visualiser_fleches(u, v)
No description has been provided for this image

Q-8) Illustrer graphiquement l’effet géométrique de la fonction¶

$$ z\longmapsto (1+i)z.$$

In [46]:
# fct produisant la transformation
def fct3(z):
    return (1+1j)*z
In [47]:
# transformation de la grille 
z3 = fct3(grille)

# visualisation de la grille transformée
visualiser(grille)
visualiser(z3, 'r')
for u,v in zip(grille, z3):
    visualiser_fleches(u, v)
No description has been provided for this image

Q-9) Illustrer graphiquement l’effet géométrique de la fonction¶

$$ z\longmapsto -1.2+3i + z.$$

In [48]:
# fct produisant la transformation
def fct4(z):
    return -1.2 + 3j + z
In [49]:
# transformation de la grille 
z4 = fct4(grille)

# visualisation de la grille transformée
visualiser(grille)
visualiser(z4, 'r')
for u,v in zip(grille, z4):
    visualiser_fleches(u, v)
No description has been provided for this image

Q-10) La fonction np.exp est tout à fait capable de prendre en argument des nombres complexes. Pour plusieurs valeurs de $\theta\in [0,2\pi[$ illustrer graphiquement l'effet géométrique de la fonction¶

$$ z\longmapsto e^{i\theta}z.$$

In [50]:
# fct produisant la transformation
def fct5(z, theta):
    return np.exp(theta*1j) * z
In [52]:
# definition de \theta
theta = pi/4

# transformation de la grille 
z5 = fct5(grille, theta)

# visualisation de la grille transformée
visualiser(grille)
visualiser(z5, 'r')
for u,v in zip(grille, z5):
    visualiser_fleches(u, v)
No description has been provided for this image

Q-11) Pour finir, même question avec les deux fonctions suivantes:¶

$$ z\longmapsto z^2 \qquad\text{and}\qquad z\longmapsto e^z.$$

In [53]:
# fct produisant la transformation
def fct6(z):
    return z**2
In [54]:
# transformation de la grille 
z6 = fct6(grille)

# visualisation de la grille transformée
visualiser(grille)
visualiser(z6, 'r')
for u,v in zip(grille, z6):
    visualiser_fleches(u, v)
No description has been provided for this image
In [55]:
# fct produisant la transformation
def fct7(z):
    return np.exp(z)
In [56]:
# transformation de la grille 
z7 = fct7(grille)

# visualisation de la grille transformée
visualiser(grille)
visualiser(z7, 'r')
for u,v in zip(grille, z7):
    visualiser_fleches(u, v)
No description has been provided for this image