Mathc matrices/069

Application

Installer et compiler ces fichiers dans votre répertoire de travail.

	c00a.c

/* ------------------------------------ */
/*  Save as :   c00a.c                  */
/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
#define  RA  R4
#define  CA  C6
#define  Cb  C1
/* ------------------------------------ */
#define CB     C2            /* B : a basis for the column space of A */
/* ------------------------------------ */
#define CbFREE Cb+C3
/* ------------------------------------ */
#define Cx       C3
#define SVALUE   4.
/* ------------------------------------ */
int main(void)
{
double ab[RA*(CA+Cb)]={
   +9,   -15,   +21,   -18,    +6,   +27,    +0, 
  -18,   +30,   -42,   +36,   -12,   -54,    +0, 
  +21,   -35,   +49,   -42,   +14,   +63,    +0, 
   -6,   +10,   -14,   +12,    -4,   -18,    +0 
};

double **Ab =      ca_A_mR(ab, i_Abr_Ac_bc_mR(RA,CA,Cb));
double **A  =    c_Ab_A_mR(Ab,           i_mR(RA,CA));
double **b  =    c_Ab_b_mR(Ab,           i_mR(RA,Cb));

double **AT = transpose_mR(A,            i_mR(CA,RA));

double **B   =                           i_mR(RA,CB);
double **BT  =                           i_mR(CB,RA);
double **BTb =                 i_Abr_Ac_bc_mR(CB,RA,Cb); 

double **BTb_free =            i_Abr_Ac_bc_mR(RA,RA,CbFREE);
double **b_free   =                      i_mR(RA,CbFREE);

double **cx     =                        i_mR(RA,C1);
double **scx    =                        i_mR(RA,C1);
double **AT_scx =                        i_mR(CA,C1); 

int r;

  clrscrn();
  printf(" Verify if the scalar multiplication of a column of b_free\n"
         " is orthogonal to A :\n\n");
  printf(" A :");
  p_mR(A,S6,P1,C10);
  printf(" AT :");
  p_mR(AT, S7,P3,C10);
  stop();

     gj_PP_mR(Ab,NO);
  
       c_c_mR(A,C1,B,C1);
 transpose_mR(B,BT);        
         c_mR(BT,BTb); 
     gj_PP_mR(BTb,NO); 

  put_zeroR_mR(BTb,BTb_free);  
  put_freeV_mR(BTb_free);

  r = rsize_R(BTb_free);
  while(r>R1)    
        zero_below_pivot_gj1Ab_mR(BTb_free,r--);
       
  c_Ab_b_mR(BTb_free,b_free);

  clrscrn();    
  printf(" b_free :"); 
  p_mR(b_free, S7,P3,C10);
  
  c_c_mR(b_free,Cx,cx,C1);
  
  printf(" %.2f * C%d :",SVALUE,Cx);  
  p_mR(smul_mR(SVALUE,cx,scx),S10,P3,C7);
  printf(" AT * (%.2f*C%d) :",SVALUE,Cx);     
  p_mR(mul_mR(AT,scx,AT_scx),S10,P9,C7);
  stop();
         
  f_mR(Ab);
  f_mR(A);
  f_mR(b);

  f_mR(AT);
    
  f_mR(B);
  f_mR(BT);
  f_mR(BTb);
  
  f_mR(BTb_free);
  f_mR(b_free);    

  f_mR(cx); 
  f_mR(scx);
  f_mR(AT_scx);
         
  return 0;
}
/* ------------------------------------ */
/* ------------------------------------ */

On peut sélectionner la colonne de travail et la valeur du scalaire dans le code ci-dessous.

#define Cx        C3
#define SVALUE    4.

Exemple de sortie écran :

 Verify if the scalar multiplication of a column of b_free
 is orthogonal to AT :

 A :
  +9.0  -15.0  +21.0  -18.0   +6.0  +27.0 
 -18.0  +30.0  -42.0  +36.0  -12.0  -54.0 
 +21.0  -35.0  +49.0  -42.0  +14.0  +63.0 
  -6.0  +10.0  -14.0  +12.0   -4.0  -18.0 

 AT :
 +9.000 -18.000 +21.000  -6.000 
-15.000 +30.000 -35.000 +10.000 
+21.000 -42.000 +49.000 -14.000 
-18.000 +36.000 -42.000 +12.000 
 +6.000 -12.000 +14.000  -4.000 
+27.000 -54.000 +63.000 -18.000 

 Press return to continue. 


 b_free :
 +0.000  +2.000  -2.333  +0.667 
 +0.000  +1.000  +0.000  +0.000 
 +0.000  +0.000  +1.000  +0.000 
 +0.000  +0.000  +0.000  +1.000 

 4.00 * C3 :
    -9.333 
    +0.000 
    +4.000 
    +0.000 

 AT * (4.00*C3) :
+0.000000000 
-0.000000000 
+0.000000000 
-0.000000000 
+0.000000000 
+0.000000000 

 Press return to continue.