Programme pour lire une matrice triangulaire inférieure à partir

Programme pour lire une matrice triangulaire inférieure à partir - C++ - Programmation

Marsh Posté le 07-08-2006 à 18:25:24    

Bonjour,
 
Je voudrais lire une matrice inférieure à partir d'un fichier .txt.  
La forme de la matrice en question est la suivante :

Code :
  1. 4
  2. 1.23E-02
  3. -1.24E-02 1.26E-02
  4. 1.27E-02 -1.23E-04 1.23E-03
  5. 1.27E-02 -1.23E-04 1.23E-03 1.23E-03


Le premier élément de cette matrice qui est 4 représente la dimension, le reste des éléments constituent la matrice.
N'étant pas expert en c++ je suis passé par deux codes différents mais aucun ne me donne un réusltat satisfaisant.
 
code 1 :

Code :
  1. #include "essai.h"
  2. #include <iostream>
  3. #include <fstream>
  4. #include <iomanip>
  5. using namespace std;
  8. using namespace std;
  10. int main()
  11. {
  12.   // Ouverture du fichier
  13.   ifstream fichierEntree("c:\\test1.txt", ios::in);
  15.   // Test d'ouverture du fichier
  16.     if (!fichierEntree) {
  17.         cerr << "Problème d'ouverture de fichier" << endl;
  18.         exit(1);
  19.     }
  21.     char* ligne;
  22.     int i = 0;
  23.     char * err = NULL;
  24. //double z;  
  26.     ligne = new char[10];
  27.     fichierEntree.getline(ligne, 4);
  28.     int conv1 = strtoul(ligne,0,10);
  29. ArrayLengthSpecifier dimension(conv1);
  30. cout << conv1 << endl;
  31. SymmetricMatrix covariance(dimension);
  33.     int longueur;
  35.     do
  36.   {
  37.   i = i + 1;
  38.   longueur = 9 * i + 1;
  39.   ligne = new char [longueur];//format "0.00E+00"
  40.   //donc 8 caractères; 9i=8i+ (i-1) espaces + élt nul terminal
  41.   fichierEntree.getline(ligne,longueur);
  42.   cout << ligne << endl;
  44.   
  45.   for (int j=1;j<=i;j++)
  46.  {
  47.   char temp[9];
  48.   for (int k=0;k<=7;k++)
  49.   {
  50.    temp[8]=0;
  51.    if (j==1)
  52.    temp[k] = ligne[k];
  53.    else
  54.    temp[k] = ligne[9* (j - 1) + k ];//attention dimension de 0 à n-1
  56.   }
  57.   const char* caractere=temp;
  58.   cout << caractere << endl;
  59.   covariance(i,j) = 2 * strtod(caractere, &err);
  60.   cout << covariance(i,j) << endl;
  61.   cout << covariance(j,i) << endl;
  62.  }
  63.  delete[] ligne;
  65.   }
  66.   while (!fichierEntree.eof());
  68.     fichierEntree.close();
  69. }


 
code 2 :  
 
[code]
#include "essai.h"
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <string>
 
 
 
using namespace std;
 
 
 
int main()
{
 ifstream FichierMatrice("c:\\test1.txt",ios::in);
 if (!FichierMatrice)
 {
  cerr << "Ouverture du fichier impossible" << endl;
  exit(1);
 }
 
 int val1;
 int j = 0;  
 double* valf;
 double val;
 
 FichierMatrice >> val1;
 ArrayLengthSpecifier dimension(val1);
 SymmetricMatrix covariance(dimension);
 cout << val1 << endl;  
 
 int dime = (val1*(val1+1))/2;
 valf = new double [dime];
   
 do  
 {
    i = i + 1;
 FichierMatrice >> valf[j];
 cout << valf[j] <<endl;
 //cout << valf[1]<<endl;
 //cout << covariance (1,2) <<endl;
 //cout << covariance (2,1) <<endl;
 //cout << covariance (3,2) <<endl;
 }
 while (!FichierMatrice.eof());
 
 
 return 0;
}
[code]
La classe SymmetricMatrix et la matrice covariance sont correctement définis à l'aide de la bibliothèque Newmat.
Je suis vraiment bloqué parceque je n'arrive pas à traiter le fichier de donnée. Pourriez-vous m'aider sur ce point en me conseillant laquelle des deux voies d'abord suivre puis comment écire ce code???
 
Merci d'avance

Reply

Marsh Posté le 07-08-2006 à 18:25:24   

Reply

Marsh Posté le 07-08-2006 à 19:26:27    

tu aurais pu continuer sur le même topic plutôt que d'en ouvrir un autre :o
 
que donne un truc dans ce genre là :

Code :
  1. ifstream fichierEntree("c:\\test1.txt", ios::in);
  2. int dim;
  3. fichierEntree >> dim;
  4. ArrayLengthSpecifier dimension(dim);
  5. SymmetricMatrix covariance(dimension);
  7. /* lecture de la matrice */
  8. for( int i=1 ; i<=dim ; ++i )
  9. {
  10.   for( int j=1 ; j<=i ; ++j )
  11.   {
  12.     double val;
  13.     fichierEntree >> val;
  14.     covariance(i,j) = val;
  15.   }
  16. }
  17. fichierEntree.close();
  19. /* affichage pour tester */
  20. for( int i=1 ; i<=dim ; ++i )
  21. {
  22.   for( int j=1 ; j<=dim ; ++j )
  23.   {
  24.     std::cout << setw(10) << covariance(i,j);
  25.   }
  26.   std::cout << std::endl;
  27. }


---------------
TriScale innov
Reply

Marsh Posté le 09-08-2006 à 14:56:19    

Bonjour,
Merci pour ton message, je n'ai malheureusement pas pu le lire auparavant,
Le code que tu m'a laissé marche bieb je l'ai testé.
Par contre j'aurais une petite question concercant les lignes suivantes pour les tests car j'aimerai savoir comment ça marche pour pouvoir l'exploiter plus tard :

Code :
  1. for( int i=1 ; i<=dim ; ++i )
  2. { 
  3. for( int j=1 ; j<=dim ; ++j )
  4. {   
  5. std::cout << setw(10) << covariance(i,j); 
  6. } 
  7. std::cout << std::endl;
  8. }


 
a quoi sert le setw(10)???
je voudrais utiliser ce qui sort en test dans un fichier c'est pour ça que je te pose la question, j'ai l'impression que c'est assez proche !

Message cité 1 fois
Reply

Marsh Posté le 09-08-2006 à 14:57:56    

Reply

Marsh Posté le 09-08-2006 à 15:19:35    

oui ok c'est l'espace entre les sorties je m'en suis aperçu quad j'ai testé je suis débutant en C++, alors excusez mon manque d'expérience.
Par contre j'ai encore deux petites questions. Je pense que la première est un peu évidente pour vous !
 
Pensez-vous que cette syntaxe est correcte pour l'écriture du résultat extrait dans un fichier (bien sûr ici il n'a subi aucun traitement, le traitement en question est le sujet de ma deuxième question, c'est juste pour voir si j'arrive à écrie sans problème).
 
Cette partie de code est à mettre juste après :

Code :
  1. fichierEntree.close();


 

Code :
  1. ofstream fichierSortie("C:\\sortie.txt",ios::in);
  2. if (!fichierSortie)
  3. {
  4.  cerr << "Création du fichier impossible" << endl;
  5.  exit(1);
  6.     }
  7. for (int i=1;i<=dim;i++)
  8. {
  9. for (int j=1;j<=i;j++)
  10. {
  11. double vals;
  12. vals << fichierSortie ;   
  13. }
  14. }
  15. fichierSortie.close();


 
Normalement ca devarit marché mais il y a un problème sur l'opérande << que je ne comprend pas!
 
Ma deuxième question porte plutôt sur le une fonction issu d'une bibliothèque mathématique la fonction est la suivante :

Code :
  1. ReturnMatrix simind(const int& nbre_noms)
  2. {
  3. //créer une matrice colonne epsilon
  4. ColumnVector epsilon;
  5. //redimensionne la matrice espsilon avec la dimension correpondante  
  6. //au nombre de titre
  7. epsilon.ReSize(nbre_noms);
  8. //générateur de loie normale
  9. for (int i=1;  i<=nbre_noms; ++i)
  10. { 
  11.  epsilon(i)=(double)normal_random();
  12. }
  13. epsilon.Release();
  14. return epsilon;
  15. }


 
Elle retourne un vecteur colonnes dont les composantes sont des variables normales générés aléatoirment. Pourtant quand j'applique cette fonction à mon code je trouve qu'elle génère toujours les mêmes variables, ce que je ne comprend pas :
voici mon code intégrale :
 

Code :
  1. //fichier main principal
  2. #include "essai.h"
  3. #include <iostream>
  4. #include <sstream>
  5. #include <fstream>
  6. #include <iomanip>
  7. #include <string>
  10. using namespace std;
  14. int main()
  15. {
  18. ifstream fichierEntree("c:\\test1.txt", ios::in);
  19. int dim;
  20. fichierEntree >> dim;
  21. ArrayLengthSpecifier dimension(dim);
  22. SymmetricMatrix covariance(dimension);
  23. /* lecture de la matrice */
  24. for( int i=1 ; i<=dim ; ++i )
  25. { 
  26. for( int j=1 ; j<=i ; ++j ) 
  27. {   
  28. double val;   
  29. fichierEntree >> val;   
  30. covariance(i,j) = val; 
  31. }
  32. }
  33. fichierEntree.close();
  34. //décompose la matrice de covariance suivant cholesky
  35. Matrix C;
  36. C = chol(covariance);
  37. //génère un vecteur colonne de variable normale
  38. ColumnVector E;
  39. E = simind (dim);
  41. ofstream fichierSortie("C:\\sortie.txt",ios::in);
  42. if (!fichierSortie)
  43. {
  44.  cerr << "Création du fichier impossible" << endl;
  45.  exit(1);
  46.     }
  47. for (int i=1;i<=dim;i++)
  48. {
  49. for (int j=1;j<=i;j++)
  50. {
  51. double vals;
  52. vals << fichierSortie ;   
  53. }
  54. }
  55. fichierSortie.close();


 
Merci d'avance pour votre aide

Message cité 2 fois
Reply

Marsh Posté le 09-08-2006 à 15:37:09    

Pour la question 1 :

iamora a écrit :

Code :
  1. ofstream fichierSortie("C:\\sortie.txt",ios::in); // si tu veux écrire dans le fichier, c'est ios::out qu'il faut mettre
  2. if (!fichierSortie)
  3. {
  4. cerr << "Création du fichier impossible" << endl;
  5. exit(1);
  6. }
  8. for (int i=1;i<=dim;i++)
  9. {
  10.   for (int j=1;j<=i;j++)
  11.   {
  12.     double vals;               // si tu n'initialise pas vals, tu vas écrire n'importe quoi dans ton fichier
  14.     vals << fichierSortie ;    // c'est dans l'autre sens qu'on écrit : monFlux << maValeurAEcrireDansLeFlux
  15.                                // comme dans : std::cout << "hello world\n"
  16.   }
  17. }
  18. fichierSortie.close();



 
Pour la question 2:
que fait la fonction normal_random() ? D'où sort elle (une bibliothèque, ou bien c'est toi qui l'as programmée) ? Quand tu dis qu'elle génère toujours la même chose, a veut dire que tu obtiens toujours le même vecteur, ou bien que toutes les composantes de ton vecteur sont égales ? Es-tu sûr de l'utiliser correctement ? habituellement, les fonctions qui génèrent des nombres pseudo-aléatoires doivent être initialisées avec une graine (sinon elles renvoient toujours la même suite de nombres)


Message édité par franceso le 09-08-2006 à 15:43:10

---------------
TriScale innov
Reply

Marsh Posté le 09-08-2006 à 15:40:43    

iamora a écrit :

oui ok c'est l'espace entre les sorties je m'en suis aperçu quad j'ai testé je suis débutant en C++, alors excusez mon manque d'expérience.


 
Tout les débutants sont excusés à partir du moment où qu'il mettent les mains dans le cambouis, la documentation et google :jap:


---------------
Töp of the plöp
Reply

Marsh Posté le 09-08-2006 à 16:08:18    

Tout d'abord merci pour la présicion de tes réponses.
 
Pour la question1 : Il me manque encore la notion d'initialiser une variable, que cela veut-il dire ?, et pourquoi ne l'a t-on pas fait lors de la lecture du fichier
 
 
Pour la question 2:
 
que fait la fonction normal_random() ? D'où sort elle (une bibliothèque, ou bien c'est toi qui l'as programmée) ?  
 
La fonction normal_random() génére aléatoirement une valeur d'une variable aléatoire. Elle est définie ci-dessus et provient de la bibliothèque newmat
 

Code :
  1. double normal_random()
  2. {
  3. return cndev(genrand_real1());
  4. }


 
genrand_real1 est défini quant à lui ci-dessus
 

Code :
  1. double genrand_real1(void)
  2. {
  3.     return genrand_int32()*(1.0/4294967295.0);
  4.     /* divided by 2^32-1 */
  5. }


 
genrand_int32 est défini quant à lui ci-dessus:

Code :
  1. unsigned long genrand_int32(void)
  2. {
  3.     unsigned long y;
  4.     static unsigned long mag01[2]={0x0UL, MATRIX_A};
  5.     /* mag01[x] = x * MATRIX_A  for x=0,1 */
  7.     if (mti >= N) { /* generate N words at one time */
  8.         int kk;
  10.         if (mti == N+1)   /* if init_genrand() has not been called, */
  11.             init_genrand(5489UL); /* a default initial seed is used */
  13.         for (kk=0;kk<N-M;kk++) {
  14.             y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
  15.             mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
  16.         }
  17.         for (;kk<N-1;kk++) {
  18.             y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
  19.             mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
  20.         }
  21.         y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
  22.         mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
  24.         mti = 0;
  25.     }
  27.     y = mt[mti++];
  29.     /* Tempering */
  30.     y ^= (y >> 11);
  31.     y ^= (y << 7) & 0x9d2c5680UL;
  32.     y ^= (y << 15) & 0xefc60000UL;
  33.     y ^= (y >> 18);
  35.     return y;
  36. }


Je crois que ces fonctions partent d'un générateur de nombre aléatoires entre 0 et 1 puis grâce à la fonction de répartition réciproque de la loi normale il permette de générer une variable aléatoire.
 
Quand tu dis qu'elle génère toujours la même chose, a veut dire que tu obtiens toujours le même vecteur, ou bien que toutes les composantes de ton vecteur sont égales ? Es-tu sûr de l'utiliser correctement ? habituellement, les fonctions qui génèrent des nombres pseudo-aléatoires doivent être initialisées avec une graine (sinon elles renvoient toujours la même suite de nombres)[/quotemsg]
 
Je veux dire par là que la composante 1 de mon vecteur est toujours la même quand je compile un nouvelle fois ce qui ne devrait pas être le cas normalement. Tout à fait d'accord au sujet de la graine j'ai pensé pareil il faut qu'elle soit intégrer dans le fonction.
Je sais qu'en VB c'est Randomize la graine mais en C++ je n'ai aucune idée???
J'espère que mon problème est un peu plus clair???

Message cité 1 fois
Message édité par iamora le 09-08-2006 à 16:14:34
Reply

Marsh Posté le 09-08-2006 à 16:32:51    

iamora a écrit :

Pour la question1 : Il me manque encore la notion d'initialiser une variable, que cela veut-il dire ?, et pourquoi ne l'a t-on pas fait lors de la lecture du fichier

lorsque tu écris

Code :
  1. double vals

tu es en train de dire à ton compilateur : "je vais utiliser à partir de maintenant une variable ne nom 'vals', de type double". Rien de plus, rien de moins. En particulier, la valeur de la variable vals est indéfinie. Lorsque à la ligne suivante, tu écris :

Code :
  1. fichierSortie << vals;

tu es en train d'écrire dans le fichier la valeur de vals, à savoir n'importe quoi.
 
Il faut que tu écrives dans la variable avant de l'utiliser. Par exemple:

Code :
  1. for( int i ...)
  2. {
  3.   for( int j ... )
  4.   {
  5.     double val;
  6.     val = covariance(i,j);
  7.     fichierSortie << val;
  8.   }
  9. }


 
Ou plus simplement, puisque ici tu n'as pas besoin d'une variable intermédiaire vals :

Code :
  1. for( int i ...)
  2. {
  3.   for( int j ... )
  4.   {
  5.     fichierSortie << covariance(i,j);
  6.   }
  7. }


 
 
 

iamora a écrit :

Pour la question 2:
Je veux dire par là que la composante 1 de mon vecteur est toujours la même quand je compile un nouvelle fois ce qui ne devrait pas être le cas normalement. Tout à fait d'accord au sujet de la graine j'ai pensé pareil il faut qu'elle soit intégrer dans le fonction.
Je sais qu'en VB c'est Randomize la graine mais en C++ je n'ai aucune idée???


D'après les commentaires de la fonction genrand_int32, l'initialisation de la graine se fait avec la fonction init_genrand.
Il n'est pas interdit de regarder la documentation de ta bibliothèque non plus. C'est là que tu trouveras toutes les informations utiles pour utiliser les fonctions qu'elle définit :o


---------------
TriScale innov
Reply

Marsh Posté le 09-08-2006 à 17:00:46    

Merci pour tes réponses efficaces!

Reply

Marsh Posté le 09-08-2006 à 17:00:46   

Reply

Marsh Posté le 09-08-2006 à 17:45:16    

En fait ce que je t'ai envoyé sur la fonction normal_random n'est pas tiré sur une bibliothèque Newmat, je viens de m'en apercevoir, je ne connais pas tellement sa proivenance. En tout cas il a l'aire de foinctionner correctement, je pense que c'est l'un de ces générateurs de nombres utilisés pour les simulations de Monté Carlo!
En tout cas voilà le code

Code :
  1. #include "stdafx.h"
  3. #ifndef PI
  4. #define PI 3.141592653589793238462643
  5. #endif
  7. double n(const double& z)
  8. {
  9.     return (1.0/sqrt(2.0*PI))*exp(-0.5*z*z);
  10. }
  13. double N(const double& z) {
  14.     if (z >  6.0)
  15.  return 1.0; // this guards against overflow  
  16.     if (z < -6.0)
  17.  return 0.0;
  18.     double b1 =  0.31938153;
  19.     double b2 = -0.356563782;
  20.     double b3 =  1.781477937;
  21.     double b4 = -1.821255978;
  22.     double b5 =  1.330274429;
  23.     double p  =  0.2316419;
  24.     double c2 =  0.3989423;
  25.     double a=fabs(z);
  26.     double t = 1.0/(1.0+a*p);
  27.     double b = c2*exp((-z)*(z/2.0));
  28.     double n = ((((b5*t+b4)*t+b3)*t+b2)*t+b1)*t;
  29.     n = 1.0-b*n;
  30.     if ( z < 0.0 ) n = 1.0 - n;
  31.     return n;
  32. }
  35. double random_0_1(void)
  36. {
  37. return double(rand())/double(RAND_MAX);
  38. }
  41. double box_muller(void)
  42. {
  43. double U1, U2, V1, V2;
  44. double S=2;
  45. while (S>=1)
  46. {
  47.  U1 = random_0_1();
  48.  U2 = random_0_1();
  49.  V1 = 2.0*U1-1.0;
  50.  V2 = 2.0*U2-1.0;
  51.  S = (V1*V1)+(V2*V2);
  52. }
  53. double X1=V1*sqrt((-2.0*log(S))/S);
  54. return X1;
  55. }
  58. double normal_random()
  59. {
  60. return cndev(genrand_real1());
  61. }
  65. double lognormal_random(const double& S,const double& r,const double& sigma,
  66.      const double& time)
  67. {
  68. double R = (r-0.5 * (sigma*sigma) )*time;
  69. double SD = sigma * sqrt(time);
  70. return S * exp(R + SD * normal_random());
  71. }
  73. #define N 624
  74. #define M 397
  75. #define MATRIX_A 0x9908b0dfUL 
  76. #define UPPER_MASK 0x80000000UL
  77. #define LOWER_MASK 0x7fffffffUL
  79. static unsigned long mt[N];
  80. static int mti=N+1;
  83. void init_genrand(unsigned long s)
  84. {
  85.     mt[0]= s & 0xffffffffUL;
  86.     for (mti=1; mti<N; mti++) {
  87.         mt[mti] =
  88.   (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
  89.         mt[mti] &= 0xffffffffUL;
  90. }
  91. }
  94. void init_by_array(unsigned long init_key[], int key_length)
  95. {
  96.     int i, j, k;
  97.     init_genrand(19650218UL);
  98.     i=1; j=0;
  99.     k = (N>key_length ? N : key_length);
  100.     for (; k; k--) {
  101.         mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
  102.   + init_key[j] + j; /* non linear */
  103.         mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
  104.         i++; j++;
  105.         if (i>=N) { mt[0] = mt[N-1]; i=1; }
  106.         if (j>=key_length) j=0;
  107.     }
  108.     for (k=N-1; k; k--) {
  109.         mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
  110.   - i; /* non linear */
  111.         mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
  112.         i++;
  113.         if (i>=N) { mt[0] = mt[N-1]; i=1; }
  114.     }
  116.     mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
  117. }
  119. /* generates a random number on [0,0xffffffff]-interval */
  120. unsigned long genrand_int32(void)
  121. {
  122.     unsigned long y;
  123.     static unsigned long mag01[2]={0x0UL, MATRIX_A};
  124.     /* mag01[x] = x * MATRIX_A  for x=0,1 */
  126.     if (mti >= N) { /* generate N words at one time */
  127.         int kk;
  129.         if (mti == N+1)   /* if init_genrand() has not been called, */
  130.             init_genrand(5489UL); /* a default initial seed is used */
  132.         for (kk=0;kk<N-M;kk++) {
  133.             y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
  134.             mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
  135.         }
  136.         for (;kk<N-1;kk++) {
  137.             y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
  138.             mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
  139.         }
  140.         y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
  141.         mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
  143.         mti = 0;
  144.     }
  146.     y = mt[mti++];
  148.     /* Tempering */
  149.     y ^= (y >> 11);
  150.     y ^= (y << 7) & 0x9d2c5680UL;
  151.     y ^= (y << 15) & 0xefc60000UL;
  152.     y ^= (y >> 18);
  154.     return y;
  155. }
  157. /* generates a random number on [0,1]-real-interval */
  158. double genrand_real1(void)
  159. {
  160.     return genrand_int32()*(1.0/4294967295.0);
  161.     /* divided by 2^32-1 */
  162. }
  165. double cndev(double u)
  166. {
  167. static double a[4]={2.50662823884,-18.61500062529,41.39119773534,-25.44106049637};
  168. static double b[4]={-8.47351093090,23.08336743743,-21.06224101826,3.13082909833};
  169. static double c[9]={0.3374754822726147,0.9761690190917186,0.1607979714918209,0.0276438810333863,
  170.  0.0038405729373609,0.0003951896511919,0.0000321767881768,0.0000002888167364,0.0000003960315187};
  171. double x,r;
  172. x=u-0.5;
  173. if (fabs(x)<0.42)
  174. {
  175.  r=x*x;
  176.  r=x*(((a[3]*r+a[2])*r+a[1])*r+a[0])/((((b[3]*r+b[2])*r+b[1])*r+b[0])*r+1.0);
  177.  return(r);
  178. }
  179. r=u;
  180. if(x>0.0)
  181.  r=1.0-u;
  182. r=log(-log(r));
  183. r=c[0]+r*(c[1]+r*(c[2]+r*(c[3]+r*(c[4]+r*(c[5]+r*(c[6]+r*(c[7]+r*c[8])))))));
  184. if(x<0.0)
  185.  r=-r;
  186. return(r);
  187. }


 
Normalement à chaque fois que je compile je dois tomber sur une nouvelle valeur, mais là c'a à l'aire de garder la même valeur. J'ai remarqué par contre que si je mettai pour autant un :
init_genrand(n) avec n un nombre que je chose à chaque fois avant que je compile, cela change le résultat!
 

Code :
  1. ReturnMatrix simind(const int& nbre_noms)
  2. {
  3. //créer une matrice colonne epsilon
  4. ColumnVector epsilon;
  5. //redimensionne la matrice espsilon avec la dimension correpondante  
  6. //au nombre de titre
  7. epsilon.ReSize(nbre_noms);
  8. //générateur de loie normale
  9. for (int i=1;  i<=nbre_noms; ++i)
  10. { 
  11.  init_genrand(n)
  12.               epsilon(i)= normal_random();
  13. }


 
Décidement, c'est bien compliqué le C++

Reply

Marsh Posté le 09-08-2006 à 18:16:56    

Les méthodes aléatoires c'est pas si compliqué : ce sont en fait des suite récurentes du type
 
Un+1 = (Un^6) % un grand chiffre premier;
 
enfin mon exemple est peut être (sûrement  :D ) bidon Mais l'idée c'est que c'est une suite. Donc tu doit d'initialiser a partir d'une certaine valeur et ensuite tu obtient des nombres pseudo aléatoire. C'est pour cela que tu as toujours les même nombres : tu part du même premier terme et les autres sont calculé par récurrence a partir du premier...
 
L'idée si tu veut avoir des résultats différents a chaque exécution serait de l'initialiser a partir d'un chiffre obtenu a partir de l'horloge de l'ordi. Comme ça a chaque fois que tu exécute ton prog tu a un point de départ différent pour ta suite et donc des résultats différents.

Message cité 1 fois
Reply

Marsh Posté le 09-08-2006 à 18:36:41    

Amonchakai a écrit :

Les méthodes aléatoires c'est pas si compliqué : ce sont en fait des suite récurentes du type
 
Un+1 = (Un^6) % un grand chiffre premier;
 
enfin mon exemple est peut être (sûrement  :D ) bidon Mais l'idée c'est que c'est une suite. Donc tu doit d'initialiser a partir d'une certaine valeur et ensuite tu obtient des nombres pseudo aléatoire. C'est pour cela que tu as toujours les même nombres : tu part du même premier terme et les autres sont calculé par récurrence a partir du premier...
 
L'idée si tu veut avoir des résultats différents a chaque exécution serait de l'initialiser a partir d'un chiffre obtenu a partir de l'horloge de l'ordi. Comme ça a chaque fois que tu exécute ton prog tu a un point de départ différent pour ta suite et donc des résultats différents.


 
 
Merci pour ces explications,C'est plus clair maintenant.
Jstement cette fonction qui me permetterait de récuperer l'horloge de l'ordi, je pensais que c'était la fonction init_genrand(n) ais comme elle prend en argument un entier c pas possible.
Une telle fonction doit être sans argument apparamment, non?
Sauras tu quelle fonction utiliser?
Peut être qu'elle figure déjà dans le code que j'ai intégré dans mon dernier message?

Reply

Marsh Posté le 09-08-2006 à 19:17:48    

c'est justement le n de init_genrand(n) qu'on choisit généralement sur la base de l'horloge de l'ordi.
En général, j'utilise la fonction C time().
 
man 2 time

Message cité 1 fois

---------------
TriScale innov
Reply

Marsh Posté le 10-08-2006 à 10:44:16    

franceso a écrit :

c'est justement le n de init_genrand(n) qu'on choisit généralement sur la base de l'horloge de l'ordi.
En général, j'utilise la fonction C time().
 
Merci franseco pour ton aide, ça marche maintenant j'utiliser pour ça la fonction time() que tu m'as montré

Code :
  1. init_genrand(time(NULL));


 
En fait c'est quoi le site que tu m'as montré ???, il est un peu bizarre à quoi sert la photo et c'est quoi man??
 
man 2 time


Message cité 1 fois
Reply

Marsh Posté le 10-08-2006 à 10:50:34    

"man" c'est pour avoir la doc de quelque chose dans les *nix

Reply

Marsh Posté le 10-08-2006 à 10:57:32    

iamora a écrit :

En fait c'est quoi le site que tu m'as montré ???, il est un peu bizarre à quoi sert la photo et c'est quoi man??

Bah la photo, je suppose que c'est pour faire joli :spamafote:
 
"man", c'est l'abbréviation de "manuel". Il s'agit au départ d'une commande présente dans les unixoides pour donner de la documentation sur les fonctions C et les commandes que tu peux taper dans un terminal. Les pages de man sont toutes écrites de la même façon, et constituent une source centrale de documentation de référence. La plupart des pages de man sont aussi disponible sur internet sur le genre de site que je t'ai montré (donc la prochaine fois que tu te demandes comment utiliser une fonction C, tu peux essayer de taper 'man printf' (par exemple) dans google pour voir ce qui sort).


---------------
TriScale innov
Reply

Marsh Posté le 10-08-2006 à 10:59:59    

'man 3 time' plutot ?

Message cité 1 fois
Reply

Marsh Posté le 10-08-2006 à 11:04:54    

skelter a écrit :

'man 3 time' plutot ?


> man 3 time
No entry for time in section 3 of the manual


---------------
TriScale innov
Reply

Marsh Posté le 10-08-2006 à 11:06:36    

OK!
Merci pour ces infos les gars, ça me sera surement utile par la suite.
L'opérateur << est certes puissant dans le code que je vous ai transmis et que tu as corrigé franseco, je voudrais faire une petit changement d'affichage, mais je me rends compte que c'est impossibel :

Code :
  1. /* affichage pour tester */
  2. for( int i=1 ; i<=dim ; ++i )
  3. { 
  4. for( int j=1 ; j<=dim ; ++j )
  5. {   
  6. std::cout << setw(10) << covariance(i,j); 
  7. } 
  8. std::cout << std::endl;
  9. }


 
C'était pour afficher ma matraice de covariance, seulement  moi je ne voudrais pas d'espace au début de chaque ligne, alors je me suis dis en faisant ça :

Code :
  1. std::cout << covariance(i,j)  << setw(10);


Mais non ça ne marche pas, il le fait bien pour la première ligne mais pas pour les autres lignes qui suivent puisq'ils laissent un espace au début de chaque nouvelle ligne??
 
Peut être qu'avec l'opérateur << de sortie c'est pas possible de réaliser ce que je veux non?
 

Message cité 1 fois
Reply

Marsh Posté le 10-08-2006 à 11:14:28    

iamora a écrit :

Peut être qu'avec l'opérateur << de sortie c'est pas possible de réaliser ce que je veux non?

Si si, c'est possible !
Essaie de comprendre le fonctionnement des manipulateurs. En particulier, essaie de comprendre pourquoi tu as un espace en début de chaque ligne, et pourquoi ta solution ne marche pas. Si tu n'y arrives pas, on te proposera une solution, mais il est important que tu arrives à trouver les informations par toi même.
 
EDIT: Cf  le post d'Elmoricq sur les histoires de poissons et de canne à pêche

Message cité 1 fois
Message édité par franceso le 10-08-2006 à 11:16:41

---------------
TriScale innov
Reply

Marsh Posté le 10-08-2006 à 11:33:17    

franceso a écrit :

Si si, c'est possible !
Essaie de comprendre le fonctionnement des manipulateurs. En particulier, essaie de comprendre pourquoi tu as un espace en début de chaque ligne, et pourquoi ta solution ne marche pas. Si tu n'y arrives pas, on te proposera une solution, mais il est important que tu arrives à trouver les informations par toi même.
 
Pas mal l'histoire,
Mais je dois dire que tu as bien raison, j'essaierai de trouver seul !
 
EDIT: Cf  le post d'Elmoricq sur les histoires de poissons et de canne à pêche


Reply

Marsh Posté le 10-08-2006 à 11:42:59    

Code :
  1. /* affichage pour tester la matrice de cholesky */
  2. for( int i=1 ; i<=dim ; ++i )
  3. { 
  4. for( int j=1 ; j<=dim ; ++j )
  5. {   
  6. if (j==1)
  7. std::cout << C(i,j); 
  8. else
  9. {
  10. std::cout << setw(12) << C(i,j); 
  11.  } 
  12. } 
  13.     std::cout << std::endl;
  14. }


 
C'est mieux comme ça non?

Reply

Marsh Posté le 10-08-2006 à 14:45:23    

C'est effectivement l'une des solutions. Bravo !

Message cité 1 fois

---------------
TriScale innov
Reply

Marsh Posté le 10-08-2006 à 15:07:33    

franceso a écrit :

C'est effectivement l'une des solutions. Bravo !


Je pense que l'énigme suivante est plus diffcile et malgrès que je me suis planché la-dessus assez longtemps je bloque, je pense que j'ai besoin d'aide cette fois.
Voilà le but de mon programme est le suivant :
 
1) récupérer une matrice de variance-covariance depuis un fichier .txt  (étape faite et testée)
 
Le fichier .txt a la forme suivante:

Code :
  1. 6
  2. 3.06E-01
  3. 1.83E-02 4.42E-02
  4. 6.33E-03 2.98E-03 3.11E-02
  5. 1.88E-04 1.88E-04 1.88E-04 6.25E-04
  6. 1.29E-02 1.36E-02 -5.03E-04 1.88E-04 9.51E-02
  7. 4.49E-03 2.91E-02 6.50E-03 1.88E-04 3.05E-02 2.27E-01


 

Code :
  1. //fichier main principal
  2. #include "essai.h"
  3. #include <iostream>
  4. #include <sstream>
  5. #include <fstream>
  6. #include <iomanip>
  7. #include <string>
  10. using namespace std;
  14. int main()
  15. {
  18. ifstream fichierEntree("D:\\Documents and Settings\\AMOR\\Desktop\\VaRaction\\covariance.txt", ios::in);
  19. int dim;
  20. fichierEntree >> dim;
  21. ArrayLengthSpecifier dimension(dim);
  22. SymmetricMatrix covariance(dimension);
  23. /* lecture de la matrice */
  24. for( int i=1 ; i<=dim ; ++i )
  25. { 
  26. for( int j=1 ; j<=i ; ++j ) 
  27. {   
  28. double val;   
  29. fichierEntree >> val;   
  30. covariance(i,j) = val; 
  31. }
  32. }
  33. fichierEntree.close();


 
2) Traiter la matrice récupérée, cette étape se fait sous deux sous-étapes :
 
2-1) Appliquer une fonction nommée chol (cette fonction réalise la décomposition de Cholesky) Cette fonction c'est moi qui l'ai codée et elle est en annexe en à la fin de mon message (étape faite et testée)
 

Code :
  1. //décompose la matrice de covariance suivant cholesky
  2. int nbre_simul;
  3. Matrix C;
  4. C = chol(covariance);


 
2-2) étape ou je bloque:
 
2-2-1) Prendre la matrice transformée par la fonction Chol puis la multiplier par un vecteur de variable aléatoire normale généré par la fonction simind, dont mainteant tu connais la fonction:
simind : retourne à partir d'un générateur de nombre entre 0 et 1, la valeur correspondante à une variable normale
 
(étape ok)  
 
2-2-2) Mon but dans cet étape que je n'arrive pas à réaliser construire dans une matrice de dimension (nombre_simul, dim_vecteur généré) ou bien entendu la ligne i représente le produit de la matrice issue de la fonction chol par un vecteur dont les composantes sont générés aléatoirement.
Bien sur chaque ligne i représente une nouvelle simulation .
 
voici ce que j'ai codé et qui me semble être un début mais ça bloque pour des raisons que je ne comprend pas !
 
 

Code :
  1. //décompose la matrice de covariance suivant cholesky
  2. int nbre_simul;
  3. Matrix C;
  4. C = chol(covariance);
  6. //saisie du nombre de simulation
  7. cout << "Veuillez saisir le nombre de simulations souhaitees : ";
  8. cin >> nbre_simul;
  9. // définie la matrice de sortie  
  10. Matrix simul_epsilon (nbre_simul,dim);
  11.  
  12. for( int i=1 ; i<=nbre_simul ; i++ )
  13. {
  14. for( int j=0 ; j=dim ; ++j )
  15. {
  16. //génère un vecteur colonne de variable normale
  17. ColumnVector E;
  18. E = simind (dim);
  19. std::cout << E(1) << std::endl;
  20. //multiplie la matrice de cholesky par le vecteur de varibles normales (simulation d'un vecteur normale)
  21. ColumnVector epsilon_correl;
  22. epsilon_correl = C * E;
  23. std::cout << epsilon_correl(0) << std::endl;
  24.     //std::cout << epsilon_correl(2) << std::endl;
  25. simul_epsilon(i,j) = epsilon_correl(j);
  26. }
  27. }
  29. /* affichage pour tester la matrice de cholesky */
  30. for( int i=1 ; i<=dim ; ++i )
  31. { 
  32. for( int j=1 ; j<=dim ; ++j )
  33. {   
  34. if (j==1)
  35. std::cout << C(i,j); 
  36. else
  37.   {
  38. std::cout << " " << C(i,j); 
  39.   } 
  40. } 
  41.     std::cout << std::endl;
  42. }
  45. /* affichage pour tester la matrice simul_epsilon */
  46. for( int i=1 ; i<=dim ; ++i )
  47. { 
  48. for( int j=1 ; j<=dim ; ++j )
  49. {   
  50. if (j==1)
  51. std::cout << simul_epsilon(i,j); 
  52. else
  53.   {
  54. std::cout << " " << simul_epsilon(i,j); 
  55.   } 
  56. } 
  57.     std::cout << std::endl;
  58. }
  60. /* affichage pour tester la génération d'une variable normale*/
  61. //std::cout << E(1) << std::endl;  
  62. /* affichage pour tester la matrice de epsilon correl */
  63. //std::cout << epsilon_correl(1) << std::endl;  
  65. //écriture de la matrice de Cholesky transformée dans un fichier .txt  
  67. ofstream fichierSortie("C:\\Matrice de cholesky transformée.txt",ios::out);
  68. if (!fichierSortie)
  69. {
  70.  cerr << "Création du fichier impossible" << endl;
  71.  exit(1);
  72.     }
  73. for (int i=1;i<=dim;i++)
  74. { 
  75. for (int j=1;j<=i;j++)
  76. {   
  77. if (j==1)
  78. fichierSortie << C(i,j);
  79. else
  80.   {
  81.   fichierSortie <<  " " << C(i,j);                           
  82.   }
  83. }
  84. fichierSortie << endl;
  85. }
  87. return 0;
  89. }


 
code pour la fonction simind et chol
 

Code :
  1. // Il s'agit du fichier DLL principal.
  3. #include "stdafx.h"
  5. #include "CorrelSimul.h"
  7. ReturnMatrix chol(const SymmetricMatrix& correlation)
  8. {
  9. //renvoie la dimension de la matrice de corrélation
  10. ArrayLengthSpecifier dimension(correlation.Nrows());
  11. int dimension1 = correlation.Nrows();
  12. //initialise le test de défini positivité à faux
  13. bool test=false;
  14. //diagonalise la matrice de corrélation
  15. DiagonalMatrix D(dimension);
  16. Matrix V(dimension1,dimension1);
  17. LowerTriangularMatrix L(dimension);
  18. Matrix resultat;
  19. //renvoie les valeurs propres
  20. EigenValues(correlation,D,V);
  21. //
  22. if (D(1)<=0) test=true;
  24. if (test=false)
  25. {
  26.  L = Cholesky(correlation);
  27.  resultat=L;
  28. }
  29. else
  30. {
  31.  for (int i = 1; i <= dimension1; i++)
  32.  {
  33.   D(i)=sqrt(max(D(i),0)); /* on transforme D en D+ puis en (D+)^1/2  
  34.         pour prendre la racine carrée */
  35.  }
  37.   resultat = V*D*V.t();
  40. }
  42. D.Release();
  43. V.Release();
  44. L.Release();
  45. return resultat;
  46. }
  48. ReturnMatrix simind(const int& nbre_noms)
  49. {
  50. //créer une matrice colonne epsilon
  51. ColumnVector epsilon;
  52. //redimensionne la matrice espsilon avec la dimension correpondante  
  53. //au nombre de titre
  54. epsilon.ReSize(nbre_noms);
  55. //générateur de loie normale
  56. for (int i=1;  i<=nbre_noms; ++i)
  57. { 
  58.  init_genrand(time(NULL));
  59.  epsilon(i)= normal_random();
  60. }
  61. epsilon.Release();
  62. return epsilon;
  63. }


Message édité par iamora le 10-08-2006 à 15:47:48
Reply

Marsh Posté le 10-08-2006 à 15:51:58    

plusieurs remarques :
 
1- il faut initialiser la graine de ton générateur alatoire une seule fois au début du programme (par exemple dans la fonction main()).
 
2- dans chol(), je ne vois pas trop l'intéret de la variable booléenne temporaire test
 
3- tu devrais faire une fonction qui affiche une matrice, plutôt que de faire du copier/coller de code
 
4- tel quel, ton code ne doit sûrement pas compiler : la variable E est locale à la boucle du haut, mais tu demandes de l'afficher en dehors de cette boucle
 
5- tu as à mon avis un gros problème dans ta première double boucle : tel que tu es en train de le faire, tu génères un nouveau vecteur aléatoire pour chaque couple (i,j), ce qui veut dire qu'au final tu auras généré dim x nbre_simul vecteurs alatoires. Ceci ne semble pas cohérent avec le fait que chaque vecteur aléatoire est censé reprsenter une simulation.
D'après ce que j'ai compris (arrête moi si je me trompe), C est la transformation de Choleski de la matrice correlation. Donc C est de dimension dim.
Une 'simulation' est modélisée par un produit entre la matrice C et un vecteur E de dim variables alatoires indpendantes et identiquement distribues selon une loi normale. Le résultat d'une simulation epsilon_correl est donc un vecteur de dimension dim.
Tu ranges tes nbre_simul résultats de simulation en lignes dans une matrice simul_epsilon, qui est donc de dimension (nbre_simul, dim)
 
Dans ce cas, ta première double boucle devrait s'écrire :

Code :
  1. ColumnVector E;
  2. ColumnVector epsilon_correl;
  3. for(int i=1 ; i<=nbre_simul ; ++i )
  4. {
  5.   E = imind(dim);
  6.   epsilon_correl = C * E; 
  8.   for(int j=1 ; j<=dim ; ++j )
  9.   {
  10.     simul_epsilon(i,j) = epsilon_correl(j);
  11.   }
  12. }


 
6- tu as un problème dans les dimensions de tes matrices utilisées pour l'affichage


---------------
TriScale innov
Reply

Marsh Posté le 10-08-2006 à 16:23:03    

[quotemsg=1423777,26,383694]plusieurs remarques :
 
Merci, encore une fois tes indications sont trés clairs, et j'ajouterai que tu connais trés bien le sujet.  
Pour le point 5, de ton précédent message, je n'avais pas fait attention effectivement mais j'ai bien redimensionner ma matrice.
Après l'application de tes conseils voilà le code que j'obtiens et qui marche!
 

Code :
  1. //fichier main principal
  2. #include "essai.h"
  3. #include <iostream>
  4. #include <sstream>
  5. #include <fstream>
  6. #include <iomanip>
  7. #include <string>
  10. using namespace std;
  14. int main()
  15. {
  16. //initialise la graine du générateur de variable normale  
  17. init_genrand(time(NULL));
  18. ifstream fichierEntree("D:\\Documents and Settings\\AMOR\\Desktop\\VaRaction\\covariance.txt", ios::in);
  19. int dim;
  20. fichierEntree >> dim;
  21. ArrayLengthSpecifier dimension(dim);
  22. SymmetricMatrix covariance(dimension);
  23. /* lecture de la matrice */
  24. for( int i=1 ; i<=dim ; ++i )
  25. { 
  26. for( int j=1 ; j<=i ; ++j ) 
  27. {   
  28. double val;   
  29. fichierEntree >> val;   
  30. covariance(i,j) = val; 
  31. }
  32. }
  33. fichierEntree.close();
  36. //décompose la matrice de covariance suivant cholesky
  37. Matrix C;
  38. C = chol(covariance);
  39. int nbre_simul;
  40. ColumnVector E;
  41. ColumnVector epsilon_correl;
  45. //saisie du nombre de simulation
  46. cout << "Veuillez saisir le nombre de simulations souhaitees : ";
  47. cin >> nbre_simul;
  48. // définie la matrice de sortie  
  49. Matrix simul_epsilon (nbre_simul,dim);
  50. for(int i=1 ; i<=nbre_simul ; ++i )
  51. { 
  52. E = simind(dim); 
  53. epsilon_correl = C * E;   
  54. for(int j=1 ; j<=dim ; ++j )
  55. {   
  56. simul_epsilon(i,j) = epsilon_correl(j); 
  57. }
  58. }
  60. std::cout << simul_epsilon(4,4) << std::endl;
  63. /* affichage pour tester la matrice de cholesky */
  64. for( int i=1 ; i<=dim ; ++i )
  65. { 
  66. for( int j=1 ; j<=dim ; ++j )
  67. {   
  68. if (j==1)
  69. std::cout << C(i,j); 
  70. else
  71.   {
  72. std::cout << " " << C(i,j); 
  73.   } 
  74. } 
  75.     std::cout << std::endl;
  76. }
  79. /* affichage pour tester la matrice simul_epsilon */
  80. for( int i=1 ; i<=nbre_simul ; ++i )
  81. { 
  82. for( int j=1 ; j<=dim ; ++j )
  83. {   
  84. if (j==1)
  85. std::cout << simul_epsilon(i,j); 
  86. else
  87.   {
  88. std::cout << " " << simul_epsilon(i,j); 
  89.   } 
  90. } 
  91.     std::cout << std::endl;
  92. }
  95. //écriture de la matrice de Cholesky transformée dans un fichier .txt  
  97. ofstream fichierSortie("C:\\Matrice de cholesky transformée.txt",ios::out);
  98. if (!fichierSortie)
  99. {
  100.  cerr << "Création du fichier impossible" << endl;
  101.  exit(1);
  102.     }
  103. for (int i=1;i<=dim;i++)
  104. { 
  105. for (int j=1;j<=i;j++)
  106. {   
  107. if (j==1)
  108. fichierSortie << C(i,j);
  109. else
  110.   {
  111.   fichierSortie <<  " " << C(i,j);                           
  112.   }
  113. }
  114. fichierSortie << endl;
  115. }
  117. return 0;
  119. }


 
Cependant comme tu commence à me donner goût à la rigueur en C++ je suis tout à fait d'accord avec toi pour representer les choses dans une fonction comme réalisée pour chol et simind.
J'arrange cette fonction et si tu n'y voi pas d'incovénient je te la montre pour me dire si c'est ok???


Message édité par iamora le 10-08-2006 à 17:39:14
Reply

Marsh Posté le 10-08-2006 à 16:54:02    

Voilà la fonction que j'ai composé !
Elle s'apelle simcor, je te fournis tout mon fichier ou sont définies mes fonctions
 

Code :
  1. // Il s'agit du fichier DLL principal.
  3. #include "stdafx.h"
  5. #include "CorrelSimul.h"
  7. ReturnMatrix chol(const SymmetricMatrix& correlation)
  8. {
  9. //renvoie la dimension de la matrice de corrélation
  10. ArrayLengthSpecifier dimension(correlation.Nrows());
  11. int dimension1 = correlation.Nrows();
  12. //initialise le test de défini positivité à faux
  13. bool test=false;
  14. //diagonalise la matrice de corrélation
  15. DiagonalMatrix D(dimension);
  16. Matrix V(dimension1,dimension1);
  17. LowerTriangularMatrix L(dimension);
  18. Matrix resultat;
  19. //renvoie les valeurs propres
  20. EigenValues(correlation,D,V);
  21. //
  22. if (D(1)<=0) test=true;
  24. if (test=false)
  25. {
  26.  L = Cholesky(correlation);
  27.  resultat=L;
  28. }
  29. else
  30. {
  31.  for (int i = 1; i <= dimension1; i++)
  32.  {
  33.   D(i)=sqrt(max(D(i),0)); /* on transforme D en D+ puis en (D+)^1/2  
  34.         pour prendre la racine carrée */
  35.  }
  37.   resultat = V*D*V.t();
  40. }
  42. D.Release();
  43. V.Release();
  44. L.Release();
  45. return resultat;
  46. }
  48. ReturnMatrix simind(const int& nbre_noms)
  49. {
  50. //créer une matrice colonne epsilon
  51. ColumnVector epsilon;
  52. //redimensionne la matrice espsilon avec la dimension correpondante  
  53. //au nombre de titre
  54. epsilon.ReSize(nbre_noms);
  55. //générateur de loie normale
  56. for (int i=1;  i<=nbre_noms; ++i)
  57. { 
  59.  epsilon(i)= normal_random();
  60. }
  61. epsilon.Release();
  62. return epsilon;
  63. }
  66. ReturnMatrix simcor(const int& nbre_simul, const int& dim, const SymmetricMatrix& covariance)
  67. {
  69. //décompose la matrice de covariance suivant cholesky
  70. Matrix C;
  71. C = chol(covariance);
  73. //définie le vecteur de variables aléatoires normales
  74. ColumnVector E;
  76. //définie le vecteur issue de la multiplication de E et C
  77. ColumnVector epsilon_correl;
  79. // définie la matrice de sortie  
  80. Matrix simul_epsilon (nbre_simul,dim);
  82. for(int i=1 ; i<=nbre_simul ; ++i )
  83. { 
  84. E = simind(dim); 
  85. epsilon_correl = C * E;   
  86. for(int j=1 ; j<=dim ; ++j )
  87. {   
  88. simul_epsilon(i,j) = epsilon_correl(j); 
  89. }
  90. }
  92. C.Release();
  93. E.Release();
  94. epsilon_correl.Release();
  95. simul_epsilon.Release();
  98. return simul_epsilon;
  99. }


 
Puis voilà mon fichier principal ou j'utilise la fonction  
 

Code :
  1. //fichier main principal
  2. #include "essai.h"
  3. #include <iostream>
  4. #include <sstream>
  5. #include <fstream>
  6. #include <iomanip>
  7. #include <string>
  10. using namespace std;
  14. int main()
  15. {
  16. //initialise la graine du générateur de variable normale  
  17. init_genrand(time(NULL));
  18. ifstream fichierEntree("D:\\Documents and Settings\\AMOR\\Desktop\\VaRaction\\covariance.txt", ios::in);
  19. int dim;
  20. fichierEntree >> dim;
  21. ArrayLengthSpecifier dimension(dim);
  22. SymmetricMatrix covariance(dimension);
  23. /* lecture de la matrice */
  24. for( int i=1 ; i<=dim ; ++i )
  25. { 
  26. for( int j=1 ; j<=i ; ++j ) 
  27. {   
  28. double val;   
  29. fichierEntree >> val;   
  30. covariance(i,j) = val; 
  31. }
  32. }
  33. fichierEntree.close();
  36. //saisie du nombre de simulation
  37. int x;
  38. cout << "Veuillez saisir le nombre de simulations souhaitees : ";
  39. cin >> x;
  41. //définie la matrice de sortie
  42. Matrix sortie;
  43. sortie = simcor(x, dim, covariance);
  45. std::cout << sortie(4,4) << std::endl;
  48. return 0;
  50. }


 
Normalement ça devrait marcher, mais j'ai un message d'erreur le compilateur me dit que  

Code :
  1. essai.cpp(43) : error C2660: 'simcor' : la fonction ne prend pas 3 arguments


 
Ce que je trouve bizarre puisque j'ai bien définie une fonction à trois arguments???


Message édité par iamora le 11-08-2006 à 10:37:39
Reply

Marsh Posté le 11-08-2006 à 10:56:42    

Oui, ce que tu as écrit me semble pas mal. Tu devrais peut-être encapsuler le code d'input de la matrice dans une fonction : ça rendrait les choses plus claires et plus llisibles.
 
Concernant ton erreur de compilation, tu n'as pas de messages de warnings autour de ton erreur ? As-tu défini les prototypes de tes fonctions dans un fichier d'en-tête ? As-tu inclus le fichier d'en-tête en question dans ton programme principal ?

Message cité 1 fois

---------------
TriScale innov
Reply

Marsh Posté le 11-08-2006 à 11:05:57    

franceso a écrit :

Oui, ce que tu as écrit me semble pas mal.  
Bonjour,  
 
Tu devrais peut-être encapsuler le code d'input de la matrice dans une fonction : ça rendrait les choses plus claires et plus llisibles.
 
Je ne sais pas ce que veux dire le terme encapsuler un code (je suis encore débutant, j'apprend sur le tas...)
 
Concernant ton erreur de compilation, tu n'as pas de messages de warnings autour de ton erreur ?  
Non pas de warning, la seule erreure que j'ai est celle que je t'ai envoyé !
 
As-tu défini les prototypes de tes fonctions dans un fichier d'en-tête ?
Encore une fois et je suis désolén mais je ne comprend pas ce que sont les prototypes de fonction??, est ce les includes???
 
As-tu inclus le fichier d'en-tête en question dans ton programme principal ?


 
En fait voici mon fichier d'en-tête précompilé stadfx.h, je ne sais pas si il faut mettre la dedans comme mis en commentaire les fonctions que j'ai codé dans le fichier correl_simul.cpp.
Mais apparament non puisque ça marche sans ??
 

Code :
  1. // stdafx.h : Fichier Include pour les fichiers Include système standard,
  2. // ou les fichiers Include spécifiques aux projets qui sont utilisés fréquemment,
  3. // et sont rarement modifiés
  5. #define WINVER 0x400
  7. #pragma once
  9. #include <Afx.h>
  10. #include <afxdisp.h>
  11. #include <afxwin.h>
  12. #include <algorithm>
  13. #include <numeric>
  14. #include <fstream>
  15. #include <vector>
  16. #include <time.h>
  17. #include <math.h>
  18. #include <iostream>
  19. #include <tchar.h>
  20. #include <stdlib.h>
  21. #include <stdio.h>
  22. #include <string.h>
  23. #include <vector>
  24. #include "newmat\NEWMATAP.h"
  25. #include "newmat\NEWMAT.h"
  26. #include "newmat\myexcept.h"
  29. using namespace std;
  31. void init_genrand(unsigned long s);
  32. void init_by_array(unsigned long init_key[], int key_length);
  33. unsigned long genrand_int32(void);
  34. double genrand_real1(void);
  35. double random_0_1(void);
  36. double cndev(double u);
  37. double N(const double& z);
  38. double normal_random();
  39. double box_muller();
  40. double n(const double& z);
  41. double lognormal_random();
  42. /*ReturnMatrix cholesky (const SymmetricMatrix& S);*/
  43. //ReturnMatrix simind(const int& nbre_noms)
  44. /*ReturnMatrix simcor(const int& nbre_simul, const int& dim, const SymmetricMatrix& covariance);*/


 
 

Reply

Marsh Posté le 11-08-2006 à 11:15:50    

Je ne sais pas trop comment marchent les headers précompilés (je suppose que tu es sous VC++ ou quelque chose du genre ?). Essaie peut-être de te documenter dans ce sens la...
 
Sinon, que contiennent tes headers "essai.h" et "CorrelSimul.h" ?

Message cité 1 fois

---------------
TriScale innov
Reply

Marsh Posté le 11-08-2006 à 11:25:27    

Ne fait pas attention au début de ce message,regarde la fin c'est peut être la raison de mon erreur,
 
 
 

franceso a écrit :

Je ne sais pas trop comment marchent les headers précompilés (je suppose que tu es sous VC++ ou quelque chose du genre ?). Essaie peut-être de te documenter dans ce sens la...
 
Sinon, que contiennent tes headers "essai.h" et "CorrelSimul.h" ?


OK
Je suis sous Visualstudio.net 2003.
Je suis en mode release et dans les proporiétés de mon projet sous entêtes précompilés je compile avec l'option :  
Générer automatiquement (/YX)
Normalement ça ne devrait pas posé mon problème .
Un ami me dit que c'est peut être du au fait que ma fonction est définie avec un ReturnMatrix et que j'initialise sortie à Matrix dans le fichier priniicpal, mais je doute que ça soit la raison puisqu'avant ça marchait pour la fonction chol définie avec ReturnMatrix et renvoyant un resultat dans le fichier principal dans une variable déclarée comme Matrix
Matrix C;
C = chol(covariance);
 
En tout cas voilà le fichier "essai.h"  
 

Code :
  1. #include "stdafx.h"
  2. #include "CorrelSimul.h"


 
et le fichier correlsimul.h

Code :
  1. // CorrelSimul.h
  2. //Specifies that the file will be included (opened) only once by the compiler in a build.  
  3. //This can reduce build times as the compiler will not open and read the file
  4. //after the first #include of the module.
  6. //#pragma once
  8. //using namespace System
  10. //namespace CorrelSimul
  12. // public __gc class Class1
  13. // {
  14.  // TODO : ajoutez ici vos méthodes pour cette classe.
  15. // };
  17. ReturnMatrix chol(const SymmetricMatrix& correlation);
  18. ReturnMatrix simind(const int& nbre_noms);
  19. ReturnMatrix simcor(const int& nbre_noms, const double& rho);
  20. ReturnMatrix spreads(const Matrix& lambda, const ColumnVector& T, const Matrix& r, const ColumnVector& sigma, const ColumnVector& defaut,
  21.      const ColumnVector& x, const double& correlation, const int& nbre_noms,const int& no_steps);


 
Ah oui je ne l'ai pas changé la fdéfinition de ma focntion dans le fichier correlsimul.h, erreur de débutant je la change et je tiens au courant  
 
[code]


Message édité par iamora le 11-08-2006 à 11:26:57
Reply

Marsh Posté le 11-08-2006 à 11:28:23    


C'était ça l'erreur, la preuve que je ne maitrise pas du tout encore le c++.
Merci pour tes réflexions ça m'a mis sur la voie  
 

Reply

Marsh Posté le 11-08-2006 à 11:41:53    

on est tous passés par là. C'est les erreurs les plus bêtes qui prennent parfois le plus de temps à corriger.
 
De rien


---------------
TriScale innov
Reply

Marsh Posté le 11-08-2006 à 11:53:56    

Franseco, t'es de l'ensta?
Si c'est le cas je peux te demander ton avis sur une question purement technique en mathématiques?
SI ça risque de te gêner t'as qu'à me le dire!

Message cité 1 fois
Reply

Marsh Posté le 11-08-2006 à 12:02:48    

iamora a écrit :

Franseco, t'es de l'ensta?
Oui
 
Si c'est le cas je peux te demander ton avis sur une question purement technique en mathématiques?
Tu peux toujours demander... je ne garantis rien sur la réponse !
 
SI ça risque de te gêner t'as qu'à me le dire!
Pas de prob


Message cité 1 fois

---------------
TriScale innov
Reply

Marsh Posté le 11-08-2006 à 12:05:29    

franceso a écrit :



Donc voilà  
 
Je voudrais comme tu le sais simuler en C++ un vecteur de variables aléatoires normales. Pour cela la méthode conseillée est de générer un vecteur colonne de variables normales, que je noterai [epsilon] puis de le multiplier par la matrice de "Cholesky" qui est une matrice issue de la décomposition de Cholesky de la matrice de variance covariance :
 
[var-covar]=[chol]*[chol]t
 
[var-covar]: est la matrice de variance-covariance
[chol]: est la matrice de Cholesky
[chol]t: est la transposée de la matrice de Cholesky
 
Le problème est que pour que cette décomposition soit juste, il faut que [var-covar] soit définie positive or ce n'est pas toujours mon cas.
Mon objectif est donc de trouver une méthode qui puisse forcer la matrice [var-covar] à devenir une matrice symétrique définie positive.
Pour cela j'ai pensé à diagonaliser [var-covar] puis à remplacer toutes les valeurs propres négatives par des 0 :
 
[var-covar] = [v]-1*[d]*[v]
ou [d] est une matrice diagonale dont les valeurs>0
 
ensuite je prends la racine des éléments de [d], donc diag[di]=di^(1/2).
Puis je dis que la matrice de Cholesky est la suivante  
chol = [v]-1*[d]^(1/2)*[v].
 
Je voudrais savoir si mon raisonnemment est correct, car j'ai un doute sur la validité de ma méthode.

Reply

Marsh Posté le 11-08-2006 à 13:30:34    

Salut !
Bon j'avoue tout de suite je n'y connait rien en matrice de variance-covaiance et Cholesky. Aussi j'ai été voir Google et j'ai trouvé ça :
http://fr.wikipedia.org/wiki/Matri [...] covariance
 
je sais pas si ce qui est dit dans Wikipedia est juste mais visiblement y'a un soucis : Ils disent que la matrice de variance-covariance est Symétrique positive. Donc y'a comme un soucis si tu trouve des Valeurs propre négatives...  :??:  
Ensuite ces valeurs propre (négatives...) tu veut les remplacer par des 0. Déja là tu rend ta matrice positive et PAS définie positive (tes valeurs propre doivent être strictement positive...) donc faudrait les remplacer par un nombre positif != de zéro... Mais moi ce qui me turlupine c'est qu'est-ce qui te donne le doit de changer ta matrice comme ça... Si tu change ses valeurs propre elle n'aurra plus rien a voir avec celle initiale (surtout qu'après tu va la multiplier par les matrices diagonalisantes...) Je sais pas ce que ça va donner sûrement qqch qui n'a rien a voir avec tes résultats initiaux...
 
Et puis juste par curiosité tu fait comment pour trouver les valeurs propres... Moi je chercherai les racines du polynôme caractéristique... Mais c'est du calcul formel : ça se fait bien a la main mais pour le faire faire a un ordinateur... (avec Maple Ok... mais sinon...)
 
[edit] J'espère que tu prend pas mal ma remarque, je veut pas répondre méchament c'est juste que je comprend pas bien ce que tu veut faire  :)  Et si j'ai dit un bêtise excuse moi  :D

Message cité 1 fois
Reply

Marsh Posté le 11-08-2006 à 13:59:26    

Amonchakai a écrit :

je sais pas si ce qui est dit dans Wikipedia est juste mais visiblement y'a un soucis : Ils disent que la matrice de variance-covariance est Symétrique positive. Donc y'a comme un soucis si tu trouve des Valeurs propre négatives...  :??:
Ensuite ces valeurs propre (négatives...) tu veut les remplacer par des 0. Déja là tu rend ta matrice positive et PAS définie positive (tes valeurs propre doivent être strictement positive...) donc faudrait les remplacer par un nombre positif != de zéro... Mais moi ce qui me turlupine c'est qu'est-ce qui te donne le doit de changer ta matrice comme ça... Si tu change ses valeurs propre elle n'aurra plus rien a voir avec celle initiale (surtout qu'après tu va la multiplier par les matrices diagonalisantes...) Je sais pas ce que ça va donner sûrement qqch qui n'a rien a voir avec tes résultats initiaux...


+1
c'est ce qui me paraît être la plus grande faille dans le raisonnement. Tu ne peux pas comme ça décider de changer ta matrice pour qu'elle vérifie les propriétés dont tu as besoin.
 
Il y a aussi un autre problème dans les dernières lignes : à mon avis tu ne peux pas te passer de calculer la décomposition de choleski de ta matrice "transformée". Ton histoire à base de "racine carrée" de la matrice diagonale ne marche pas à mon avis (il suffit de calculer le C x Ct avec l'expression que tu proposes pour voir qu'on ne retombe pas sur la matrice de départ)
 
 

Amonchakai a écrit :

Et puis juste par curiosité tu fait comment pour trouver les valeurs propres... Moi je chercherai les racines du polynôme caractéristique... Mais c'est du calcul formel : ça se fait bien a la main mais pour le faire faire a un ordinateur... (avec Maple Ok... mais sinon...)

Il existe plein de méthodes numériques pour déterminer des valeurs approchées des valeurs propres d'une matrice (par exemple l'algorithme de Jacobi pour les matrices symétriques)


Message édité par franceso le 11-08-2006 à 14:00:08

---------------
TriScale innov
Reply

Marsh Posté le 11-08-2006 à 14:06:43    

Citation :


Il existe plein de méthodes numériques pour déterminer des valeurs approchées des valeurs propres d'une matrice (par exemple l'algorithme de Jacobi pour les matrices symétriques)


 
ha tien je connais pas.... Merci pour l'info je vais voir ça pour ma culture.... :)

Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed