Calculer et Travailler avec des Nombres Complexes en Python

Introduction

Les nombres complexes sont un outil mathematique fondamental qui depasse largement le cadre academique. En programmation, ils trouvent des applications concretes dans de nombreux domaines professionnels :

• Traitement du signal : analyse frequentielle, filtres numeriques, transformees de Fourier
• Electrotechnique : calcul d’impedances, analyse de circuits AC, puissance reactive
• Physique quantique : fonctions d’onde, amplitudes de probabilite
• Computer Graphics : rotations 2D, fractales (ensemble de Mandelbrot)
• Controle automatique : analyse de stabilite, diagrammes de Bode

Python offre une implementation robuste des nombres complexes via le type natif complex et le module cmath. Contrairement au module math qui genere des erreurs sur les racines carrees negatives, cmath gere elegamment ces cas et retourne des resultats complexes.

import math
import cmath

# Le module math echoue sur les racines negatives
try:
    result = math.sqrt(-1)
except ValueError as e:
    print(f"math.sqrt(-1) -> Erreur: {e}")

# Le module cmath gere correctement ce cas
result = cmath.sqrt(-1)
print(f"cmath.sqrt(-1) -> {result}")  # Affiche: 1j

Dans cet article, nous explorerons en profondeur le module cmath avec des exemples pratiques issus de cas d’usage reels.

Comprendre les Nombres Complexes

Un nombre complexe est represente sous forme de a + bi, ou a est la partie reelle et b est la partie imaginaire. La notation i represente l’unite imaginaire, definie par i^2 = -1. En Python, on utilise j au lieu de i pour noter la partie imaginaire.

# Creation de nombres complexes en Python
z1 = 3 + 4j                    # Notation litterale
z2 = complex(3, 4)             # Constructeur complex()
z3 = complex("3+4j")           # Depuis une chaine (sans espaces!)

# Acces aux composantes
print(f"Partie reelle: {z1.real}")       # 3.0
print(f"Partie imaginaire: {z1.imag}")   # 4.0
print(f"Conjugue: {z1.conjugate()}")     # (3-4j)

# Operations arithmetiques de base
z_sum = z1 + z2                # Addition
z_prod = z1 * z2               # Multiplication
z_div = z1 / z2                # Division
z_pow = z1 ** 2                # Puissance

Utiliser le Module cmath

Le module cmath fournit toutes les fonctions necessaires pour manipuler les nombres complexes. Voici les principales categories de fonctions :

Fonctions de Conversion

Fonction	Description	Exemple
cmath.phase(z)	Argument (angle) en radians	cmath.phase(1+1j) -> 0.785
cmath.polar(z)	Conversion en (module, argument)	cmath.polar(1+1j) -> (1.41, 0.785)
cmath.rect(r, phi)	Polaire vers cartesien	cmath.rect(1, 0) -> 1+0j

Fonctions Mathematiques

Fonction	Description
cmath.sqrt(z)	Racine carree complexe
cmath.exp(z)	Exponentielle complexe
cmath.log(z)	Logarithme naturel complexe
cmath.log10(z)	Logarithme base 10

Exemples Pratiques

Exemple 1 : Calcul d’Impedance Electrique

En electrotechnique, l’impedance d’un circuit RLC est un nombre complexe :

import cmath
import math

# Parametres du circuit
R = 100      # Resistance en Ohms
L = 0.1      # Inductance en Henry
C = 0.00001  # Capacite en Farads
f = 50       # Frequence en Hz

# Pulsation angulaire
omega = 2 * math.pi * f

# Calcul des reactances
X_L = omega * L                    # Reactance inductive
X_C = 1 / (omega * C)              # Reactance capacitive

# Impedance complexe: Z = R + j(X_L - X_C)
Z = complex(R, X_L - X_C)

# Module et phase de l'impedance
module, phase = cmath.polar(Z)
phase_deg = math.degrees(phase)

print(f"Impedance: {Z}")
print(f"Module: {module:.2f} Ohms")
print(f"Phase: {phase_deg:.2f} degres")

Exemple 2 : Rotation 2D avec Nombres Complexes

Les nombres complexes permettent d’effectuer des rotations elegamment :

import cmath
import math

def rotate_point(x, y, angle_degrees):
    """Effectue une rotation d'un point autour de l'origine."""
    # Convertir le point en nombre complexe
    point = complex(x, y)

    # Creer le facteur de rotation (formule d'Euler: e^(i*theta))
    angle_rad = math.radians(angle_degrees)
    rotation_factor = cmath.exp(complex(0, angle_rad))

    # Appliquer la rotation
    rotated = point * rotation_factor

    return rotated.real, rotated.imag

# Rotation d'un point (1, 0) de 90 degres
x_new, y_new = rotate_point(1, 0, 90)
print(f"Point (1, 0) apres rotation 90 degres: ({x_new:.4f}, {y_new:.4f})")
# Resultat: (0.0000, 1.0000)

Exemple 3 : Transformee de Fourier Discrete Simplifiee

import cmath
import math

def dft_simple(signal):
    """Calcule la DFT d'un signal (version simplifiee)."""
    N = len(signal)
    result = []

    for k in range(N):
        somme = 0
        for n in range(N):
            # Formule DFT: X[k] = sum(x[n] * e^(-2*pi*i*k*n/N))
            angle = -2 * math.pi * k * n / N
            somme += signal[n] * cmath.exp(complex(0, angle))
        result.append(somme)

    return result

# Signal simple: sinusoide echantillonnee
N = 8
signal = [math.sin(2 * math.pi * n / N) for n in range(N)]

# Calcul de la DFT
spectre = dft_simple(signal)

# Afficher les magnitudes
print("Magnitudes du spectre:")
for k, X in enumerate(spectre):
    print(f"  Bin {k}: {abs(X):.4f}")

Exemple 4 : Ensemble de Mandelbrot

import cmath

def mandelbrot_iterations(c, max_iter=100):
    """Determine si un point appartient a l'ensemble de Mandelbrot."""
    z = 0
    for n in range(max_iter):
        z = z * z + c
        if abs(z) > 2:
            return n  # Diverge apres n iterations
    return max_iter  # Ne diverge pas (dans l'ensemble)

# Tester quelques points
points_test = [
    complex(0, 0),      # Dans l'ensemble
    complex(-0.5, 0),   # Dans l'ensemble
    complex(1, 0),      # Hors de l'ensemble
    complex(-2, 0),     # Limite
]

for c in points_test:
    iters = mandelbrot_iterations(c)
    status = "dans l'ensemble" if iters == 100 else f"diverge apres {iters} iter"
    print(f"c = {c}: {status}")

Fonctions Trigonometriques et Hyperboliques

Le module cmath fournit egalement des fonctions trigonometriques et hyperboliques pour nombres complexes :

import cmath

z = 1 + 2j

# Fonctions trigonometriques
print(f"sin({z}) = {cmath.sin(z)}")
print(f"cos({z}) = {cmath.cos(z)}")
print(f"tan({z}) = {cmath.tan(z)}")

# Fonctions hyperboliques
print(f"sinh({z}) = {cmath.sinh(z)}")
print(f"cosh({z}) = {cmath.cosh(z)}")
print(f"tanh({z}) = {cmath.tanh(z)}")

# Fonctions inverses
print(f"asin({z}) = {cmath.asin(z)}")
print(f"acos({z}) = {cmath.acos(z)}")

Bonnes Pratiques

1. Utilisez cmath plutot que math pour les calculs susceptibles de produire des complexes

import cmath

# Toujours utiliser cmath.sqrt() si le resultat peut etre complexe
def resoudre_quadratique(a, b, c):
    """Resout ax^2 + bx + c = 0, meme avec discriminant negatif."""
    discriminant = b**2 - 4*a*c
    x1 = (-b + cmath.sqrt(discriminant)) / (2*a)
    x2 = (-b - cmath.sqrt(discriminant)) / (2*a)
    return x1, x2

2. Gerez les erreurs de precision flottante

import cmath

z = cmath.exp(complex(0, cmath.pi))  # Devrait etre -1

# La partie imaginaire n'est pas exactement 0
print(f"e^(i*pi) = {z}")  # (-1+1.22...e-16j)

# Utilisez isclose() pour les comparaisons
print(f"Proche de -1? {cmath.isclose(z, -1, rel_tol=1e-9)}")  # True

3. Preferez les constantes du module cmath

import cmath

# Utilisez les constantes predefinies
print(f"pi = {cmath.pi}")
print(f"e = {cmath.e}")
print(f"tau = {cmath.tau}")  # 2*pi
print(f"inf = {cmath.inf}")
print(f"nan = {cmath.nan}")

4. Documentez clairement l’utilisation des complexes

def calculate_impedance(resistance: float,
                        reactance: float) -> complex:
    """
    Calcule l'impedance complexe d'un circuit.

    Args:
        resistance: Partie reelle (Ohms)
        reactance: Partie imaginaire (Ohms)

    Returns:
        Impedance complexe Z = R + jX
    """
    return complex(resistance, reactance)

5. Utilisez abs() pour le module

z = 3 + 4j

# abs() fonctionne nativement sur les complexes
module = abs(z)  # 5.0 (racine de 3^2 + 4^2)

Pieges Courants

Piege 1 : Espaces dans complex()

# ERREUR: les espaces causent une ValueError
try:
    z = complex("3 + 4j")  # ValueError!
except ValueError as e:
    print(f"Erreur: {e}")

# CORRECT: pas d'espaces
z = complex("3+4j")  # OK

Piege 2 : Division par zero complexe

import cmath

# La division par zero complexe leve une exception
try:
    result = (1 + 2j) / (0 + 0j)  # ZeroDivisionError
except ZeroDivisionError:
    print("Division par zero!")

# Meme avec des parties non nulles separement
try:
    result = (1 + 2j) / complex(0, 0)
except ZeroDivisionError:
    print("Toujours une erreur!")

Piege 3 : Confusion entre math et cmath

import math
import cmath

z = 1 + 2j

# math.sqrt() n'accepte pas les complexes
try:
    result = math.sqrt(z)  # TypeError!
except TypeError as e:
    print(f"math.sqrt sur complexe: {e}")

# Utilisez cmath pour les complexes
result = cmath.sqrt(z)  # OK

Piege 4 : La branche principale du logarithme

import cmath
import math

# log() retourne la branche principale
z = -1
log_result = cmath.log(z)
print(f"log(-1) = {log_result}")  # (0+3.14159j) = i*pi

# Attention aux valeurs multiples (branches)
# log(z) = ln|z| + i*arg(z) + 2*k*pi*i pour tout k entier

Conclusion

Le module cmath est un outil puissant et indispensable pour tout developpeur Python travaillant dans des domaines scientifiques ou techniques. Ses applications sont vastes :

• Ingenierie electrique : calculs d’impedance, analyse de circuits AC
• Traitement du signal : FFT, filtres, modulation
• Physique : mecanique quantique, ondes electromagnetiques
• Graphisme : rotations, transformations, fractales
• Mathematiques : resolution d’equations, analyse complexe

En suivant les bonnes pratiques presentees et en evitant les pieges courants, vous serez en mesure d’exploiter pleinement la puissance des nombres complexes en Python.

Pour Aller Plus Loin

• Documentation officielle : docs.python.org/3/library/cmath.html
• NumPy pour les calculs vectorises : numpy.complex128 pour les tableaux de complexes
• SciPy : fonctions avancees (FFT optimisee, filtres, etc.)
• SymPy : calcul symbolique avec nombres complexes