Nombres complexes A: avec la bibliothèque logicielle std complex

Soyez le premier à donner votre avis sur cette source.

Vue 657 fois - Téléchargée 39 fois

Description

Bonjour,

Les nombres complexes peuvent s'écrie sous l'une des trois formes: algébrique, polaire (ou trigonométrique), exponentielle:

Forme
  algébrique: z = [a+i·b], avec i² = -1
  polaire: z = ρ·[cosθ+i·sinθ], avec ρ = √(a² + b²), cosθ = a/ρ, sinθ = b/ρ
  exponentielle: z = ρ·eⁱᶱ

Les sites qui décrivent les nombres complexes ne manquent pas sur le Net et également dans CodeS-SourceS (voir quelques liens ci-dessous).

Avec Microsoft Visual Studio 14.0 (qui utilise le fichier complex du 01/06/2016), le code du Zip ComplexLib.cpp:
#include <iostream>
#include <complex>
#define Reel double

void Out(char *s,  std::complex<double> z) {
  char *ss = "+i";
  double im = imag(z);
  if (im < 0.0) {ss = "-i"; im = -im;}
  std::cout << s << '[' << real(z) << ss << char(250) << im <<  "]";
} // char(250) = '·' sur la console

#define NL std::cout << ";n"
int main() {
  const Reel pi=(Reel)3.14159265358979323846;
  const std::complex<double> x(-5,4), y(3,2.1), z(7,-4.88);
  std::complex<double> v;

  std::cout << "Nombres complexes B: avec struct std::complex<double>n";
  Out("nA: x = ", x); Out(", y = ", y); Out(", z = ", z);
  v=17; Out("nB: v=17 = ", v); v=z; Out(", v = z = ", v);
  std::cout << "nC: x==y ? " << ((x==y) ? "true" : "false");
  std::cout << ", x!=y ? " << ((x!=y) ? "true" : "false");
  Out("nD: +z = ", +z);
  Out(", -z = ", -z);
  Out("nE: x+y = ", x+y);
    v=z; Out("; v=z, v+=x = ", v+=x);
    v=z; Out("; v=z, v+=6 = ", v+=6);
  // Out("nE': 3+x = ", 3+x); Out(", x+4 = ", x+4);
  Out("nF: x-y = ", x-y);
    v=z; Out("; v=z, v-=x = ", v-=x);
    v=z; Out("; v=z, v-=6 = ", v-=6);
  // Out("nF': 3-x = ", 3-x); Out(", x-1 = ", x-1);
  Out("nG: x*y = ", x*y);
    v=z; Out("; v=z, v*=x = ", v*=x);
    v=z; Out("; v=z, v*=6 = ", v*=6);
  // Out("nG': 3*x = ", 3*x); Out(", x*4 = ", x*4);
  Out("nH: x/y = ", x/y);
    v=z; Out("; v=z, v/=x = ", v/=x);
    v=z; Out("; v=z, v/=6 = ", v/=6);
  // Out("nH': 3/x = ", 3/x); Out(", x/2.5 = ", x/2.5);
  // Out("nI': 3+1/x+z/y-5*x*y = ", 3+1/x+z/y-5*x*y);
  std::cout << "nJ: norm(z) = " << norm(z) << ", abs(z) = " << abs(z);
  std::cout << ", arg(z) = " << arg(z);
  Out("nK: conj(z) = ", conj(z));
  Out("nL: cos(z) = ", cos(z)); Out(", cosh(z) = ", cosh(z));
  Out("nM: exp(z) = ", exp(z));
  Out("nN: log(z) = ", log(z)); Out(", log10(z) = ", log10(z));
  // Out("nO': polar(5, pi/6) = ", polar(5, pi/6));
  Out("nP: pow(z, 3) = ", pow(z, 3)); Out(", pow(z, 1.5) = ", pow(z, 1.5));
    Out(", pow(z, x) = ", pow(z, x));
  Out("nQ: sin(z) = ", sin(z)); Out(", sinh(z) = ", sinh(z));
  v=sqrt(z); Out("nR: v = sqrt(z) = ", v); Out(", v*v = ", v*v);
  Out("nS: tan(z) = ", tan(z)); Out(", tanh(z) = ", tanh(z));

  std::cout << "nnEquation du second degre a coefficients complexes:";
  std::cout << "  a*x*x + b*x + c = 0.nAvec ";
  std::complex<double> a(-5,4), b(6,3), c(1,-7);
  std::complex<double> D, srD, x1, x2; // D = Discr, srD = √D, x1,x2 = solutions
  std::complex<double> k2 = 2, k4 = 4;
  Out("a = ", a); Out(", b = ", b); Out(", c = ", c);
  Out(", k2 = ", k2); Out(", k4 = ", k4);
  D = b*b - k4*a*c; srD = sqrt(D);
  Out("n  posons D = b*b - k4*a*c = ", D); Out(", srD = sqrt(D) = ", srD); 
  x1 = (-b + srD)/(k2*a); x2 = (-b - srD)/(k2*a);
  Out("n  x1 = (-b + srD)/(k2*a) = ",x1);
  Out("n  x2 = (-b - srD)/(k2*a) = ",x2);
  Out("nControl 1: a*x1*x1 + b*x1 + c = ", a*x1*x1 + b*x1 + c);
  Out("nControl 2: a*x2*x2 + b*x2 + c = ", a*x2*x2 + b*x2 + c);

  getchar();
}
donne les résultats suivants:
Nombres complexes B: avec struct std::complex<double>

A: x = [-5+i·4], y = [3+i·2.1], z = [7-i·4.88]
B: v=17 = [17+i·0], v = z = [7-i·4.88]
C: x==y ? false, x!=y ? true
D: +z = [7-i·4.88], -z = [-7+i·4.88]
E: x+y = [-2+i·6.1]; v=z, v+=x = [2-i·0.88]; v=z, v+=6 = [13-i·4.88]
F: x-y = [-8+i·1.9]; v=z, v-=x = [12-i·8.88]; v=z, v-=6 = [1-i·4.88]
G: x*y = [-23.4+i·1.5]; v=z, v*=x = [-15.48+i·52.4]; v=z, v*=6 = [42-i·29.28]
H: x/y = [-0.49217+i·1.67785]; v=z, v/=x = [-1.32976-i·0.0878049]; v=z, v/=6 = [1.16667-i·0.813333]
J: norm(z) = 72.8144, abs(z) = 8.53314, arg(z) = -0.608806
K: conj(z) = [7+i·4.88]
L: cos(z) = [49.6212+i·43.2373], cosh(z) = [91.4743+i·540.632]
M: exp(z) = [182.948+i·1081.27]
N: log(z) = [2.14396-i·0.608806], log10(z) = [0.931109-i·0.264401]
P: pow(z, 3) = [-157.102-i·601.146], pow(z, 1.5) = [15.2354-i·19.7286], pow(z, x) = [0.000147522-i·0.00020478]
Q: sin(z) = [43.2423-i·49.6155], sinh(z) = [91.4741+i·540.633]
R: v = sqrt(z) = [2.78686-i·0.875539], v*v = [7-i·4.88]
S: tan(z) = [0.000114343-i·0.999984], tanh(z) = [1+i·5.47112e-07]

Equation du second degre a coefficients complexes:  a*x*x + b*x + c = 0.
Avec a = [-5+i·4], b = [6+i·3], c = [1-i·7], k2 = [2+i·0], k4 = [4+i·0]
  posons D = b*b - k4*a*c = [-65-i·120], srD = sqrt(D) = [5.97802-i·10.0368]
  x1 = (-b + srD)/(k2*a) = [-0.6346+i·0.795997]
  x2 = (-b - srD)/(k2*a) = [1.07362+i·0.155222]
Control 1: a*x1*x1 + b*x1 + c = [0+i·1.77636e-15]
Control 2: a*x2*x2 + b*x2 + c = [-1.77636e-15+i·1.77636e-15]

Les instructions mises en commentaire correspondent à des fonctions ou opérations non gérées par la bibliothèque <complex> référencée ci-dessus.
Qu'en est-il des versions plus modernes ?

A titre d'exemple, j'ai ajouté un code pour la résolution d'une équation du second degré à coefficients complexes: a*x*x + b*x + c = 0.
On y constate notamment qu'on ne peut pas directement écrire l'instruction "habituelle" D = b*b - 4*a*c.

Le prochain article Nombres complexes B: ... présentera une bibliothèque sous forme de struct.
Son contenu sera testé avec les résultats ci-dessus.
 
Bonne lecture ...
 

Liens

WikipédiA: Nombre complexe
WikipédiA: Formule d'Euler
WikipediA: Euler's formula
Villemin: NOMBRES COMPLEXES
CodeS-SourceS: Nombres complexes ( c++, classe )
CodeS-SourceS: Resolution d'equations (jusqu'au 3eme degre)
CodeS-SourceS: Nombres complexes - complex numbers
EasyCalculation: Complex Number Calculator
 

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.