C pointeurs/Matrices complexes

Début de la boite de navigation du chapitre
Matrices complexes
Icône de la faculté
Chapitre no 9
Leçon : C pointeurs
Chap. préc. :Tableau de double pointeur
Chap. suiv. :Matrices complexes 2
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « C pointeurs : Matrices complexes
C pointeurs/Matrices complexes
 », n'a pu être restituée correctement ci-dessus.


IntroductionModifier

PrésentationModifier

Double pointeur de double.

  • Pour nous ce sera un travail sur les matrices.

Ce cours en deux parties va vous présenter la création et la destruction de matrices complexes de la librairie "Mathc".

Le butModifier

Cela vous permettra :


  • Soit de construire votre propre méthode de création de matrices.
  • Soit de construire votre propre librairie à partir de ces deux méthodes.
  • Soit de commencer votre apprentissage de la méthode "mathc".


Exemple d'utilisation de la librairieModifier

Copie d'un tableau dans une matriceModifier

  • Pour récupérer la librairied'algèbre linéaire (n_1aa.zip).
  • Indispensable pour tester les exemples de cette page.
  • Le deuxième fichier n_1ab.zip sera pour l'étude des tableaux de matrices.
/* ------------------------------------ */
/* Save as : c01.c */
/* ------------------------------------ */
#include "w_a.h"
/* ------------------------------------ */
int main(void)
{
double a[R2*(C3*C2)] ={ 1, 2, 3, 4, 5, 6,
                       10,20, 30,40, 50,60};

double **A = i_mZ(R2,C3);

  c_a_A_mZ(a,A);

  printf(" a[r*c] -> A : \n\n");
  p_mZ(A,4,0,3,0,C6);

  f_mZ(A);
  getchar();

  return 0;
}


Présentation des fonctions :

double **A = i_mZ(R2,C3); Initialiser une matrice complexe
  • Deux lignes (rows)
  • Trois colonnes (columns)
c_a_A_mZ(a,A); Copier le tableau "a" dans la matrice "A"
p_mZ(A, N_N, VR, R_I, VI, C); Imprimer la matrice "A"
  • N_N espaces entre les nombres.
  • VR chiffres après la virgule. (Réelles)
  • R_I espaces entre les parties réelles et imaginaire.
  • VI chiffres après la virgule. (Imaginaires)
  • C colonnes par lignes.
f_mR(A); Libérer l'espace alloué à la matrice "A"


Additionner deux matricesModifier

/* ------------------------------------ */
/* Save as : c02.c */
/* ------------------------------------ */
#include "w_a.h"
/* ------------------------------------ */
int main(void)
{
time_t t;

  srand(time(&t));

int r = rp_I(5);
int c = rp_I(5);

double **A = r_mZ(i_mZ(r,c),9);
double **B = r_mZ(i_mZ(r,c),9);
double **AplsB = i_mZ(r,c);

  printf(" A :");
  p_mZ(A,3,0,3,0,C6);

  printf(" B :");
  p_mZ(B,3,0,3,0,C6);

  add_mZ(A,B,AplsB);

  printf(" AplsB :");
  p_mZ(AplsB,3,0,3,0,C6);

  f_mZ(A);
  f_mZ(B);
  f_mZ(AplsB);

  getchar();

  return 0;
}


Résultat :

A :
-5 +4i  -7 -7i  -5 +2i 
+8 -7i  -9 +8i  -7 -1i 
-1 -7i  -3 +8i  +4 +2i 
-5 -9i  +8 -3i  -1 -9i 
. 
B :
-3 +6i  +6 -5i  -9 +4i 
-9 -3i  -5 +6i  -9 +8i 
-5 -5i  -5 -3i  -3 -1i 
-3 -1i  -5 +4i  -9 +8i 
. 
AplsB :
-8+10i  -1-12i -14 +6i 
-1-10i -14+14i -16 +7i 
-6-12i  -8 +5i  +1 +1i 
-8-10i  +3 +1i -10 -1i


Multiplier deux matricesModifier

/* ------------------------------------ */
/* Save as : c03.c */
/* ------------------------------------ */

#include "w_a.h"
/* ------------------------------------ */
int main(void)
{
time_t t;

  srand(time(&t));

int a = rp_I(5);
int b = rp_I(5);
int c = rp_I(5);

double **A = r_mZ(i_mZ(a,c),9);
double **B = r_mZ(i_mZ(c,b),9);
double **AB = i_mZ(a,b);

  printf(" A : ");
  p_mZ(A,3,0,3,0,C6);

  printf(" B : ");
  p_mZ(B,3,0,3,0,C6);

  printf(" AB : ");
  p_mZ(mul_mZ(A,B,AB),5,0,5,0,C6);

  f_mZ(A);
  f_mZ(B);
  f_mZ(AB);

  getchar();

  return 0;
}


Résultat :

A : 
+2 -3i  -3 -1i  +4 +2i  +4 +2i  +2 +8i 
+6 +2i  +6 -1i  -7 -1i  +4 -9i  -3 -1i 
+8 +6i  -9 +6i  -3 +8i  -1 +6i  +8 -7i 
+4 -7i  -7 +4i  +8 +2i  -5 -9i  -3 +4i 
-5 +6i  +6 +8i  +6 -1i  +8 -7i  -9 -9i 
. 
B : 
+8 +6i  -3 -7i 
+2 -5i  -3 +2i 
+2 +8i  +6 -3i 
+6 -3i  -7 +2i 
+4 -9i  +8 +4i 
. 
AB : 
+125  +51i   -34  +58i 
 +13  -81i   -95  +33i 
 -49  +84i  +126 -121i 
 +47  +83i   +19  +28i 
 -94  +29i   -22  -62i 

Inverser une matriceModifier

/* ------------------------------------ */
/* Save as : c03.c */
/* ------------------------------------ 
Use fixed size matrices to improve the out.

int r = 4;

Instead of :

int r = rp_I(5)+1; +1 -> M_2x2 // M_6x6

*/
#include "w_a.h"
/* ------------------------------------ */
int main(void)
{
time_t t;

  srand(time(&t));

int r = 4;

double **A = r_mZ(i_mZ(r,r),99);
double **invA = r_mZ(i_mZ(r,r),99);
double **AinvA = i_mZ(r,r);

  printf(" A : ");
  p_mZ(A,5,0,4,0,C6);

  printf(" invA : p_E_mZ() : Print with power of 10.");
  p_E_mZ(inv_mZ(A,invA),11,1,10,1,C3);

  printf(" A *& invA : ");
  p_mZ(mul_mZ(A,invA,AinvA),8,3,7,3,C6);

  f_mZ(A);
  f_mZ(invA);
  f_mZ(AinvA);

  getchar();

  return 0;
}


Résultat :

 A : 
 -25 -69i    -9 -43i   -39 -35i   -23 -39i 
 -67 -87i   -69 -63i   +32 -25i   +34 +78i 
 +62 -43i   +66 -19i   -63 -97i   -97 +76i 
 -79 +74i   -95 -71i   +74 +28i   +10 -99i 
.
invA : p_E_mZ() : Print with power of 10.
  +7.1e-04  +7.8e-03i    -2.7e-03  +3.4e-03i    -2.0e-03  -6.0e-03i 
  -3.9e-03  -1.6e-03i    -1.5e-03  -1.1e-03i    +4.0e-03  +5.4e-03i 
  -4.6e-03  +3.8e-05i    +5.1e-03  +2.0e-03i    -1.5e-03  +6.0e-03i 
  -1.9e-03  +7.5e-03i    +1.2e-05  -3.5e-03i    -9.8e-04  -3.2e-03i 
.
  +6.4e-04  -5.9e-03i 
  -1.1e-03  +7.5e-03i 
  -3.1e-04  +1.9e-03i 
  +2.4e-04  +4.8e-04i 
.
A *& invA : 
 +1.000 +0.000i   -0.000 +0.000i   +0.000 -0.000i   +0.000 +0.000i 
 -0.000 -0.000i   +1.000 +0.000i   +0.000 +0.000i   +0.000 +0.000i 
 -0.000 -0.000i   +0.000 +0.000i   +1.000 +0.000i   -0.000 +0.000i 
 -0.000 +0.000i   -0.000 -0.000i   +0.000 +0.000i   +1.000 +0.000i 


Remarque :

  • r_ pour rand.
  • rp_I (r) pour rand, (p) pour positif, (I) pour integer (1,2,3)
  • p_ pour print.
  • i_ pour initialize.
  • f_ pour free.


La fonction f_mZ();Modifier

  • Nous allons commencer par cette fonction.
  • Elle libère l'espace alloué à la matrice par la fonction i_mR();


Code sourceModifier

/* ------------------------------------ */
void f_mZ(
double **A
)
{
  if(A) free(A[0]);

  free(A);
}


  • Nous travaillons avec des double pointeurs (**A).
  • Il y a deux pointeurs dans la fonction. (A,A[0])
  • C'est un bon début.
  • On commence par vérifier que "A" n’est pas NULL.
  • Si tout va bien on libère "A[0]" le deuxième pointeur.
  • Puis on libère A.
  • Si "A" n'existe pas, on saute "A[0]", mais on libère "A".
  • Peut-être aurait-il mieux valu écrire


/* ------------------------------------ */ 
void f_mZ(
double **A
)
{
  if(A){ 
    free(A[0]);
    free(A);
       }
}


  • Ces vidéos terminent notre premier pas sur les double pointeurs.