Mathc matrices/c22u

Sommaire ◀ Utilise la commande "Retour en Arrière" de ton navigateur.

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

	c00a.c

/* ------------------------------------ */
/*  Save as :   c00a.c                  */
/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
/* ------------------------------------ */
#define   RA R3
#define   CA C2
#define   Cb C1 
/* ------------------------------------ */
/* ------------------------------------ */
void fun(void)
{
double ab[RA*(CA+Cb)]={
 1,  1, 1,
 2,  3, 7,
 3,  4, 9
};

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 **A_T        = i_mR(CA,RA);
double **A_TA       = i_mR(CA,CA); //         A_T*A
double **invA_TA    = i_mR(CA,CA); //     inv(A_T*A)
double **invA_TAA_T = i_mR(CA,RA); //     inv(A_T*A)*A_T

double **x          = i_mR(CA,Cb); // x = inv(A_T*A)*A_T*b

  clrscrn();
  printf("Find the unique Least Squares Solution of Ax = b : \n\n");
  printf(" A :");
  p_mR(A,S5,P1,C7);
  printf(" b :");
  p_mR(b,S5,P1,C7);
  printf(" Ab :");
  p_mR(Ab,S5,P1,C7);
  stop();
  
  clrscrn();
  printf(" A_T :");
  p_mR(transpose_mR(A,A_T),S5,P1,C7);
  printf(" A_TA :");
  p_mR(mul_mR(A_T,A,A_TA),S5,P1,C7);
  printf(" inv(A_TA) :");
  p_mR(inv_mR(A_TA,invA_TA),S5,P4,C7);  
  printf(" inv(A_TA)*A_T :");
  p_mR(mul_mR(invA_TA,A_T,invA_TAA_T),S5,P4,C7);
  printf("\n x = inv(A_TA)*A_T*b :");
  p_mR(mul_mR(invA_TAA_T,b,x),S5,P4,C7);     
  stop();  

  clrscrn();
  printf(" Solving this system yields a unique\n"
         " least squares solution, namely   \n\n");
  printf(" x = inv(A_TA)*A_T * b :");   
  p_mR(x,S10,P4,C6);
  printf(" A :");
  p_mR(A,S10,P4,C6);
  printf(" b :");
  p_mR(b,S10,P4,C6);
  printf(" A x = b' :"); 
  mul_mR(A,x,b);  
  p_mR(b,S10,P4,C6);
  stop();
    
  f_mR(A);
  f_mR(b);
  f_mR(Ab);

  f_mR(A_T);
  f_mR(A_TA);       //         A_T*A
  f_mR(invA_TA);    //     inv(A_T*A)
  f_mR(invA_TAA_T); //     inv(A_T*A)*A_T
    
  f_mR(x); 
}
/* ------------------------------------ */
int main(void)
{
	
  fun();

  return 0;
}
/* ------------------------------------ */
/* ------------------------------------ */

 Nous avons une liste de points dans un nuage. 
 Il faut que ce nuage puisse être modélisé par une droite.
 Il ne doit donc pas y avoir des valeurs extrêmes sortant du nuage.

Exemple de sortie écran :

Find the unique Least Squares Solution of Ax = b : 

 A :
 +1.0  +1.0 
 +2.0  +3.0 
 +3.0  +4.0 

 b :
 +1.0 
 +7.0 
 +9.0 

 Ab :
 +1.0  +1.0  +1.0 
 +2.0  +3.0  +7.0 
 +3.0  +4.0  +9.0 

 Press return to continue. 


 A_T :
 +1.0  +2.0  +3.0 
 +1.0  +3.0  +4.0 

 A_TA :
+14.0 +19.0 
+19.0 +26.0 

 inv(A_TA) :
+8.6667 -6.3333 
-6.3333 +4.6667 

 inv(A_TA)*A_T :
+2.3333 -1.6667 +0.6667 
-1.6667 +1.3333 -0.3333 


 x = inv(A_TA)*A_T*b :
-3.3333 
+4.6667 

 Press return to continue. 


 Solving this system yields a unique
 least squares solution, namely   

 x = inv(A_TA)*A_T * b :
   -3.3333 
   +4.6667 

 A :
   +1.0000    +1.0000 
   +2.0000    +3.0000 
   +3.0000    +4.0000 

 b :
   +1.0000 
   +7.0000 
   +9.0000 

 A x = b' :
   +1.3333 
   +7.3333 
   +8.6667 

 Press return to continue.