Discussion :

[mkrzemin]

Salut à toutes et à tous,

J'avoue que là, j'ai vraiment un os de taille. Pour faire simple: j'ai un programme en C qui lit un fichier de coordonnées cartésiennes.
J'ai pour ce programme deux structures:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
	struct atom
	{
		char name[5];	// residue name
		double x;	// x coordinate
		double y;	// y coordinate
		double z;	// z coordinate
	};
 
	struct residue
	{
		int nb;
		int nb_atoms;
		unsigned short D_nb;
		double *D;
		struct atom ids[25];		// The size is not important; it will be re-scaled
	}

Un résidu a un numéro (nb), et est constitué de plusieurs atomes (nb_atoms), qui ont chacun un nom de 4 caractères (name[5]) et une coordonnées dans l'espace (x, y, z). Et dans mon fichier de coordonnées, j'ai plein de résidus.
D'autre part, dans la structure "residue", D est un tableau de valeurs et D_nb le nombre de données que j'ai pour le résidue en question.

Ensuite, je déclare la variable suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

struct residue residues[500]

Voici le GROS problème que j'ai rencontré:
A chaque fois que j'incrémente la valeur D d'un élément de residues, j'incrémente la valeur D_nb de 1 (Ce tableau est initialisé en tout début). Jusque là, rien d'extraordinnaire, ça donne en gros:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
residues[i].D[k] += K;      // K est un double, i est l'indice du résidu et k l'indice de l'atome
residues[i].D_nb++;        // i est l'indice du résidu

La complication vient maintenant:
Si K est un double, une des valeurs de mon tableau residues[i].D complètement perturbée, comme si la lecture du tableau était érronnée! Par exemple, elle passe de 0 à 13107!!
En revanche; si K est une valeur ronde (8 ou 8.0), tout se passe normalement, tel que je l'avais prévu.

Si quelqu'un a une idée, qu'il (elle) n'hésite pas surtout. Je lui en serai très reconnaissant!

A bientôt,
Mickaël

[diogene]

Comment est créé le tableau D de la struct residue ?

[matafan]

Ton commentaire "The size is not important; it will be re-scaled" m'inquiète. Puisque tu alloues un tableau de struct residue, tu ne peux pas donner à cette structure la taille que tu veux ; elle doit faire la taille déclarée, un point c'est tout.

[mkrzemin]

Salut à tous et merci pour vos premiers commentaires!


1. Pour répondre à diogene, D est créée dynamiquement:

if ((residues[nb_resi].D = (double *) calloc(nb_rdcs, sizeof(double))) == NULL)
{
return; // Problem of memory allocation
}

La variable nb_rdcs correspond au nombre de type de données que j'ai (il est déterminé juste avant).

2. Pour répondre à matafan:
La structure n'est pas re-dimensionnée en fait. Le commentaire avait été mis uniquement lors de la déclaration des variables. Mais, dans un sens, je ne vois quand même pas pourquoi je ne pourrais pas re-dimensionner ce tableau (que ce soit une structure ou non), à condition que je garde quelquepart en mémoire sa taille... Ca permet surtout de minimiser l'espace alloué, en particulier quand le nombre de données à enregistrer est gargantuesque. Je me trompe ?

Mickaël

[souviron34]

Je me trompe ?
l

oui..

Toute déclaration initiale n'est pas réallouable plus tard..

• Soit tu déclares un pointeur, et à la céation d'un résidu tu alloues un tableau de X (par exemple 23), quitte à le ré-allouer après
  
• Soit tu as déclaré 23, et ce sera valable pour toutes les strutures céées, sans possibilité de réallocation.

[souviron34]

et au fait, as-tu bien commencé tes tableaux à 0 ??

Le premier élément d'un tableau est celui d'indice 0 :

Tableau[0] = 1er élément

[mkrzemin]

Merci souviron34 pour ton intervention et tes précisions. Je me souviens en effet que je devais déclarer mes variables sous forme de pointeur quand je voulais les ré-allouer dynamiquement!

Et bien évidemment, j'ai commencé mes tableaux à 0. Je ne suis pas complètement un dummy... :p

Pour ceux qui seraient intéressés par le code entier, je peux l'envoyer (Le programme a déjà été conçu en PERL, et même publié, j'essaie juste de le faire passer en C pour en accélérer l'exécution).
En fait, je pense que le problème vient de la lecture de mon fichier de départ. Pourquoi ? Parce que lorsque j'utilise un premier fichier test, tout marche superbe, et quand j'utilise un autre fichier (qui est légèrement différent du premier), ça plante! J'aimerais en fait surtout comprendre ce qui se passe quand j'utilise ce second fichier...

Merci encore,
Mickaël

[mkrzemin]

Bonsoir à toutes et à tous,

J'ai enfin trouvé la solution à mon problème. En fait, je m'étais embrouillé avec les indices!

Ainsi, au lieu de:

residues[i].D[k] += K; // K est un double, i est l'indice du résidu et k l'indice de l'atome
residues[i].D_nb++; // i est l'indice du résidu

Il fallait écrire:
residues[i].D[j] += K; // K est un double, i est l'indice du résidu et k l'indice de l'atome
residues[i].D_nb++; // i est l'indice du résidu

En tout cas, merci encore pour vos efforts!

A bientôt,
Mickaël