Pour travailler en Python avec les nombres complexes, on dispose du type natif complex que l'on complète en important le module cmath.

Voici quelques exemples testés en console :

>>> import cmath as cp
>>> z = complex (1, 2) # z = 1 + 2i
>>> z
(1+2j)  # j est utilisé pour le nombre tel que j**2 = -1
>>> z.real
1
>>> z.imag
2.0
>>> type(z)
<class 'complex'>
>>> (1+1j).conjugate()
(1-1j)
>>> (1+2j) + (2-3j)
(3-1j)
>>> (1+2j) * (2-3j)
(8+1j)
>>> (1+2j) / (2-3j)
(-0.30769230769230776+0.5384615384615384j)
>>> (1+2j)**7
(29+278j)
>>> abs(3-4j)
5.0
>>> cp.polar(1-1j)
(1.4142135623730951, -0.7853981633974483)
>>> cp.rect(1 , 2*cp.pi/3)
(-0.4999999999999998+0.8660254037844387j)

On utilise le module pyplot de la bibliothèque matplotlib avec l'alias plt :

import matplotlib.pyplot as plt

Rappel : Pour tracer une ligne polygonale ABCD…, on utilise plt.plot. Par exemple, si les points ont les coordonnées (1, 2), (3,4), (10,21), (5, 13), on écrira :

plt.plot([1, 3, 10, 5], [2, 4, 21, 13], 'k')
# k pour noir. Autrement r pour rouge, b pour bleu

On sait que dans le plan complexe l'image d'un point $M$ d'affixe $z$ par une rotation de centre $\Omega$ d’affixe $\omega$ et d’angle $\theta$ est le point $M'$ d'affixe $z'$ telle que $z' - \omega = \text{e}^{i\,\theta} (z - \omega)$, c'est-à-dire $z' = \omega + \text{e}^{i\,\theta} (z - \omega)$.

Ici on part d'un segment $[A, B]$ donné par les affixes (complexes) $a$ et $b$ de $A$ et $B$, on divise ce segment en trois segments de même longueur et on remplace le segment du milieu par les deux autres côtés d'un triangle équilatéral construit sur ce segment, pour obtenir le motif suivant – pour $a = 0$ et $b = 3$.

Partant des points $A$ et $B$, on doit déterminer la position des points $C$, $D$ et $E$.

• $C$ est tel que $\overrightarrow{AC} = \frac{1}{3} \overrightarrow{AB}$
• $D$ est tel que $\overrightarrow{AD} = \frac{2}{3} \overrightarrow{AB}$
• $E$ est l'image de $D$ par la rotation de centre $C$ et d'angle $\frac{pi}{3}$.

La fonction précédente remplace un segment par une ligne polygonale de 4 segments. On voudrait répéter ce processus sur les 4 segments.

Autrement dit, nous sommes partis de $AB$ et sommes arrivés à la ligne $ACEDB$. On voudrait faire de même sur $AC$, $CE$, $ED$, $DB$.

Et ainsi de suite jusqu'à une certaine limite – mathématiquement on peut imaginer faire cela à l'infini, mais en informatique l'infini est hors de portée.

On a une fonction récursive. Nous allons écrire une fonction decoupe_rec(affixes_in, n, extr) qui reçoit affixes_in, un tableau d'affixes ; n indiquant la profondeur à atteindre dans la récursion. La fonction renvoie le tableau des affixes obtenues après découpage.

FONCTION decoupe_rec(affixes_in, n)
ENTRÉES:
  affixes_in: tableau d'affixes de la ligne à découper
  n: profondeur de la récursion
SORTIE: affixe_out, tableau des affixes résultant du découpage de affixe_in
DÉBUT
  SI n = 0 ALORS
    RENVOYER affixes_in
  FIN
  N = nombre d'items dans affixe_in
  affixes_out est tableau vide
  POUR i ALLANT DE 0 À N-2 FAIRE
    A est affixes_in[i]
    B est affixes_in[i+1]
    ACEDB est le résultat de decoupe(A, B)
    # on poursuit le découpage récursivement
    rec_AB est le résultat de decoupe_rec(ACEDB, n-1)
    ajouter les affixes de rec_AB au bout de affixes_out
      sauf le dernier
  FIN
  ajouter l'affixe du dernier points au bout de affixes_out
  RENVOYER affixes_out
FIN