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}$
• $C$ 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(a,b,n) qui reçoit les affixes de $A$ et $B$ ainsi qu'un entier n indiquant la profondeur à atteindre dans la récursion.

• n = 0 signifie qu'on ne découpe rien, on renvoie [], tableau vide.
• n = 1 signifie qu'on fait une étape de découpe, on renvoie alors [c, e, d] comme dans decoupe(a,b)
• n = 2 signifie que l'on calcule récursivement les points du découpage sur (a,c), (c,e), (e,d), (d,b)
• etc.

FONCTION decoupe_rec(a, b, n)
ENTRÉES:
  a, b: affixe des points A, B
  n: profondeur de la récursion
DÉBUT
  SI n = 0 ALORS
    RENVOYER tableau vide
  FIN SI
  calculer c, e, d avec decoupe
  SI n = 1
    RENVOYER [c, e, d]
  FIN SI
  calculer ac = decoupe_rec(a, c)
  calculer ce = decoupe_rec(c, e)
  calculer ed = decoupe_rec(e, d)
  calculer db = decoupe_rec(d, b)
  RENVOYER ac + [c] + ce + [e] + ed + [d] + db
FIN

La fonction decoupe_rec prend $A$ et $B$ et renvoie les points intérieurs au découpage. Si on veut la ligne complète, incluant les extrémités $A$ et $B$, il faudra écrire :

[a] + decoupe_rec(a, b, n) + [b]

De la même façon, si on part d'une ligne brisée ABCDEF…, on pourra faire

[a] + decoupe_rec(a, b, n) + [b] + decoupe_rec(b, c, n) + [c] + ...