Exercice langage C: Complexes

Dans cet exercice, vous allez écrire quelques fonctions permettant la manipulation de nombres complexes. Déclarez le type Complexe, qui sera une structure représentant un nombre complexe. Cette structure aura donc deux champs de type float, que nous appelerons re et im, et qui contiendront respectivement les parties réelles et imaginaire du nombre complexe.

 

  struct Complexe {
      float re, im;
    };

1. Ecrivez les fonctions init_comp et afficher_comp qui initialise et affiche respectivement une variable de type Complexe. Ces fonctions auront l'en-tête suivant:

   Complexe init_comp(float re, float im)
et

      void afficher_comp(Complexe c)

2. Ecrivez une fonction main permettant de tester les deux fonctions que vous venez d'écrire. 

3. Ajoutez la fonctions add_comp permettant de calculer la somme de deux complexes, qui aura comme en-tête

 Complexe add_comp(Complexe C1, Complexe C2)

 

4. Ajoutez les fonctions

      Complexe mult_comp(Complexe C1, Complexe C2)
      Complexe mult_scal_comp(float s, Complexe C)
      Complexe sqrt_comp(float r)

qui renvoient respectivement

  • le produit de deux complexes;
  • le produit d'un réel et d'un complexe;
  • la racine carrée d'un réel pouvant être négatif.

5. Finalement, ajoutez la fonction module qui renvoie le module d'un complexe passé en paramètre.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include 
#include 

using namespace std;

struct Complexe{
  float re, im;
};

Complexe init_comp(float re, float im) {
  Complexe c;
  c.re = re;
  c.im = im;

  return c;
}

void afficher_comp(Complexe C) {
 cout << C.re << " + i " << C.im << endl;
}

Complexe add_comp(Complexe C1, Complexe C2) {
  return init_comp(C1.re + C2.re, C1.im + C2.im);
}

Complexe mult_comp(Complexe C1, Complexe C2) {
  return init_comp(C1.re * C2.re - C1.im * C2.im, C1.re * C2.im + C1.im * C2.re);
}

Complexe mult_scal_comp(float s, Complexe C) {
  return init_comp(s * C.re, s * C.im);
}

Complexe sqrt_comp(float r) {
  if (r >=0)
    return init_comp(sqrt(r), 0);
  else
    return init_comp(0, -sqrt(-r));
}

float module(Complexe C) {
  return sqrt(C.re * C.re + C.im * C.im);
}

int main(int argc, char **argv) {
  Complexe z1, z2;

  z1 = init_comp(1, 2);
  z2 = init_comp(2, 5);

  afficher_comp(add_comp(z1, z2));
  afficher_comp(mult_comp(z1, z2));
  afficher_comp(mult_scal_comp(3, z2));
  afficher_comp(sqrt_comp(-9));

 cout << module(z1) << endl;

  return 0;
}