Discussion :

[Milka08]

Bonjour,

J'aurais besoin de votre aide pour créer un programme en langage C qui doit être capable de modéliser une avalanche de sable (modèle proposé par P.Bak en 1988). Voici ce que j'ai.
A une dimension, on construit une série de N colonnes numérotées de 1 à N (vers la droite) adjacentes constituées de carrés représentant des grains de sable. Soit zn la différence de hauteur entre les deux colonnes n et n + 1

zn = h(n) − h(n + 1)

L’ajout d’un grain de sable sur la colonne n (choisie au hasard) entraîne

zn -> zn + 1
zn−1 -> zn−1 − 1

ce qui peut engendrer un déplacement de grains de sable d’une colonne à une autre avec la règle suivante : dès qu’une colonne i contient plus de zc grains que sa voisine de droite, elle déverse un grain sur cette dernière ce qui se traduit par

zi -> zi − 2
zi±1 -> zi±1 + 1 pour z < zc

Le sable ne peut se déverser que sur la frontière droite du tas (comme si on ne simulait qu’un demi tas de sable), soit les conditions aux frontières

z0 = 0
zN -> zN − 1
zN−1 -> zN−1 − 1 pour z < zc

Le processus continue jusqu’à ce que, pout tout n, zn < zc. Pour chaque grain lancé, on calcule la taille de l’avalanche (c’est-à-dire le nombre de grains de sable qui ont franchi la barrière droite).
On étudie ensuite comment réagit le système à différentes configurations initiales (colonnes de hauteurs identiques, distribution de hauteurs telle que, pour tout n, zn>zc, ...).

Voilà en gros ce que je dois programmer, mais je suis asse mauvais en informatique, alors j'aurais besoin d'un petit coup de pour pour commencer.

J'ai toujours quelques soucis avec mon programme. Mon projet est à rendre pour Jeudi, et il y a encore quelques bugs...

Je trace la distribution des avalanches et je trouve quelque chose de très incohérent : des traits dans tous les sens, quelque chose de très désordonné et aléatoire. Puis j'ai un souci pour le problème en 2 D. Je vous mets la trame du programme, si vous souhaitez y jeter un coup d’œil.

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
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
 
#include<iostream>
#include<cmath>
#include<fstream>
#include<iomanip>
#include<stdlib.h>
#include<bibli_fonctions.h>
#include<time.h>
using namespace std;
#define N 50
 
int main()
{
    fstream avalanche ("avalanche.res",ios::out);
    int h[N]; /* hauteur */
    int z[N]; /* différence de hauteur entre les deux colonnes n et n+1 */
    int i,n,j,k;
    int zc=2;
 
    for (i = 0; i<N; i++)
    {
        h[i]=0;
    }
 
    /* On construit une série de N colonnes numérotées de 1 à N */
    germe(time(NULL));
 
 
    for (i = 0; i<N; i++)
    {
        z[i]=0;
 
    }
 
    /* On ajoute un grain de sable choisi au hasard sur la colonne n */
 
    int Ngrains=1000;
 
    for (n = 0 ; n < Ngrains ; n++)
    { 
        k=alea()*N;
        z[k]=z[k]+1;
        z[k-1]=z[k-1]-1;
        h[k]=h[k]+1;
        if (z[k]>zc)
        {
            z[k]=z[k]-2;
            z[k+1]=z[k+1]+1;
            z[k-1]=z[k-1]+1;
            h[k+1]=h[k+1]+1;
            h[k]=h[k-1];
        }
    }
    for (j = 0 ; j < N ; j++)
    {
        avalanche << z[j] << " " << h[j] << endl;
    }
    avalanche.close();
 
    system("gnuplot avalanche.res") ;
 
    /* Problème à 2D avec matrice */
 
    int y[N];
    int **M;
    M = (int**) malloc(N * sizeof(int*));
    for (i = 0; i < N; i++)
        M[i] = (int*) malloc(N * sizeof(int));
    for (i = 0; i < N; i++)
    {
        for (n=0; n<Ngrains; n++)
        {
            for (i=0; i<N; i++)
            {
                for (j=1; j<N; j++)
                {
                    if(z[i][j] > zc)
                    {
                        z[i][j]=z[i][j]-2;
                        z[i][j-1]=z[i][j-1]+1;
                        z[i][j+1]=z[i][j+1]+1;
                        h[i][j]=h[i][j-1];
                    }
                }
            }
 
            for (j=0; j<N; j++)
            {
                for (i=1; i<N; i++)
                {
                    if(y[i][j] > zc)
                    {
                        y[i][j]=y[i][j]-2;
                        y[i-1][j]=y[i-1][j]+1;
                        y[i+1][j]=y[i+1][j]+1;
                        h[i][j]=h[i-1][j];
                    }
                }
            }
 
            for (i=0; i<N; i++)
            {
                z[i][0]=0;
                y[0][i]=0;
            }
 
        }
    }
 
    for (i = 0 ; i < N ; i++)
    {
        for (j=0 ; j <N ; j++)
        {
            avalanche << M[i][j] << " " << h[i][j] << " " << z[i][j] << endl;
        }
    }
    return 0;
}

Si quelques personnes ont des conseils, je suis preneur.
Merci.

[cob59]

Dans tes boucles for télescopiques L69 tu utilises 2 fois l'indice i, c'est normal ?
Tu sais qu'en C++ on a le droit faire ça for (int i= 0; i<N; i++) { ... }, n'est-ce pas ?

[Milka08]

Euh le souci viendrait de là alors. Il faut remplacer l'indice i par autre chose c'est ça ?

[Bousk]

Euh le souci viendrait de là alors. Il faut remplacer l'indice i par autre chose c'est ça ?

L'utilisation de l'index dans une boucle imbriquée peut avoir un sens.
Dans ton cas, je ne pense pas.
As-tu une vraie raison d'avoir une boucle imbriquée qui réutilise l'index d'une boucle parente ? J'en doute.
Surtout quand tu réinitialises l'index dans la boucle imbriquée pour boucler à nouveau sur 0-N.
En sortie i valant N, la boucle parente ne bouclera rien du tout.

Comme remarqué ci-dessus, en C++ tu n'as pas besoin de déclarer toutes les variables au début. En fait on les déclare uniquement quand on en a besoin, et on essaye de limiter leur scope au maximum.

Code :

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

1
2
3
M = (int**) malloc(N * sizeof(int*));
    for (i = 0; i < N; i++)
        M[i] = (int*) malloc(N * sizeof(int));

Tu es en C++, préfère l'opérateur new, voire un conteneur type vector ou array.
N'oublie pas non plus de libérer la mémoire.
Enfin vu que N est un define, nul besoin de faire une allocation dynamique : la taille est connue à la compilation.

Retravaille l'algorithme, voire l'algorithmique et ça coulera tout seul.