Erreur programme fractale

Version imprimable

Bonjour ! Je viens de faire mon programme qui est censé afficher la fractale de Mandelbrot. Le programme fonctionne mais pas pour des veleurs de t (=taille de l'image [t][t]) au delà de 1000...

Quelqu'un pourrait-il m'indiquer pourquoi mon programme crash ? J'obtient un segmentation fault..

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
int main(){
 
 
FILE *fp;
 
fp=fopen("fractals.txt","w");
 
	int t; ;
	printf("Entrer la taille d'image t \n");
 
	scanf("%d",&t);			// t = taille du tableau
 
    int image[t][t];
    /// image de taille t
 
	float dx; float dy; float xo;	float yo;
 
	printf("Entrer l'origine xo et yo \n");
 
	scanf("%f",&xo);
	scanf("%f",&yo);
 
 
	printf("Entrer le pas dx et dy \n");
 
	scanf("%f",&dx);
	scanf("%f",&dy);
 
 
 
 
 
	int i;	int j;	int c;	float Re;	float Im;	int zmax; int k;
 
 
				 	// on déclare les variables
 
 
 
	printf("Entrer zmax \n");					// on demande la limite de la serie zmax
	scanf("%d",&zmax);
 
 
 
		float r[200]; float im[200]; float norme[200];
 
		for (i=0;i<1000;i++) {
							// on balaye le tableau en i et en j pour lequel on va siigner un complexe c
 
			for(j=0;j<1000;j++){
 
 
				 Re=i*dx+xo;
 
 
				 Im=j*dy+yo;		// on déclare le réel et imaginaire
 
 
 
				r[0]=0;		im[0]=0;
				printf("%f %f \n", Re, Im);
 
				for (k=1; k<=zmax ; k++){
 
 
 
 
 
 
 
				/*z[k]= (Re*Re + 2*Re*Im - Im*Im) + Re + Im;*/
 
 
				r[k]= r[k-1]*r[k-1] -im[k-1]*im[k-1] + Re;
 
				im[k]= 2*r[k-1]*im[k-1] + Im;
 
					/*if (r[k]*r[k]+im[k]*im[k]>0 ){*/
 
				norme[k]=sqrt(r[k]*r[k]+im[k]*im[k]);
															// on test la norme à chaque k;
 
 
 
 
 
 
				if ( norme[k] > 2.0 ){
 
 
					image[i][j]=k;
					k=zmax+1;
					}
 
					else{
 
					image[i][j]=k;							// on test si la serie diverge ou converge
 
 
					}
				}
			}
 
 
 
		}
 
 
 
 
 
/*for (k=0; k<=zmax ; k++){
 
printf("%f",norme[k]);
 
 
 
}
*/
 
 
 
 
 
for (i=0;i<t;i++) {
 
 
for(j=0;j<t;j++){
 
fprintf(fp,"%d ",image[i][j]);
 
 
}
fprintf(fp,"\n");
}
 
 
 
fclose(fp);
 
 
 
 
 
return 0;
}

Merci beaucoup :)

08/05/2018, 20h16
edgarjacobs

Hello,

Je ne suis pas spécialiste des vla (loin de là !) mais 1000 x 1000 x 4 n'est-ce pas un peu trop pour une vla ? Que donnerait ton programme si tu faisais une allocation dynamique ?
08/05/2018, 21h31
mancol1309

Citation:

Envoyé par edgarjacobs

Hello,

Je ne suis pas spécialiste des vla (loin de là !) mais 1000 x 1000 x 4 n'est-ce pas un peu trop pour une vla ? Que donnerait ton programme si tu faisais une allocation dynamique ?

Justement je ne sais pas trop comment faire. .. Car j'ai essayé avec des long int mais ça ne résout rien .. :(
09/05/2018, 00h43
edgarjacobs
Code:

1 2 3 4 5 6 int **image,t; scanf("%d",&t); image=malloc(t*sizeof(*image)); for(int i=0;i<t;i++) image[i]=malloc(t*sizeof(**image));
Et dans la suite du programme, tu utilises image comme tu le faisais:

Code:

image[i][j]=....;

Ne pas oublier de libérer la mémoire quand le programme n'en a plus besoin.

EDIT: je sais, il y a plus rapide en linéarisant la chose, mais je vais au plus simple.
09/05/2018, 07h38
mancol1309

1 pièce(s) jointe(s)
Citation:
Envoyé par edgarjacobs

Code:

1 2 3 4 5 6 int **image,t; scanf("%d",&t); image=malloc(t*sizeof(*image)); for(int i=0;i<t;i++) image[i]=malloc(t*sizeof(**image));

Et dans la suite du programme, tu utilises image comme tu le faisais:

Code:

image[i][j]=....;

Ne pas oublier de libérer la mémoire quand le programme n'en a plus besoin.

EDIT: je sais, il y a plus rapide en linéarisant la chose, mais je vais au plus simple.
Malheureusement ça ne fonctionne toujours pas ...ça me met toujours segmentation fault..
Pièce jointe 378448
09/05/2018, 09h02
Bousk

Et si tu utilisais le debugger pour savoir quelles valeurs de i et j déclenchent le crash ?
i semble valoir 0, mais que vaut j ?

Je me permets de te donner quelques conseils sur la manière de présenter ton problème. Un forum est un lieu de rencontre et d'échange, où chacun doit faire un pas. Si tu es un peu branché RPG, imagine-toi que les intervenants disposés à t'aider détiennent une quantité finie de « motivation » qu'il est de ta responsabilité de ne pas épuiser (pro tip: ça fonctionne aussi pour toutes les interactions sociales de la vie de tous les jours). Cette motivation diminue chaque fois que l'on doit déchiffrer ton code derrière une indentation indigne, chaque fois qu'il faut te tirer les vers du nez parce que l'on ne dispose que de bribes de phrases vides d'information comme « pourquoi mon programme crash », « ça ne fonctionne toujours pas »..

Les indications nécessaires t'ont été données. As-tu seulement cherché la signification d'allocation dynamique en C ? Est-on sensé deviner à quoi ressemble le programme modifié ? As-tu tenté de déterminer quelles instructions faisaient planter le programme ?

Citation:

Envoyé par edgarjacobs

Je ne suis pas spécialiste des vla (loin de là !) mais 1000 x 1000 x 4 n'est-ce pas un peu trop pour une vla ? Que donnerait ton programme si tu faisais une allocation dynamique ?

C'en est très probablement la cause, même si la quantité de mémoire requise - à laquelle il faut également ajouter les tableaux de float déclarés ensuite - n'est pas outrancière. On pourrait peut-être déplorer qu'en 2018 l'OP ne puisse disposer par défaut de plus de 4 MiB pour sa pile, si l'on suppose :

« standard » son environnement : une machine de bureau moderne, physique ou virtuelle. Peut-être s'agit-il d'un environnement basé sur Cygwin ?
négligeable la taille de la pile en regard de sa limite au moment de l'appel du code incriminé.

Il est de toutes les façons mal avisé de déclarer un VLA directement à partir d'une entrée utilisateur car il n'y a aucun moyen de récupérer d'une erreur d'allocation. La solution ici est comme indiqué d'utiliser l'allocation dynamique de mémoire.

Lorsque l'on veut toutefois pouvoir exploiter les avantages - bien réels - des VLA et de la pile, on peut utiliser une construction un peu alambiquée de ce type :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #define VLA_SIZE_MAX (size_t)16384u // request at most 16 KiB from the stack #define TRY_USE_VLA_(func, size, ...) { \ if (size <= VLA_SIZE_MAX) { \ unsigned char buf[size]; \ func(buf, size, ##__VA_ARGS__); \ } \ else { \ void *buf = malloc(size); \ if (buf) \ func(buf, size, ##__VA_ARGS__); \ } \ } #define TRY_USE_VLA(func, size, ...) TRY_USE_VLA_(func, size, ##__VA_ARGS__)