Mathc matrices/Fichiers c : xi mr
Installer et compiler ce fichier dans votre répertoire de travail.
|
ai_mr.c |
|---|
/* ------------------------------------ */
/* Save as : ai_mr.c */
/* ------------------------------------ */
#include "v_a.h"
/* ---------------------------------------------------------------------------
Do : Dynamically allocate a multidimensional array.
(see : FAQ of the comp.lang.c group)
You can keep the array's contents contiguous,
r0 r1 r2 ... rn
R_000|C_xxx|0_xxx|...|0_xxx
R = Number of rows.
C = Number of columns.
The declaration of the sizes into the matrices, it is my work.
So be careful.
The first row and the first column are not used.
*********************
The size of the row of the matrix is into A[R_SIZE][C0] = A[0][0]
The size of the column of the matrix is into A[C_SIZE][C0] = A[1][0]
*********************
The first element of the matrix is z =(A[1][1],A[1][1])
For a 10x10 matrix the last element is z = (A[10][10],A[10][10])
*********************
If you want to duplicate a matrix A, you must use :
double **T;
T = i_RC_mR( A[R_SIZE][C0],
A[C_SIZE][C0]);
f_mR(T);
-------------------------------------------------------------------------- */
/* ------------------------------------ */
/* Same as i_RC_mR() but work with the
functions.
ex : i_mR(rsize_R(M),csize_R(M)); */
/* ------------------------------------ */
double **xi_mR(
int r,
int c
)
{
double **A;
int ar;
int ac;
int i;
if(r<R1||c<C1)
{
printf(" The size of the matrix must be positive integers.\n\n");
printf(" double **i_mR(); \n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
ar = r + R1;
ac = c + C1;
A = malloc(ar * sizeof(*A));
if(!A)
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR(); \n\n");
printf(" **A = malloc(ar * sizeof(*A));\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
A[0] = malloc(ar * ac * sizeof(**A) );
if(!A[0])
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR();\n\n");
printf(" A[0] = malloc(ar * ac * sizeof(**A) );\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
for(i=R1; i<ar; i++) A[i] = A[0]+i*ac;
/* ----------- Give a value to the zero row and the zero column ------------- */
A[R_SIZE][C0] = ar;
A[C_SIZE][C0] = ac;
for(r=R2; r<A[R_SIZE][C0]; r++)
A[r][0] = 0.;
for(c=C1; c<A[C_SIZE][C0]; c++)
A[0][c] = c;
m0_mR(A);
return(A);
}
/* ------------------------------------ */
/* ------------------------------------ */
void fun(int r,int c)
{
double **A = r_mR(xi_mR(r,c),9);
clrscrn();
printf(" A[R%d,C%d]: (p_mR();)\n",rsize_R(A),csize_R(A));
p_mR(A,S4,P0,C8);
printf("\n\n\n");
printf(" A[R%d,C%d]: (pall_mR();)\n",rsize_R(A),csize_R(A));
pall_mR(A,S4,P0,C9);
f_mR(A);
}
/* ------------------------------------ */
int main(void)
{
time_t t;
srand(time(&t));
do
fun(rp_I(R4),rp_I(C8));
while(stop_w());
return 0;
}
/* ------------------------------------ */
/* ------------------------------------ */
La fonction i_mR(); existant déjà dans la bibliothèque je l'ai ici renommé xi_mR();
Nous connaissons la fonction pall_mR(); qui permet afficher la colonne zéro et la ligne zéro.
Étudions quelques sorties écran.
Exemple de sortie écran :
A[R4,C8]: (p_mR();)
-1 -3 +6 -3 -5 -3 -3 +4
-1 +8 -7 -9 +2 -1 +8 -5
-7 +6 -5 +6 +8 +2 -3 -1
-5 +8 -9 -5 -7 -1 -3 -5
A[R4,C8]: (pall_mR();)
+5 +1 +2 +3 +4 +5 +6 +7 +8
+9 -1 -3 +6 -3 -5 -3 -3 +4
+0 -1 +8 -7 -9 +2 -1 +8 -5
+0 -7 +6 -5 +6 +8 +2 -3 -1
+0 -5 +8 -9 -5 -7 -1 -3 -5
Press return to continue
Press X to stop
Nous allons étudier la fin de la fonction.
/* ----------- Give a value to the zero row and the zero column ------------- */
A[R_SIZE][C0] = ar; /* On copie le nombre de lignes dans la case A[0;0] */
A[C_SIZE][C0] = ac; /* On copie le nombre de colonnes dans la case A[1;0] */
for(r=R2; r<A[R_SIZE][C0]; r++) /* On met des zéro dans la colonne zéro */
/* à partir de la ligne deux */
A[r][0] = 0.;
for(c=1; c<A[C_SIZE][C0]; c++) /* On crée un index dans la ligne zéro */
A[0][c] = c;
m0_mR(A); /* On initialise la matrice comme une matrice zéro */
return(A); /* On retourne l'adresse de la matrice au programme */
}
Passons maintenant au début de la fonction.
if(r<R1||c<C1) /* On vérifie que les tailles des lignes */
{ /* et des colonnes sont positives */
printf(" The size of the matrix must be positive integers.\n\n");
printf(" double **i_mR(); \n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
ar = r + R1; /* On rajoute une ligne, la ligne zéro */
ac = c + C1; /* On rajoute une colonne, la colonne zéro */
Maintenant vérifions si on a suffisamment d'espace pour le nombre de lignes
A = malloc(ar * sizeof(**A)); /* Donne de l'espace pour ar lignes */
if(!A) /* Si cela à échoué... */
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR(); \n\n");
printf(" **A = malloc(ar * sizeof(**A));\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
sizeof(**A) indique que l'on travaille avec des doubles. On crée donc un espace pour ar double.
Maintenant vérifions si on a suffisamment d'espace pour le nombre de colonnes
A[0] = malloc(ar * ac * sizeof(**A) ); /* Donne de l'espace pour ar*ac colonnes */
if(!A[0]) /* Si cela à échoué... */
{
printf(" I was unable to allocate the memory you requested.\n\n");
printf(" double **i_mR();\n\n");
printf(" A[0] = malloc(ar * ac * sizeof(**A) );\n\n");
fflush(stdout);
getchar();
exit(EXIT_FAILURE);
}
for(i=R1; i<ar; i++) A[i] = A[0]+i*ac; /* On associe à chaque ligne les ac colonnes */