Mathc matrices/a154

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

	`c00a.c`

/* ------------------------------------ */
/*  Save as :   c00a.c                  */
/* ------------------------------------ */
#include "v_a.h"
/* ------------------------------------ */
#define RCA          RC4
/* ------------------------------------ */
void fun(void)
{
int i;

double **A         [C4];  
double **LogA_EValue[C4];
double **LogA       [C4];

double **V       = i_mR(RCA,RCA);
double **V_T     = i_mR(RCA,RCA);
double **EValue  = i_mR(RCA,RCA); 
double **T       = i_mR(RCA,RCA);
                      
  for(i = C0; i < C3; i++)
     { 
       clrscrn();

       if(i < C2)	
     
            A[i] = rEsymmetric_mR(i_mR(RCA,RCA),999,+1.E-3);
            
       else if(i == C2)   
           {
            A[i] = mul_mR(A[C0],A[C1],i_mR(RCA,RCA));  

            printf(" ERROR : A2 = A0 * A1 : Try into octave -> A0*A1\n\n"
                   " My work is not correct if the matrix\n"
                   " is not symetric \n\n"); 
            }                           
                     
          printf(" Copy/Past into the octave window.\n\n");
          pAi_Octave_mR(A[i],"A",i, P4);
          printf(" [V, E] = eigs (A%d,%d) \n\n",i,RCA);
          printf(" logm (A%d)\n\n\n",i);
          stop();  
          
          clrscrn();
          LogA_EValue[i] = i_mR(RCA,RCA);  
          LogA[i]        = i_mR(RCA,RCA);   
          
          printf(" A[%d] :",i);
          p_mR(A[i], S9,P4, C6);
  
          eigs_V_mR(A[i],V);
          transpose_mR(V,V_T);
    
/* EValue = V_T * A * V */   
         mul_mR(V_T,A[i],T);
         mul_mR(T,V,EValue); 
         clean_eye_mR( EValue);
         
         printf(" EVector of A[%d]:",i);
         p_mR( V, S9,P4, C6);   
               
         printf(" EValue of A[%d]:",i);
         p_mR( EValue, S9,P4, C6);
            
         f_eigs_mR(log,EValue, LogA_EValue[i]);
    
         printf(" LogA_EValue[A%d] :",i);
         p_mR( LogA_EValue[i], S9,P4, C6);
  
/* LogA[i] = V * LogA_EValue[i] * V_T*/     
         mul_mR(V,LogA_EValue[i],T);
         mul_mR(T,V_T,LogA[i]); 
    
         printf(" LogA[A%d]",i);
         p_mR(LogA[i], S9,P4, C6);
         stop();
        } 
        
  clrscrn();         
  printf("    LogA[0]+LogA[1] :");
  p_mR(add_mR(LogA[0],LogA[1],T), S9,P4, C6);
  printf("    LogA[2] :");
  p_mR(LogA[2], S9,P4, C6);  
  stop();
           
  for(i = C0; i < C3; i++)
     {
      f_mR(A[i]);
      f_mR(LogA_EValue[i]);
      f_mR(LogA[i]); 
     }  
       
   f_mR(V);
   f_mR(V_T);
   f_mR(EValue); 
   f_mR(T);   
}
/* ------------------------------------ */
int main(void)
{
time_t t;

  srand(time(&t));

    fun();

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

                         Log(A0) + Log(A1) != Log(A0 * A1)

J'ai essayé de montrer les calculs intermédiaires de ce travail. Tous les calculs des valeurs propres et des vecteurs propres semblent identiques à ceux que propose octave. Le problème commence avec LogA[2] de mon travail, qui est différent du LogA[2] d'octave, alors que les vecteurs propres et les valeurs propres de A[2] sont identiques à ceux que donne octave.

 Si vous tapez le code dans octave  :

logm (A0) + logm (A1)
logm (A0*A1)

Après avoir testé un exemple vous pourrez observer que les résultats sont différent. Cela me laisse supposer qu'il faut que les matrices commutent pour obtenir l'égalités.

La fonction clean_eye_mR(); nettoie la matrice des valeurs propres de la matrice A[2] peut être parce qu'elle n'est pas symétrique !!!