Mathc matrices/Fichiers c : xi mr

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


Installer et compiler ce fichier dans votre répertoire de travail.

Crystal Clear mimetype source c.png 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_duplicate_mR(  A[R_SIZE][C0],
                             A[C_SIZE][C0]);

        f_mR(T);

   -------------------------------------------------------------------------- */
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=1; 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_mR(A),csize_mR(A));
  p_mR(A,4,0,C8);

  printf("\n\n\n");
  printf(" A[R%d,C%d]:          (pall_mR();)\n",rsize_mR(A),csize_mR(A));
  pall_mR(A,4,0,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 librairie 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 */