La transformation conforme

Salut tout le monde.

Jean_Debord que je remercie beaucoup, a réalisé une bonne bibliothèque pour les nombres complexes, or certains Panoramiciens disent que c’est très mathématique et très pointu.
C’est tout à fait juste : c’est le domaine des mathématiques supérieures et je me souviens très vaguement que j’en ai fais beaucoup quand j’étais plus jeune et moins bête que maintenant !
Il m’est impossible de dénombrer les domaines où les nombres complexes entrent en scène, mais Monsieur tout le monde peut mener son train de vie sans jamais sentir le besoin de recourir aux complexes !

Bon, sans faire de publicité pour les complexes, je vous propose simplement un code pour visualiser ces fonctions complexes en utilisant la bibliothèque de Jean_Debord.

Rappel mathématique que vous pouvez sauter

Quand on veut visualiser les fonctions réelles, on trace leur graphe en coordonnées cartésiennes : par exemple y = x² représente une parabole. Mais pour tracer les fonctions complexes (appelées aussi fonctions analytiques) on se heurte à un obstacle sérieux : le nombre z et son image f(z) ont chacun deux coordonnées ce qui signifie qu’il nous faut quatre dimensions pour représenter l’équivalent complexe du graphe d’une fonction.
Or nous ne sommes que des simples créatures tridimensionnelles ! Contentons-nous de ces trois dimensions pour visualiser nos fonctions complexes. Mais notre écran de visualisation est (jusqu’ à nouvel ordre) un vulgaire plan à deux dimensions.
Comme les mathématiciens n’abandonnent pas de si tôt, ils ont inventé la transformation conforme . Cette transformation possède des nombreuses propriétés. L’une d’entre elle est la conservation des angles .
Par exemple, si on part d’un quadrillage orthogonal, les lignes courbes obtenues par la transformation conforme se couperont à angle droit.

Après ce long discours qui vaut ce qu’il vaut, voici le code qui comporte le graphe d’une vingtaine de fonctions complexes à tester une à une.

Spoiler:

Code:: rem ============================================================================
rem Transformation conforme
rem Par Papydall
rem Utilisant la bibliothèque de calculs sur les nombres complexes de Jean_Debord
rem ============================================================================

Init()
Variables_Globales()
Transformation()

end
rem ============================================================================
SUB Init()
   dim xi,xm,yi,ym,xmin,xmax,ymin,ymax,dx,dy,lx,ly
   full_space 0 : color 0,0,0,0 : 2d_pen_color 0,255,255
   dx = 51 : dy = 31 : lx = screen_x : ly = screen_y
   xi = -1.55 : xm = 1.55 : yi = -1.55 : ym = 1.55
   xmin = -5 : xmax = 5 : ymin = -3 : ymax = 3
   dim reseauX(dx),reseauY(dy)
END_SUB
rem ============================================================================
SUB Plot(re1,im1,re2,im2)
   dim_local x1,y1,x2,y2
   x1 = int(lx*(re1-xmin)/(xmax-xmin))
   y1 = int(ly*(im1-ymin)/(ymax-ymin))
   x2 = int(lx*(re2-xmin)/(xmax-xmin))
   y2 = int(ly*(im2-ymin)/(ymax-ymin))
   2d_line x1,y1,x2,y2
END_SUB
rem ============================================================================
SUB Transformation()
   dim_local i,j,re,im ,r1,i1
   for i = 0 to dx
   for j = 0 to dy
   re = xi + i *(xm-xi)/dx
   im = yi + j *(ym-yi)/dy
' Essayez une à une ces différentes fonctions
   CInv(re,im) : ' f(z) = 1/z
   ' CTan(re,im) : ' f(z) = tan(z)
   ' CCos(re,im) : ' f(z) = cos(z)
   ' CSin(re,im) : ' f(z) = sin(z)
   ' CSquare(re,im): ' f(z) = z*z
   ' CCube(re,im) : ' f(z) = z*z*z
   ' CSqrt(re,im) : ' f(z) = sqr(z)
   ' CLog(re,im) : ' f(z) = Log(z)
   ' CExp(re,im) : ' f(z) = Exp(z)
   ' CRealPower(re,im,5.3) : ' f(z) = z^p avec p réel = 5.3 dans ce cas
   ' CPower(re,im,3/2,-1) : ' f'z) = z^c avec c complexe = 1.5 - i dans ce cas
   ' CSinh(re,im) : ' f(z) = hsin(z)
   ' CCosh(re,im) : ' f(z) = hcos(z)
   ' CTanh(re,im) : ' f(z) = htan(z)
   ' CASin(re,im) : ' f(z) = ArcSin(z)
   ' CACos(re,im) : ' f(z) = ArcCos(z)
   ' CATan(re,im) : ' f(z) = ArcTan(z)
   ' CASinh(re,im) : ' f(z) = ArcHSin(z)
   ' CACosh(re,im) : ' f(z) = ArcHcos(z)
   ' CATanh(re,im) : ' f(z) = ARCHTan(z)

   if j > 0 then plot(reseauX(j-1),reseauY(j-1),r_x,r_y)
   if i > 0 then plot(reseauX(j),reseauY(j),r_x,r_y)
   reseauX(j) = r_x : reseauY(j) = r_y
   next j
   next i
END_SUB

rem ============================================================================
rem Bibliothèque de calculs sur les nombres complexes
rem Par Jean Debord
rem ============================================================================

rem ============================================================================
SUB Variables_Globales()
' Constantes mathematiques
   dim MaxNum, MinNum, MaxLog, MinLog, Pi, PiDiv2
   MaxLog = 709.78 : ' Argument max. pour EXP
   MinLog = -708.39 : ' Argument min. pour EXP
   MaxNum = exp(MaxLog) : ' Nb reel max. ~ 2^1024
   MinNum = exp(MinLog) : ' Nb reel min. ~ 2^(-1022)
   Pi = 4 * atn(1)
   PiDiv2 = Pi / 2

' Resultats des calculs
' Partie reelle, partie imaginaire, module, argument, signe
   dim r_x, r_y, r_mod, r_arg, r_sgn
' Code d'erreur
' 0 = pas d'erreur
' -1 = argument hors bornes
' -2 = singularite
' -3 = overflow
' -4 = underflow
   dim ErrCode%
END_SUB
rem ============================================================================
sub CMul(a_x, a_y, b_x, b_y)
' Multiplication : r_x + i r_y = (a_x + i a_y) * (b_x + i b_y)
   ErrCode% = 0
   r_x = a_x * b_x - a_y * b_y
   r_y = a_x * b_y + a_y * b_x
end_sub
rem ============================================================================
sub CSquare(a_x, a_y)
' Carre : r_x + i r_y = (a_x + i a_y)^2
   ErrCode% = 0
   r_x = a_x * a_x - a_y * a_y
   r_y = 2 * a_x * a_y
end_sub
rem ============================================================================
sub CCube(a_x, a_y)
' Cube : r_x + i r_y = (a_x + i a_y)^3
   dim_local x2, y2, x3, y3
   ErrCode% = 0
   x2 = a_x * a_x : x3 = x2 * a_x
   y2 = a_y * a_y : y3 = y2 * a_y
   r_x = x3 - 3 * a_x * y2
   r_y = 3 * x2 * a_y - y3
end_sub
rem ============================================================================
sub CIntPower(a_x, a_y, n%)
' Puissance entiere : r_x + i r_y = (a_x + i a_y)^n
   dim_local m%, b_x, b_y, res_x, res_y
   ErrCode% = 0
   if a_x = 0 and a_y = 0
   if n% = 0
' 0^0 = lim x^x quand x --> 0 = 1
   r_x = 1
   r_y = 0
   else
   if n% > 0
' 0^n = 0 si n > 0
   r_x = 0
   r_y = 0
   else
' 0^n indefini si n < 0
   ErrCode% = -2
   r_x = MaxNum
   r_y = MaxNum
   end_if
   end_if
   else
   if n% < 0
   m% = abs(n%)
   CInv(a_x, a_y)
   b_x = r_x
   b_y = r_y
   else
   m% = n%
   b_x = a_x
   b_y = a_y
   end_if
   res_x = 1 : res_y = 0
   while m% > 0
   if odd(m%) = 1
   CMul(b_x, b_y, res_x, res_y)
   res_x = r_x
   res_y = r_y
   end_if
   CSquare(b_x, b_y)
   b_x = r_x
   b_y = r_y
   m% = int(m% / 2)
   end_while
   r_x = res_x
   r_y = res_y
   end_if
end_sub
rem ============================================================================
sub CDiv(a_x, a_y, b_x, b_y)
' Division : r_x + i r_y = (a_x + i a_y) / (b_x + i b_y)
' Algorithme d'apres "Numerical Recipes"
   dim_local q, t
   if b_x = 0 and b_y = 0
   ErrCode% = -3
   r_x = MaxNum
   r_y = MaxNum
   else
   ErrCode% = 0
   if abs(b_x) >= abs(b_y)
   q = b_y / b_x
   t = b_x + b_y * q
   r_x = (a_x + a_y * q) / t
   r_y = (a_y - a_x * q) / t
   else
   q = b_x / b_y
   t = b_x * q + b_y
   r_x = (a_x * q + a_y) / t
   r_y = (a_y * q - a_x) / t
   end_if
   end_if
end_sub
rem ============================================================================
sub CInv(a_x, a_y)
' Inverse : r_x + i r_y = 1 / (a_x + i a_y)
   dim_local Temp
   if a_x = 0 and a_y = 0
   ErrCode% = -3
   r_x = MaxNum
   r_y = MaxNum
   else
   ErrCode% = 0
   Temp = a_x * a_x + a_y * a_y
   r_x = a_x / Temp
   r_y = 0 - a_y / Temp
   end_if
end_sub
rem ============================================================================
sub CSgn(a_x, a_y)
' Signe complexe
   ErrCode% = 0
   if a_x > 0
   r_sgn = 1
   else
   if a_y < 0
   r_sgn = -1
   else
   if a_y > 0
   r_sgn = 1
   else
   if a_y < 0
   r_sgn= -1
   else
   r_sgn = 0
   end_if
   end_if
   end_if
   end_if
end_sub
rem ============================================================================
sub CAbs(a_x, a_y)
' Module : r_mod = |a_x + i a_y|
' Algorithme d'apres "Numerical Recipes"
   ErrCode% = 0
   dim_local AbsX, AbsY, R, C
   AbsX = abs(a_x)
   AbsY = abs(a_y)
   if a_x = 0
   r_mod = abs(a_y)
   else
   if a_y = 0
   r_mod = abs(a_x)
   else
   if AbsX > AbsY
   R = AbsY / AbsX
   C = AbsX
   else
   R = AbsX / AbsY
   C = AbsY
   end_if
   r_mod = C * sqr(1 + R * R)
   end_if
   end_if
end_sub
rem ============================================================================
sub CArg(a_x, a_y)
' Argument : r_arg = arg(a_x + i a_y)
' Resultat dans [-Pi, Pi)
' Equivaut a atan2(a_y, a_x)
   ErrCode% = 0
   if a_x = 0
   r_arg = sgn(a_y) * PiDiv2
   else
' 4e / 1er quadrant : -Pi/2..Pi/2
   r_arg = atn(a_y / a_x)
   if a_x < 0
   if a_y > 0
' 2e quadrant : Pi/2..Pi
   r_arg = r_arg + Pi
   else
' 3e quadrant : -Pi..-Pi/2
   r_arg = r_arg - Pi
   end_if
   end_if
   end_if
end_sub
rem ============================================================================
sub ATan2(y, x)
' atn(y/x) --> Resultat dans [-Pi, Pi)
   CArg(x, y)
end_sub
rem ============================================================================
sub CSqrt(a_x, a_y)
' Racine carree : r_x + i r_y = sqrt(a_x + i a_y)
' Algorithme d'apres "Numerical Recipes"
   dim_local X, Y, W, R
   X = abs(a_x)
   Y = abs(a_y)
   ErrCode% = 0
   if a_x = 0 and a_y = 0
   r_x = 0
   r_y = 0
   else
   if X >= Y
   R = Y / X
   W = sqr(X) * sqr(0.5 * (1 + sqr(1 + R * R)))
   else
   R = X / Y
   W = sqr(Y) * sqr(0.5 * (R + sqr(1 + R * R)))
   end_if
   if a_x >= 0.0
   r_x = W
   r_y = a_y / (2 * r_x)
   else
   if a_y >= 0
   r_y = W
   else
   r_y = 0 - W
   end_if
   r_x = a_y / (2 * r_y)
   end_if
   end_if
end_sub
rem ============================================================================
sub CLog(a_x, a_y)
' Partie principale du logarithme complexe
' r_x + i r_y = ln(a_x + i a_y)
   if a_x = 0 and a_y = 0
   ErrCode% = -2
   r_x = 0 - MaxNum
   r_y = 0
   else
   ErrCode% = 0
   CAbs(a_x, a_y)
   CArg(a_x, a_y)
   r_x = log(r_mod)
   r_y = r_arg
   end_if
end_sub
rem ============================================================================
sub CExp(a_x, a_y)
' Exponentielle complexe : r_x + i r_y = exp(a_x + i a_y)
   dim_local ExpX
   if a_x < MinLog
   ErrCode% = -4
   r_x = 0
   r_y = 0
   else
   if a_x > MaxLog
   ErrCode = -3
   ExpX = MaxNum
   else
   ErrCode% = 0
   ExpX = exp(a_x)
   end_if
   r_x = ExpX * cos(a_y)
   r_y = ExpX * sin(a_y)
   end_if
end_sub
rem ============================================================================
sub CRealPower(a_x, a_y, p)
' Puissance (exposant reel) : (a_x + i a_y)^p
' Resultat dans r_x, r_y
' Resultat aussi dans r_mod, r_arg si a <> 0
   ErrCode% = 0
   if a_x = 0 and a_y = 0
   if p = 0
' 0^0 = lim x^x quand x --> 0 = 1
   r_x = 1
   r_y = 0
   else
   if p > 0
' 0^p = 0 si p > 0
   r_x = 0
   r_y = 0
   else
' 0^p indefini si p < 0
   ErrCode% = -2
   r_x = MaxNum
   r_y = MaxNum
   end_if
   end_if
   else
   CAbs(a_x, a_y)
   CArg(a_x, a_y)
   r_mod = power(r_mod, p)
   r_arg = r_arg * p
   r_x = r_mod * cos(r_arg)
   r_y = r_mod * sin(r_arg)
   end_if
end_sub
rem ============================================================================
sub CPower(a_x, a_y, b_x, b_y)
' Puissance (exposant complexe) : (a_x + i a_y)^(b_x + i b_y)
' Resultat dans r_x, r_y
   ErrCode% = 0
   if a_x = 0 and a_y = 0
   if b_x = 0 and b_y = 0
' 0^0 = lim x^x quand x --> 0 = 1
   r_x = 1
   r_y = 0
   else
' 0^p = 0 si p > 0
   r_x = 0
   r_y = 0
   end_if
   else
' exp(b ln(a))
   CAbs(a_x, a_y)
   CArg(a_x, a_y)
   CMul(b_x, b_y, log(r_mod), r_arg)
   CExp(r_x, r_y)
   end_if
end_sub
rem ============================================================================
sub CSin(a_x, a_y)
' Sinus complexe : r_x + i r_y = sin(a_x + i a_y)
   ErrCode% = 0
   r_x = sin(a_x) * hcos(a_y)
   r_y = cos(a_x) * hsin(a_y)
end_sub
rem ============================================================================
sub CCos(a_x, a_y)
' Cosinus complexe : r_x + i r_y = cos(a_x + i a_y)
   ErrCode% = 0
   r_x = cos(a_x) * hcos(a_y)
   r_y = 0 - sin(a_x) * hsin(a_y)
end_sub
rem ============================================================================
sub CSinh(a_x, a_y)
' Sinus hyperbolique complexe : r_x + i r_y = sinh(a_x + i a_y)
   ErrCode% = 0
   r_x = hsin(a_x) * cos(a_y)
   r_y = hcos(a_x) * sin(a_y)
end_sub
rem ============================================================================
sub CCosh(a_x, a_y)
' Cosinus hyperbolique complexe : r_x + i r_y = cosh(a_x + i a_y)
   ErrCode% = 0
   r_x = hcos(a_x) * cos(a_y)
   r_y = hsin(a_x) * sin(a_y)
end_sub
rem ============================================================================
sub CTan(a_x, a_y)
' Tangente complexe : r_x + i r_y = tan(a_x + i a_y)
   dim_local X2, Y2, Temp
   X2 = 2 * a_x
   Y2 = 2 * a_y
   Temp = cos(X2) + hcos(Y2)
   if Temp <> 0
   ErrCode% = 0
   r_x = sin(X2) / Temp
   r_y = hsin(Y2) / Temp
   else
' a = Pi/2 + k*Pi
   ErrCode% = -2
   r_x = MaxNum
   r_y = 0
   end_if
end_sub
rem ============================================================================
sub CTanh(a_x, a_y)
' Tangente hyperbolique complexe : r_x + i r_y = tanh(a_x + i a_y)
   dim_local X2, Y2, Temp
   X2 = 2.0 * a_x
   Y2 = 2.0 * a_y
   Temp = hcos(X2) + cos(Y2)
   if Temp = 0
' a = i * (Pi/2 + k*Pi)
   ErrCode% = -2
   r_x = 0
   r_y = MaxNum
   else
   ErrCode% = 0
   r_x = hsin(X2) / Temp
   r_y = sin(Y2) / Temp
   end_if
end_sub
rem ============================================================================
sub CASin(a_x, a_y)
' Arc Sinus complexe : r_x + i r_y = asin(a_x + i a_y)
   dim_local X2, XX, YY, Rp, Rm, S, T
   X2 = 2 * a_x
   XX = a_x * a_x
   YY = a_y * a_y
   S = XX + YY + 1
   Rp = 0.5 * sqr(S + X2)
   Rm = 0.5 * sqr(S - X2)
   T = Rp + Rm
   ErrCode% = 0
   CSgn(a_y, 0 - a_x)
   r_x = asin(Rp - Rm)
   r_y = r_sgn * log(T + sqr(T * T - 1))
end_sub
rem ============================================================================
sub CACos(a_x, a_y)
' Arc Cosinus complexe :
' r_x + i r_y = acos(a_x + i a_y) = Pi/2 - ASin(a)
   CASin(a_x, a_y)
   r_x = PiDiv2 - r_x
   r_y = 0 - r_y
end_sub
rem ============================================================================
sub CATan(a_x, a_y)
' Arc Tangente complexe : r_x + i r_y = atan(a_x + i a_y)
   dim_local XX, YY, Yp1, Ym1, A1, A2
   if a_x = 0 and abs(a_y) = 1
' a = +/- i
   ErrCode% = -2
   r_x = 0
   r_y = sgn(a_y) * MaxNum
   else
   ErrCode% = 0
   XX = a_x * a_x
   YY = a_y * a_y
   Yp1 = a_y + 1
   Ym1 = a_y - 1
   CArg(0 - Ym1, a_x) : A1 = r_arg : ' = atan2(a_x, - Ym1)
   CArg(Yp1, 0 - a_x) : A2 = r_arg : ' = atan2(- Ym1, a_x)
   r_x = 0.5 * (A1 - A2)
   r_y = 0.25 * log((XX + Yp1 * Yp1) / (XX + Ym1 * Ym1))
   end_if
end_sub
rem ============================================================================
sub CASinh(a_x, a_y)
' Argument Sinus hyperbolique complexe :
' r_x + i r_y = asinh(a_x + i a_y) = -i*asin(i*a)
' i * (a_x + i a_y) = -a_y + i a_x
   dim_local t
   CASin(0 - a_y, a_x)
   t = r_x
   r_x = r_y
   r_y = 0 - t
end_sub
rem ============================================================================
sub CACosh(a_x, a_y)
' Argument Cosinus hyperbolique complexe :
' r_x + i r_y = acosh(a_x + i a_y) = csgn(a_y + i(1 - a_x)) * i * acos(a)
   dim_local t
   CSgn(a_y, 1 - a_x)
   CACos(a_x, a_y)
   t = r_x
   r_x = 0 - r_sgn* r_y
   r_y = r_sgn * t
end_sub
rem ============================================================================
sub CATanh(a_x, a_y)
' Argument Tangente hyperbolique complexe :
' r_x + i r_y = atanh(a_x + i a_y) = -i*atan(i*a)
   dim_local t
   CATan(0 - a_y, a_x)
   t = r_x
   r_x = r_y
   r_y = 0 - t
end_sub
rem ============================================================================

J'espère que vous n'aurez plus de complexe pour les complexes! Laughing

Perso, je n'ai jamais douté que ce soit utile. C'est juste que j'ai du mal à suivre mathématiquement parlant mais je ne doute pas que ça a plein d'applications pratiques Wink

Merci Papydall. C'est effectivement une bonne manière de représenter ces fonctions.

Une autre manière consiste à représenter dans le plan (x,y), à l'aide d'un code de couleurs, une propriété de la fonction telle que le module ou l'argument. Cela peut se faire en 2D ou 3D.

Voir des exemples sur la page de Wikipedia pour la fonction exponentielle :

http://fr.wikipedia.org/wiki/Fonction_exponentielle

Je ne résiste pas à vous faire partager ceci (passez en mode plein écran, réglez le volume et admirez !)

Spoiler:

Très intéressante cette vidéo. Merci Papydall !

Donc si j'ai bien compris :

Module --> Luminosité
Argument --> Teinte (Hue)

On doit pouvoir faire cela en Panoramic !

J'ai commencé un article sur les nombres complexes et puis je suis tombé sur ce lien , alors j'ai abandonné car je ne pourrai pas faire mieux!

Passez en mode plein écran et réglez le volume de vos haut-parleurs.
Cliquez sur PLAYLIST et choisissez Dimensions 5 (c'est consacré aux complexes).
Les autres Dimensions (de 1 à 9) sont aussi très intéressants à visionner.

Ce film est extrait de ce site

Bon divertissement!

» largeur d'image chargée non conforme ?