Aller au contenu

C pointeurs/Matrices complexes fractions

Leçons de niveau 14
Une page de Wikiversité, la communauté pédagogique libre.
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
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.


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.


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();


/* ------------------------------------ */
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.