C pointeurs/Matrices complexes fractions
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
|
| c_a_A_mF(a,A); | Copier le tableau "a" dans la matrice "A" |
| p_mF(A,N,F,C); | Imprimer la matrice "A"
|
| 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.
