Leçons de niveau 14

C pointeurs/Matrices complexes fractions

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Matrices complexes fractions
Icône de la faculté
Chapitre no 16
Leçon : C pointeurs
Chap. préc. :Matrices fractions 3
Chap. suiv. :Matrices complexes fractions 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 fractions
C pointeurs/Matrices complexes fractions
 », n'a pu être restituée correctement ci-dessus.


Introduction[modifier | modifier le wikicode]

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.
  • Les valeurs sont des complexes dont les parties sont des fractions.


Le but[modifier | modifier le wikicode]

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 librairie[modifier | modifier le wikicode]

Copie d'un tableau dans une matrice[modifier | modifier le wikicode]

  • Pour récupérer la librairied'algèbre linéaire (f04a.zip).
  • Indispensable pour tester les exemples de cette page.
/* ------------------------------------ */
/* Save as : c01.c */
/* ------------------------------------ */
#include "w_a.h"
/* ------------------------------------ */
int main(void)
{
double a[R2*(C3*C4)]={ 1,1,1,1, 2,2,2,2, 3,3,3,3,
                       4,4,4,4,  5,5,5,5,  6,6,6,6};
                     
double **A = i_mF(R2,C3);

   c_a_A_mF(a,A);
   
   printf(" A: \n");
   p_mF(A,5,0,4);

   f_mF(A);

   getchar();

 return 0;
}

Le résultat:

A: 
.
  +1/1 +1/1*I    +2/2 +2/2*I    +3/3 +3/3*I 
  +4/4 +4/4*I    +5/5 +5/5*I    +6/6 +6/6*I 
  • Présentation des fonctions :
double **A = i_mF(R2,C3); Initialiser une matrice avec des fractions
  • Deux lignes (Rows)
  • Trois colonnes (Columns)
c_a_A_mF(a,A); Copier le tableau "a" dans la matrice "A"
p_mF(A,N,F,C); Imprimer la matrice "A"
  • N espaces entre les nombres.
  • F espaces entre les numérateurs et les dénominateurs.
  • C colonnes par lignes.
f_mF(A); Libérer l'espace alloué à la matrice "A"


Additionner deux matrices[modifier | modifier le wikicode]

/* ------------------------------------ */
/* 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_mF(i_mF(r,c),5,5);
double **B = r_mF(i_mF(r,c),5,5);
double **AplsB = i_mF(r,c);

   printf(" A:");
   p_mF(A,5,0,C4);
   printf(" B:");
   p_mF(B,5,0,C4);

   printf(" AplsB:");
   p_mF(add_mF(A,B,AplsB),7,3, C3);

   getchar();

   f_mF(A);
   f_mF(B);
   f_mF(AplsB);

 return 0;
}


Résultat :


A:
  +4/3 +3/5*I    +3/4 +4/4*I    +5/3 +1/3*I 
  +4/2 +4/2*I    +2/1 +2/1*I    +2/2 +3/3*I 
  +5/5 +5/5*I    +5/1 +2/4*I    +3/5 +5/5*I 
  +3/3 +3/4*I    +1/1 +3/1*I    +2/3 +3/5*I 
  +4/1 +1/2*I    +2/5 +2/2*I    +4/3 +1/5*I 
.
B:
  +3/4 +3/5*I    +3/2 +5/3*I    +5/4 +1/2*I 
  +1/4 +2/2*I    +1/4 +4/1*I    +5/4 +3/3*I 
  +5/4 +1/5*I    +3/3 +4/5*I    +2/2 +1/4*I 
  +5/2 +3/4*I    +1/4 +2/1*I    +2/4 +5/4*I 
  +4/3 +5/5*I    +3/2 +3/4*I    +2/3 +3/4*I 
.
AplsB:
   +25/ 12 +6/  5*I      +9/  4 +8/  3*I     +35/ 12 +5/  6*I 
    +9/  4 +3/  1*I      +9/  4 +6/  1*I      +9/  4 +2/  1*I 
    +9/  4 +6/  5*I      +6/  1 +13/ 10*I      +8/  5 +5/  4*I 
    +7/  2 +3/  2*I      +5/  4 +5/  1*I      +7/  6 +37/ 20*I 
   +16/  3 +3/  2*I     +19/ 10 +7/  4*I      +2/  1 +19/ 20*I 


Multiplier deux matrices[modifier | modifier le wikicode]

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

   srand(time(&t));

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

double **A = r_mF(i_mF(a,b),5,5);
double **B = r_mF(i_mF(b,c),5,5);
double **AB = i_mF(a,c);

   printf(" A:");
   p_mF(A,5,0,C4);
   printf(" B:");
   p_mF(B,5,0,C4);

   printf(" AB:");
   p_mF(mul_mF(A,B,AB),7,3, C3);

   getchar();

   f_mF(A);
   f_mF(B);
   f_mF(AB);

 return 0;
}


Résultat :


A:
  +1/4 +2/1*I    +2/4 +3/4*I 
  +1/5 +1/4*I    +3/3 +5/4*I 
  +2/2 +2/4*I    +2/5 +5/5*I 
  +1/4 +3/4*I    +3/4 +4/3*I 
.
B:
  +3/2 +3/4*I    +5/2 +2/3*I    +4/4 +1/3*I    +1/3 +4/4*I 
  +1/5 +2/2*I    +2/3 +1/4*I    +1/1 +4/1*I    +4/3 +3/3*I 
.
AB:
   -71/ 40 +307/ 80*I      -9/ 16 +139/ 24*I     -35/ 12 +29/  6*I 
   -15/ 16 +71/ 40*I     +11/ 16 +221/120*I    -233/ 60 +167/ 30*I 
   +41/200 +21/ 10*I    +131/ 60 +161/ 60*I     -83/ 30 +103/ 30*I 
  -329/240 +559/240*I      +7/ 24 +449/144*I     -55/ 12 +31/  6*I 
.
    -2/  1 +29/ 12*I 
    -1/ 10 +59/ 20*I 
   -19/ 30 +29/ 10*I 
    -1/  1 +109/ 36*I 

Remarque :

  • r_ pour rand.
  • p_ pour print.
  • i_ pour initialize.
  • f_ pour free.


La fonction f_mF();[modifier | modifier le wikicode]

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


Code source[modifier | modifier le wikicode]

/* ------------------------------------ */
void f_mF(
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_mF(
double **A
)
{
  if(A){ 
    free(A[0]);
    free(A);
       }
}


Ceci termine notre premier pas sur les double pointeurs.