Mes nombres changent tout seul

pom -  
 pom -
Bonjour, j'ai un "drôle" de problème : je me fais un tableau

[code]
double mon_tab[39][7]
[/code]

et une matrice. Je mets tous les éléments de ce tableau dans la matrice. Mon problème est dans le 5e ligne colonne 2 à 7 : les coefficients ont été modifés alors que tous les autres sont inchangés. Savez-vous pourquoi ? Je vous envoie mon code afin que vous puissiez (si vous le pouvez) le compiler. Merci d'avance.

[code]
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef struct t_mat
{
unsigned int nl; // nombre de lignes
unsigned int nc; // nombre de colonnes
double ** data;
} Matrice;

Matrice * alloc_Matrice(unsigned int nl_,unsigned int nc_,double val)
{
// alloue un espace memoire pour creer la matrice m et l'initialise a val

assert( (nl_>=0) && (nc_>=0) );

Matrice * m=malloc(sizeof(Matrice));
assert(m!=NULL);

// une matrice vide est caracterisee par nl=0, nc=0 et data=NULL
if(nl_==0) assert(nc_==0);
if(nc_==0) assert(nl_==0);

if(nl_==0)
{
m->nl=0;
m->nc=0;
m->data=NULL;
}
else
{
m->nl=nl_;
m->nc=nc_;
m->data=malloc(nl_*sizeof(double *));
if(m->data!=NULL)
{
unsigned int i,j;
for(i=0;i<nl_;i++)
{
m->data[i]=malloc(nc_*sizeof(double));
assert(m->data[i]!=NULL);
for(j=0;j<nc_;j++) // initialisation de la matrice
m->data[i][j]=val;
}
}
}

return m;
}

void free_Matrice(Matrice * m)
{
m->nc=0;
m->nl=0;

// libere l'espace memoire
int i;
for(i=0;i<m->nc;i++)
{
if(m->data[i]!=NULL)
{
free(m->data[i]);
m->data[i]=NULL;
}
}
free(m->data);
m->data=NULL;

free(m);
m=NULL;
}

Matrice * Matrice_vide(void)
{
// Cree une matrice vide
Matrice * m=malloc(sizeof(Matrice));
m->nl=0;
m->nc=0;
m->data=NULL;
return m;
}

void affiche_Matrice(Matrice * m)
{
if(m->nc==0) // donc m.nl==0
printf("Matrice vide\n");
else
{
unsigned int i,j;
for(i=0;i<m->nl;i++)
{
for(j=0;j<m->nc;j++)
printf("%7.10g\t",m->data[i][j]);

printf("\n");
}
}
}

void data_thermodynamiques(Matrice * CO1)
{
const double CO1_[39][7]={
{-1.26836187e+00, 8.54355820e-02, -5.25346786e-05, 1.62945721e-08, -2.02394925e-12, -2.56586565e+04, 3.53732912e+01}, // C7H16
{0.03212936E+02, 0.11274864E-02, -0.05756150E-05, 0.13138773E-08, -0.08768554E-11, -0.10052490E+04, 0.06034737E+02}, // O2
{0.03298677E+02, 0.14082404E-02, -0.03963222E-04, 0.05641515E-07, -0.02444854E-10, -0.10208999E+04, 0.03950372E+02}, // N2
{0.03262451E+02, 0.15119409E-02, -0.03881755E-04, 0.05581944E-07, -0.02474951E-10, -0.14310539E+05, 0.04848897E+02}, // CO
{0.02275724E+02, 0.09922072E-01 -0.10409113E-04, 0.06866686E-07, -0.02117280E-10, -0.04837314E+06, 0.10188488E+02}, // CO2
{0.02500000E+02, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.00000000E+00, 0.02547162E+06, -0.04601176E+01}, // H
{0.03298124E+02, 0.08249441E-02, -0.08143015E-05, -0.09475434E-09, 0.04134872E-11, -0.10125209E+04, -0.03294094E+02}, // H2
{0.02946428E+02, -0.16381665E-02, 0.02421031E-04, -0.16028431E-08, 0.03890696E-11, 0.02914764E+06, 0.02963995E+02}, // 0
{0.03386842E+02, 0.03474982E-01, -0.06354696E-04, 0.06968581E-07, -0.02506588E-10, -0.03020811E+06, 0.02590232E+02}, // H2O
{0.03637266E+02, 0.01850910E-02, -0.16761646E-05, 0.02387202E-07, -0.08431442E-11, 0.03606781E+05, 0.13588605E+01}, // OH
{0.02979963E+02, 0.04996697E-01, -0.03790997E-04, 0.02354192E-07, -0.08089024E-11, 0.01762273E+04, 0.09222724E+02}, // HO2
{0.03388753E+02, 0.06569226E-01, -0.14850125E-06, -0.04625805E-07, 0.02471514E-10, -0.01766314E+06, 0.06785363E+02}, // H2O2
{0.07787415E+01, 0.01747668E+00, -0.02783409E-03, 0.03049708E-06, -0.12239307E-10, -0.09825229E+05, 0.13722195E+02}, // CH4
{0.02430442E+02, 0.11124099E-01, -0.01680220E-03, 0.16218288E-07, -0.05864952E-10, 0.16423781E+05, 0.06789794E+02}, // CH3
{0.16527311E+01, 0.12631439E-01, -0.01888168E-03, 0.02050031E-06, -0.08413237E-10, -0.14865404E+05, 0.13784820E+02}, // CH2O
{0.02898329E+02, 0.06199146E-01, -0.09623084E-04, 0.10898249E-07, -0.04574885E-10, 0.04159922E+05, 0.08983614E+02}, // HCO
{-3.79155767e-02, 7.56726570e-02, -4.07473634e-05, 9.32678943e-09, -4.92360745e-13, -2.35605303e+03, 3.37321506e+01}, // C7H15-2
{2.37499334e+00, 8.34651906e-02, -5.13897320e-05, 1.64217662e-08, -2.19505216e-12, -1.99237961e+04, 2.53067342e+01}, // C7H15O2
{2.49875186e+00, 8.32443344e-02, -4.85933986e-05, 1.28927950e-08, -1.09878385e-12, -1.36530733e+04, 2.73754005e+01}, // C7H14O2H
{3.84933185e+00, 9.45955097e-02, -5.94934121e-05, 1.78836457e-08, -2.00618696e-12, -3.32051631e+04, 2.25912030e+01}, // C7H14O2HO2
{4.19023030e+00, 8.43118237e-02, -5.44315814e-05, 1.85837721e-08, -2.72768938e-12, -5.00570382e+04, 1.85783455e+01}, // C7KET21
{2.14479069e+00, 6.17863563e-02, -3.74134690e-05, 1.13283795e-08, -1.36917698e-12, -1.43451172e+04, 2.23128045e+01}, // C5H11CO
{0.014933071E+02, 0.02092517E+00, 0.04486794E-04, -0.016689121E-06, 0.07158146E-10, 0.010748264E+05, 0.01614534E+03}, // C3H6
{-0.08614880E+01, 0.02796162E+00, -0.03388677E-03, 0.02785152E-06, -0.09737879E-10, 0.05573046E+05, 0.02421148E+03}, // C2H4
{0.02690701E+02, 0.08719133E-01, 0.04419838E-04, 0.09338703E-08, -0.03927773E-10, 0.12870404E+05, 0.12138195E+02}, // C2H5
{0.47294595E+01, -0.31932858E-02, 0.47534921E-04, -0.57458611E-07, 0.21931112E-10, -0.21572878E+05, 0.41030159E+01}, // CH3CHO
{3.54885235E+00, 1.78747638E-02, 5.00782825E-05, -7.94475071E-08, 3.35802354E-11, 4.74011588E+03, 1.11849382E+01}, // C4H9
{0.01922537e+02, 0.02478927e+00, 0.01810249e-04, -0.01783266e-06, 0.08582996e-10, 0.09713281e+05, 0.01399271e+03}, // C3H7
{-4.99570406e-01, 8.08826467e-02, -5.00532754e-05, 1.56549308e-08, -1.96616227e-12, -1.04590223e+03, 3.46564011e+01}, // C7H15-1
{3.84933185e+00, 9.45955097e-02, -5.94934121e-05, 1.78836457e-08, -2.00618696e-12, -3.32051631e+04, 2.25912030e+01}, // O2C7H14O2H (== C7H14OOH1-2O2) Li
{-1.498600900E+000, 1.156093450E-001, -9.291669880E-005, 3.832857370E-008, -6.377341630E-012, -3.561937930E+004, 3.888489900E+001}, // OC7H14O-PO2H (==HO2C7H13O2H)
{-3.054845000E-001, 9.619494010E-002, -7.035325810E-005, 2.656930660E-008, -4.097054970E-012, -2.531957790E+004, 3.321248330E+001}, // OC7H13O2H (==OC7H13OOH-n) NASA
{-2.662285120E+000, 9.332588850E-002, -7.030687670E-005, 2.750678370E-008, -4.390600530E-012, -5.694319560E+003, 4.222704190E+001}, // OC7H13O (==OC7H13O-n) NASA
{3.57867617e+00, 3.04236365e-02, 3.27768270e-05, -5.86453147e-08, 2.39315107e-11, -2.60420265e+03, 1.42591121e+01}, // C5H11
{0.02459276E+02, 0.07371476E-01, 0.02109872E-04, -0.13216421E-08, -0.11847838E-11, 0.03335225E+06, 0.11556202E+02}, // C2H3
{2.37499334e+00, 8.34651906e-02, -5.13897320e-05, 1.64217662e-08, -2.19505216e-12, -1.91638565e+04, 2.58351690e+01}, // C7H15O2-1
{0.03200202E+02, 0.02072875E-01, -0.05134431E-04, 0.05733890E-07, -0.01955533E-10, 0.07045259E+06, 0.03331587E+02}, // CH therm.dat
{0.03762237E+02, 0.11598191E-02, 0.02489585E-05, 0.08800836E-08, -0.07332435E-11, 0.04536790E+06, 0.01712577E+02}, // CH2 therm.dat
{0.02106204E+02, 0.07216595E-01, 0.05338472E-04, -0.07377636E-07, 0.02075610E-10, 0.09786011E+04, 0.13152177E+02} // CH3O therm.dat
};

free_Matrice(CO1);
alloc_Matrice(39,7,0.0);
int i,j;
for(i=0;i<39;i++)
for(j=0;j<7;j++)
CO1->data[i][j]=CO1_[i][j];
}

int main()
{

Matrice * CO1=Matrice_vide(); // je suppose que je ne connais pas d'avance la dimension de CO1
data_thermodynamiques(CO1);
affiche_Matrice(CO1);
free_Matrice(CO1);

return 0;
}
[/code]

Si vous regardez bien, la 5e ligne est

[code]
{0.02275724E+02, 0.09922072E-01 -0.10409113E-04, 0.06866686E-07, -0.02117280E-10, -0.04837314E+06, 0.10188488E+02}
[/code]

mais lors de l'affichage j'obtiens :

[code]
2.275724 0.009911662887 6.866686e-09 -2.11728e-12 -48373.14 10.188488 0
[/code]

ce qui est complètement différent !

Avez-vous une idée s'il vous plait ? Merci

5 réponses

mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
 
Merci d'utiliser le bouton "code" pour entourer ton code des balises qui vont bien parce que là c'est dur à lire.

Quelques corrections déjà :
assert( (nl_>=0) && (nc_>=0) );  <-- cette ligne est inutile
 if(nl_==0)  <-- if (nl_ == 0 || nc_==0)
for(i=0;i<nl_;i++) <-- for(i=0;i<nl_;++i) (mieux en terme mémoire) et pareil pour les autres for


Sinon le reste est très bien codé ;)

Pour ce qui est du problème as-tu le problème sur d'autres lignes ? Parce que là je viens de lire ton code je ne vois pas trop ou est l'erreur. Peux-tu afficher en %8.4G (tu changeras après) la matrice et le tableau ?

Bonne chance
0
pom
 
Salut mamiemando, merci de ta réponse.
Tout d'abord quelques questions sur ta réponse
1) pourquoi dis-tu que la ligne assert( (nl_>=0) && (nc_>=0) ); est inutile ? (pour moi, une matrice est vide si nl_==0 ou nc_==0)

2) Ce n'est pas la même chose d'écrire
if(nl_==0) assert(nc_==0);
if(nc_==0) assert(nl_==0);
for(i=0;i<nl_;i++)

et
if (nl_ == 0 || nc_==0)
for(i=0;i<nl_;i++)

car dans le 2e cas, rien ne me certifie (sauf erreur de ma part) que nl_==0 et nc_==0

3) Peux-tu me donner plus d'explications sur ta dernière remarque :
for(i=0;i<nl_;i++) <-- for(i=0;i<nl_;++i) (mieux en terme mémoire) et pareil pour les autres for
ca m'intéresse énormément.

4) question très bête : où se trouvent les balises de code ?

sinon j'ai trouvé mon erreur : dans ma 5e ligne, il me manquait une virgule. C'est pourquoi c'était la seule ligne qui était en défaut.

Merci de tes remarques.

Pom
0
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
 
1) Parce que comme ce sont des unisgned int ils sont forcément tous les deux >= à 0
2) Euh ce n'est pas a cette ligne mais à celle-ci
 if(nl_==0)
{
   m->nl=0;
   m->nc=0;
   m->data=NULL;
}


Rq : (nl_==0 || nc_==0) est vérifié si (nl_==0 && nc_==0)
c'est un ou inclusif en C

3) Pour les for les ++i ou i++ ca fait la même chose, sauf que tu as une référence en moins en mémoire dans le cas de la préincrémentation (en post incrémentation le compilo garde une référence vers la variable i pour pouvoir l'incrémenter en fin de boucle, ce qui n'est pas le cas de la préincrémentation. C'est pourquoi on devrait toujours faire de la préincrémentation quand on a le choix, comme c'est le cas ici)

4) Tu as un bouton code au dessus de la boite de texte. Tu sélectionne le texte et tu cliques dessus.

5) Pour l'erreur de la virgule: bien vu :)

Bon au passage ce que tu fais est nettement plus simple et rapide à faire en C++ mais bon... :) Si ça t'intéresse regarde les classes vector de la STL. La version C++ tient en quelques lignes.

Bonne chance
0
pom
 
Re,
tu dis :
Rq : (nl_==0 || nc_==0) est vérifié si (nl_==0 && nc_==0)
c'est un ou inclusif en C

mais alors qu'elle est la différence entre (nl_==0 || nc_==0) et (nl_==0 && nc_==0) ?

est-ce donc la même chose que de faire

if(nl_==0 || nc_==0) blabla


et

if(nl_==0 && nc_==0)  blabla


Ca me parait bizarre. Je ne dois pas avoir bien compris la nuance.

Pom
0
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
 
Non car si nl==1 et nc==0, la version || est vérifiée mais pas la version &&. Idem avec nl==0 et nc==1.

Tables de vérité (0<->false, 1<->true)
a | b | (a && b)
0 | 0 | 0
0 | 1 | 0
1 | 0 | 0
1 | 1 | 1

a | b | (a || b)
0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1

Voilou :) Maintenant à toi de voir ce que tu veux faire ^^

Bonne chance
0
pom
 
Salut,
Merci encore de ta patience. Je connais mes tables de vérités, mais ce que je voulais vérifier est que si nl==0 alors nc==0 ou si nc==0 alors nl==0

Pom
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
mamiemando Messages postés 33869 Date d'inscription   Statut Modérateur Dernière intervention   7 902
 
Si tu es sûr de ton coup tu fais comme tu le sens. Je te propose aussi de jeter un oeil à une implementation c++ pour les matrices que j'ai faite rapidement hier soir avant de me coucher :

http://www.commentcamarche.net/forum/affich-1907231-produit-matriciel-en-C

Libre à toi d'y greffer les fonctions qui t'arrangent ;)

Bonne chance
0
pom
 
Re,
merci. J'avais déjà lu ton poste (mais je n'avais pas remarqué que c'était toi qui l'avais écrit).

J'ai de quoi m'inspirer effectivement

Merci de ta patience.
Pom
0