Mathc matrices/Fichiers h : vc m

Bibliothèque

Installer ce fichier dans votre répertoire de travail.

	vc_m.h

/* ------------------------------------ */
/*  Save as :   vc_m.h                  */
/* ------------------------------------ */

/* ------------------------------------ */
double ** c_mR(
double **A,
double **B
)
{
int r;
int c;

 	for    (r=R1; r<A[R_SIZE][C0]; r++)
 	   for (c=C1; c<A[C_SIZE][C0]; c++)

            B[r][c] = A[r][c];

return(B);
}
/* ------------------------------------ */
/* ------------------------------------ */
double  **ca_A_mR(
double  a[],
double  **A
)
{
int r;
int c;
int i=0;

 	for    (r=R1; r<A[R_SIZE][C0]; r++)
 	   for (c=C1; c<A[C_SIZE][C0]; c++)

            A[r][c] = a[i++];
            
return(A);
}
/* ------------------------------------ */
/* ------------------------------------ */
double  **c_c_mR(
double **A,
int cA,
double **B,
int cB
)
{
int r;

    for(r=R1; r<A[R_SIZE][C0]; r++)

            B[r][cB] = A[r][cA];
return(B);
}
/* ------------------------------------ */
double  **c_r_mR(
double **A,
int rA,
double **B,
int rB
)
{
int c;

    for(c=C1; c<A[C_SIZE][C0]; c++)

            B[rB][c] = A[rA][c];
return(B);
}
/* ------------------------------------ */
/* ------------------------------------ */
double  **c_c_r_mR(
double **A,
int cA,
double **B,
int rB
)
{
int rc;

    for(rc=RC1; rc<A[R_SIZE][C0]; rc++)

            B[rB][rc] = A[rc][cA];
return(B);
}
/* ------------------------------------ */
/* ------------------------------------ */
double **c_c_diag_mR(
double **AC,
double **AD
)
{
int      r;

  m0_mR(AD);
  
  for(r=R1; r<AC[R_SIZE][C0]; r++)

             AD[r][r] = AC[r][C1];
 return(AD);
}
/* ------------------------------------ */
double **c_D_UC1_mR(
double **D,
double **U
)
{
int  r;
int  c;

  for (   r=R1; r<D[R_SIZE][C0]; r++)
    for ( c=C1; c<D[C_SIZE][C0]; c++)

        if(r==c)       
          
               U[r][C1] = D[r][c];
              
 return(U);
}
/* ------------------------------------ */
/* ------------------------------------ */
void c_s_mR(
double  s,
double **A,
int r,
int c
)
{
int Rmax = (A[R_SIZE][C0]-R1);
int Cmax = (A[C_SIZE][C0]-C1);

    if( r<R1 ||
        c<C1 ||
        r> Rmax||
        c> Cmax)
    {
     printf("\n Error : c_coef_R(); \n\n");
     printf("\n R = %d;  C = %d; \n",r,c);
     printf("\n R and C must be : \n");
     printf("\n R>=1; C>=1;\n R=<%d; C=<%d;\n",
              Rmax,
              Cmax);
     printf("\n Press return to continue. \n");
     fflush(stdout);
     getchar();
     exit(EXIT_FAILURE);
    }
         A[r][c] = s;
}
/* ------------------------------------ */
/* ------------------------------------ */
double  **c_r_reverse_order_mR(
double **U,
double **V
)
{
int c;

    for(c=C1; c<U[C_SIZE][C0]; c++)

            V[R1][csize_R(V)+C1-c] = U[R1][c];
return(V);
}
/* ------------------------------------ */
/* ------------------------------------ */
double  **c_rU_rA_cn_mR(
double **U,
int rU,
double **A,
int rA,
int cn
)
{
int c;

    for(c=C1; cn<A[C_SIZE][C0]; c++,cn++)

            A[rA][cn] = U[rU][c];
            
return(A);
}
/* ------------------------------------ */
/* ------------------------------------ */
double  **c_cV_cA_rn_mR(
double **V,
int cV,
double **A,
int cA,
int rn
)
{
int r;

    for(r=R1; rn<A[R_SIZE][C0]; r++,rn++)

            A[rn][cA] = V[r][cV];
            
return(A);
}
/* ------------------------------------ */
/* ------------------------------------ */
double  **c_Uc_r_mR(
double **U,
int     Uc,
double **A,
int     rA
)
{
int c;

    for(c=C1; Uc<U[C_SIZE][C0]-C1; c++,Uc++)

            A[rA][c] = U[R1][Uc];
return(A);
}
/* ------------------------------------ */
/* ------------------------------------ */

La fonction c_mR(); permet de copier la matrice A dans la matrice B. Elle ne vérifie pas la taille des matrices. Le fait d'avoir conservé cette possibilité m'a rendu de grand service.

La deuxième fonction copie un tableau de nombre dans une matrice.

La fonction c_c_mR(); copie une colonne de A dans une colonne de B.

La fonction c_r_mR(); copie une ligne de A dans une ligne de B.

La fonction c_c_r_mR(); copie une colonne de A dans une ligne de B.

La fonction c_D_UC1_mR(); copie une diagonale dans un vecteur colonne.