Mathc matrices/c29a5

La décomposition spectral

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

	c05.c

/* ------------------------------------ */
/*  Save as :  c05.c                    */
/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
void fun(int r)
{
double **A         = rsymmetric_mR(i_mR(r,r),999.);
double **EigsVector=               i_mR(r,r);
double **EigsVector_T=             i_mR(r,r);
double **EigsValue =               i_mR(r,C1);

double **b1=                       i_mR(r,C1);
double **b2=                       i_mR(r,C1);
double **b3=                       i_mR(r,C1);

double **r1=                       i_mR(R1,r);
double **r2=                       i_mR(R1,r);
double **r3=                       i_mR(R1,r);

double **b1r1=                     i_mR(r,r);
double **b2r2=                     i_mR(r,r);
double **b3r3=                     i_mR(r,r);

double **E1b1r1=                    i_mR(r,r);
double **E2b2r2=                    i_mR(r,r);
double **E3b3r3=                    i_mR(r,r);

double **T  =                      i_mR(r,r);
double **a  =                      i_mR(r,r);

  clrscrn();
  printf(" Copy/Past into the octave windows \n\n");
  p_Octave_mR(A,"a", P0);
  printf(" [V, E] = eigs (a,%d) \n\n",r);

  eigs_V_mR(A,EigsVector); 
  printf(" EigsVector:");
  p_mR(EigsVector, S5, P6, C6);
  
  transpose_mR(EigsVector,EigsVector_T); 
   
  eigs_mR(A, EigsValue);
  printf(" EigsValue :");
  p_mR(EigsValue, S13, P6, C1);  
  stop();


  clrscrn(); 
  c_c_mR(EigsVector, C1, b1, C1 );
  c_c_mR(EigsVector, C2, b2, C1 );
  c_c_mR(EigsVector, C3, b3, C1 );
  
  c_r_mR(EigsVector_T, R1, r1, C1 );
  c_r_mR(EigsVector_T, R2, r2, C1 );  
  c_r_mR(EigsVector_T, R3, r3, C1 ); 
  
  mul_mR(b1, r1, b1r1);
  mul_mR(b2, r2, b2r2);
  mul_mR(b3, r3, b3r3); 
  
  smul_mR(EigsValue[R1][C1]*EigsValue[R1][C1], b1r1, E1b1r1);
  smul_mR(EigsValue[R2][C1]*EigsValue[R2][C1], b2r2, E2b2r2);
  smul_mR(EigsValue[R3][C1]*EigsValue[R3][C1], b3r3, E3b3r3);   
  
  printf(" A**2 :");
  pow_mR(2, A, T);
  p_mR(T, S12, P0, C6); 
  
  add_mR(E1b1r1, E2b2r2, T); 
  add_mR(     T, E3b3r3, a);  
  printf(" E1**2 * b1r1 + E2**2 * b2r2 + E3**2 * b3r3 = A**2");
  p_mR(a, S12, P3, C6);
   
  f_mR(A);
  f_mR(EigsVector);
  f_mR(EigsVector_T);
  f_mR(EigsValue);
    
  f_mR(b1);
  f_mR(b2);
  f_mR(b3);

  f_mR(r1);
  f_mR(r2);
  f_mR(r3);  
 
  f_mR(b1r1);
  f_mR(b2r2);
  f_mR(b3r3);
  
  f_mR(E1b1r1);
  f_mR(E2b2r2);
  f_mR(E3b3r3);

  f_mR(T);
  f_mR(a);
}
/* ------------------------------------ */
int main(void)
{

do
{
 fun(R3);

} while(stop_w());

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

Nous voyons une des propriétés de la décomposition spectral:

• E1**2 * b1r1 + E2**2 * b2r2 + E3**2 * b3r3 = A**2
• E1**n * b1r1 + E2**n * b2r2 + E3**n * b3r3 = A**n

On peux calculer la nième puissance de A en simplement prenant la puissance nième de chacune des valeurs propres.

Exemple de sortie écran :

 ------------------------------------ 
 Copy/Past into the octave windows 

 a=[
-479,-269,+992;
-269,-501,+904;
+992,+904,-763]

 [V, E] = eigs (a,3) 

 EigsVector:
-0.512981 +0.544352 -0.663726 
-0.485715 +0.453457 +0.747300 
+0.707765 +0.705732 +0.031785 

 EigsValue :
 -2102.375181 
  +583.009012 
  -223.633832 

 Press return to continue. 


 A**2 :
    +1285866     +1160388     -1475240 
    +1160388     +1140578     -1409504 
    -1475240     -1409504     +2383449 

 E1**2 * b1r1 + E2**2 * b2r2 + E3**2 * b3r3 = A**2
+1285866.000 +1160388.000 -1475240.000 
+1160388.000 +1140578.000 -1409504.000 
-1475240.000 -1409504.000 +2383449.000 


 Press return to continue
 Press X      to stop