[Debutante] Probleme d'affıchage du resultat d'une fonction de plusieurs variables

Version imprimable

Bonjour,
pour mon travail je dois realiser un programme qui, a partir de certaines donnees entrees par l'utilisateur, sort le maximum d'une fonction par rapport a trois variables theta1, theta2 et X.
J'ai deja verifie que le main tout seul fonctionne, ainsi que toutes les boucles if et for, elles sont ok. Je pense que le probleme vient des trois dernieres lignes mais je ne sais pas comment faire ! J'espere avoir ete assez claire ...
Merci de votre aide !

Voilou mon petit (!) programme :

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
 
/*Function declaration*/
float TMAXF (float,float,float,float,float,float,float,float,float,int,float,float);
 
/*Main function*/
int main()
{
    float qd,Hd,betad,id,fid,cd,rud,gammad,alphad, dholed,Shd,Tmaxd;
    int typed;
 
    /*Initialization*/
   dholed=0;
   Shd=0;
   Tmaxd=0;
 
    /*Input values*/
    printf("Enter q value (kN/m2)\n");
    scanf("%f",&qd);
    printf("Enter H value (m)\n");
    scanf("%f",&Hd);
    printf("Enter beta value (degrees)\n");
    scanf("%f",&betad);
    printf("Enter i value (degrees)\n");
    scanf("%f",&id);
    printf("Enter fi value (degrees)\n");
    scanf("%f",&fid);
    printf("Enter c value (kN/m2)\n");
    scanf("%f",&cd);
    printf("Enter ru value\n");
    scanf("%f",&rud);
    printf("Enter gamma value (kN/m3)\n");
    scanf("%f",&gammad); 
    printf("Enter interface sliding value (Entry 999 for a default value)\n");
    scanf("%f",&alphad);
    printf("Type of reinforcement : 1->Geotextiles/Geogrids, 2->Strip reinforcement, 3->Soil nails\n");
    scanf("%d",&typed);
    if (typed==3)
    {
                printf("Enter the diameter of the grout hole around the nail\n");
                scanf("%f",&dholed);
                printf("Enter the horizontal spacing\n");
                scanf("%f",&Shd);
    }
 
     Tmaxd=TMAXF(qd,Hd,betad,id,fid,cd,rud,gammad,alphad,typed,dholed,Shd);
     printf("Tmax=%f",Tmaxd);
 
    /*Wait before quit*/
    system("pause");
 
}

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
 
/*TMAXF function*/
 
float TMAXF(float q,float H,float beta,float i,float fi,float c,float ru, float gamma, float alpha,int type,float dhole, float Sh)
{
 
    float Tmax, H1,L,Xlim,theta1,theta2,X,Tmax1,Y,a,b,k,d,e,f,g,s,t,j,m,u,v,w,z,lambdas,W1,W2,U1,U2,K1,K2;
    X=0;
    Tmax=0;
    Tmax1=0;
 
    /*alpha default values*/
    if (alpha==999)
    {
       switch (type)
       {
       case 1:
       alpha=0.85;
       break;
       case 2:
       alpha=0.9;
       break;
       case 3:
       alpha=0.9;
       break;
       }
    }
 
    /*H1=Height with surcharge*/
    H1=H+(q/gamma);
    /*L=length from the toe to the crest*/
    L=H1/tan(beta*M_PI/180);
   /*Imposed limit value for X*/  
    Xlim=2.5*H1;   
 
    for (theta1=0;theta1<=90;theta1=theta1+0.1)
    {
        for (theta2=0;theta2<=90;theta2=theta2+0.1)
        {
            for (X=0;X<Xlim;X=X+0.1)
            {
                Y=X*tan(theta1*M_PI/180);
                a=(H1-X*tan(beta*M_PI/180));
                b=(H1-Y-a);
                k=((a+b)/tan(theta1*M_PI/180))-a/tan(beta*M_PI/180);
                d=k*tan(theta1*M_PI/180);
                e=k/cos(theta1*M_PI/180);
                f=((a+b)/sin(theta1*M_PI/180))-e;
                g=(a+b)/sin(theta1*M_PI/180);
                s=(a+b)/tan(theta1*M_PI/180);
                t=k-s;
                j=t*tan(theta2*M_PI/180);
                m=sqrt(X+Y);
                u=b/(tan(theta1*M_PI/180)-tan(beta*M_PI/180));
                   if (i==0)
                   v=0;                
                   else 
                   v=k/((1/tan(i*M_PI/180))-(1/tan(theta1*M_PI/180)));
                w=v/sin(theta1*M_PI/180);
                z=t*tan(i*M_PI/180);
 
                /*Different expressions of lambdas depending on the 
                reinforcement material*/
                switch (type)
                {
                case 1:
                lambdas=alpha;
                break;
                case 2:
                lambdas=alpha*b+(1-b);
                break;
                case 3:
                lambdas=(alpha*dhole/Sh)+(1-dhole/Sh);
                break;
                }
 
                if (X<=(H1/tan(beta*M_PI/180)))
                {
                   if (X+(H1-L*tan(theta1*M_PI/180))/(tan(theta2*M_PI/180)-tan(theta1*M_PI/180))<L)
                   /*CASE 3*/
                   {
                   W1=0.5*gamma*b*u;
                   W2=0.5*gamma*b*X;
                   U1=0.5*ru*gamma*b*u/cos(theta1*M_PI/180);
                   U2=0.5*ru*gamma*b*m;
                   K1=c*u/cos(theta1*M_PI/180);
                   K2=c*m;
                   }
 
 
                   else 
                   /*CASE 1*/
                   {
                   W1=0.5*gamma*((a+b)*(a+b)/tan(theta1*M_PI/180)-a*a/tan(beta*M_PI/180)+v*k);
                   W2=0.5*gamma*b*X;
                   U1=0.5*ru*gamma*(d*(e+w)+f*(d+b));
                   U2=0.5*ru*gamma*b*m;
                   K1=c*(g+w);
                   K2=c*m;
                   }
 
                }
 
 
                else
                /*CASE 2*/
                {
                W1=0.5*gamma*(H1-Y)*(H1-Y)/tan(theta1*M_PI/180)+0.5*gamma*(v*k-t*z);
                W2=0.5*gamma*(2*X*H1-X*tan(theta2*M_PI/180)-H1*H1/tan(beta*M_PI/180)+t*t*z);
                U1=0.5*ru*gamma*(g+w)*(H1-Y+z);
                U2=0.5*ru*((H1-Y)*(X+t)/cos(theta2*M_PI/180)+j*m+z*t/cos(theta2*M_PI/180));
                K1=c*(g+w);
                K2=c*m;
                }   
 
                  Tmax1=((W1*(tan(theta1*M_PI/180)-tan(fi*M_PI/180))+(U1*tan(fi*M_PI/180)-K1)/cos(theta1*M_PI/180))/(1+tan(theta1*M_PI/180)*tan(fi*M_PI/180)))+((W2*(tan(theta2*M_PI/180)-lambdas*tan(fi*M_PI/180))+lambdas*(U2*tan(fi*M_PI/180)-K2)/cos(theta2*M_PI/180))/(1+lambdas*tan(theta2*M_PI/180)*tan(fi*M_PI/180)));
 
 
                   /*Take the maximum value of Tmax*/
                   if (Tmax1>Tmax) Tmax=Tmax1;
 
                     }
 
             }
        }
        return (Tmax);
    }

10/05/2007, 14h55
ZeRiL

Euh c'est quoi le probleme exactement ? j'avoue ne pas avoir tout compris la :) la valeur retournée n'est pas bonne ?

PS : bouuuuh printf !!! bouuuuuh scanf !!! ;)
10/05/2007, 14h57
juls64

Au fait pour que le code soit plus lisible utilise le # et tu mets ton code au lieu il y aura la coloration syntaxique sinon ca donne pas envie
10/05/2007, 15h45
Médinoc

:tagcode:
C'est plus du C que du C++, ce code...

Code:

float Tmax, H1,L,Xlim,theta1,theta2,X,Tmax1,Y,a,b,k,d,e,f,g,s,t,j,m,u,v,w,z,lambdas,W1,W2,U1,U2,K1,K2;

Tu es sûr que tu ne peux pas faire plus court, comme noms de variables ? :roll: Ne compte pas sur nous pour t'aider si tu produis un code incompréhensible (et pour ainsi dire non commenté)...
10/05/2007, 21h01
HanLee

Ben disons que c'est plutôt le schéma qui nous manque... Les noms de variables désignent clairement des trucs de physique...

Désolée pour les couleurs je suis nouvelle sur le site je n'avais pas vu cette possibilité.:oops:
Effectivement mes variables ont des noms longs mais ce programme n'est que le début d'une longue suite, et il servira a dimensionner des murs de soutènement. C'est donc un problème physique, et je garde des noms proches des paramètres physiques pour m'y retrouver...
Quant a mon problème, je m'explique :
déjà je pense que le pas que j'utilisais pour mes variables theta1, theta2 et X était trop petit, si bien que les calculs duraient des heures et je n'attendais jamais assez longtemps... J'ai diminué le pas.
Ensuite la j'ai introduit une valeur p pour tester le programme pour une valeur particulière je veux qu'il me sorte les valeurs de W1, W2, U1, U2, K1 et K2. Les valeurs de W1 et W2 sont surprenantes ....En plus, au lieu de me sortir p=1,2 ou 3 il me sort une valeur aberrante !
Enfin, et c'est la la problème principal, la valeur de Tmax en sortie est complètement aberrante ...
J'ai essaye de rajouter des commentaires, j'espère que j'ai été suffisamment claire cette fois-ci merci de votre aide ! ;)

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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
 
/*Function declaration*/
float TMAXF (float,float,float,float,float,float,float,float,float,int,float,float);
 
/*Main function*/
int main()
{
    float qd,Hd,betad,id,fid,cd,rud,gammad,alphad, dholed,Shd,Tmaxd;
    int typed;
 
    /*Initialization*/
   dholed=0;
   Shd=0;
   Tmaxd=0;
 
    /*Input values*/
    printf("Enter q value (kN/m2)\n");
    scanf("%f",&qd);
    printf("Enter H value (m)\n");
    scanf("%f",&Hd);
    printf("Enter beta value (degrees)\n");
    scanf("%f",&betad);
    printf("Enter i value (degrees)\n");
    scanf("%f",&id);
    printf("Enter fi value (degrees)\n");
    scanf("%f",&fid);
    printf("Enter c value (kN/m2)\n");
    scanf("%f",&cd);
    printf("Enter ru value\n");
    scanf("%f",&rud);
    printf("Enter gamma value (kN/m3)\n");
    scanf("%f",&gammad); 
    printf("Enter interface sliding value (Entry 000 for a default value)\n");
    scanf("%f",&alphad);
    printf("Type of reinforcement : 1->Geotextiles/Geogrids, 2->Strip reinforcement, 3->Soil nails\n");
    scanf("%d",&typed);
    if (typed==3)
    {
                printf("Enter the diameter of the grout hole around the nail\n");
                scanf("%f",&dholed);
                printf("Enter the horizontal spacing\n");
                scanf("%f",&Shd);
    }
 
     /*Return Tmax value*/
     Tmaxd=TMAXF(qd,Hd,betad,id,fid,cd,rud,gammad,alphad,typed,dholed,Shd);
     printf("Tmax=%f",Tmaxd);
 
    /*Wait before quit*/
    system("pause");
 
} 
 
 
 
 
 
 
 
 
 
 
 
/*TMAXF function*/
 
float TMAXF(float q,float H,float beta,float i,float fi,float c,float ru, float gamma, float alpha,int type,float dhole, float Sh)
{
 
    float Tmax, H1,L,Xlim,theta1,theta2,X,Tmax1,Y,a,b,k,d,e,f,g,s,t,j,m,u,v,w,z,lambdas,W1,W2,U1,U2,K1,K2;
    int p;
    X=0;
    Tmax=0;
    Tmax1=0;
    p=0;
 
    /*alpha default values*/
    if (alpha==000)
    {
       switch (type)
       {
       case 1:
       alpha=0.85;
       break;
       case 2:
       alpha=0.9;
       break;
       case 3:
       alpha=0.9;
       break;
       }
    }
 
    /*H1=Height with surcharge*/
    H1=H+(q/gamma);
    /*L=length from the toe to the crest*/
    L=H1/tan(beta*M_PI/180);
   /*Imposed limit value for X*/  
    Xlim=2.5*H1;   
 
    /*Scanning of all possible combinations for theta1, theta2 and X*/
    for (theta1=1;theta1<=90;theta1=theta1+1)
    {
        for (theta2=1;theta2<=90;theta2=theta2+1)
        {
            for (X=0;X<Xlim;X=X+0.2)
            {
                /*Definition of parameters for all cases*/
                Y=X*tan(theta1*M_PI/180);
                a=(H1-X*tan(beta*M_PI/180));
                b=(H1-Y-a);
                k=((a+b)/tan(theta1*M_PI/180))-a/tan(beta*M_PI/180);
                d=k*tan(theta1*M_PI/180);
                e=k/cos(theta1*M_PI/180);
                f=((a+b)/sin(theta1*M_PI/180))-e;
                g=(a+b)/sin(theta1*M_PI/180);
                s=(a+b)/tan(theta1*M_PI/180);
                t=k-s;
                j=t*tan(theta2*M_PI/180);
                m=sqrt(X+Y);
                u=b/(tan(theta1*M_PI/180)-tan(beta*M_PI/180));
                   if (i==0)
                   v=0;                
                   else 
                   v=k/((1/tan(i*M_PI/180))-(1/tan(theta1*M_PI/180)));
                w=v/sin(theta1*M_PI/180);
                z=t*tan(i*M_PI/180);
 
                /*Different expressions of lambdas depending on the 
                reinforcement material*/
                switch (type)
                {
                case 1:
                lambdas=alpha;
                break;
                case 2:
                lambdas=alpha*b+(1-b);
                break;
                case 3:
                lambdas=(alpha*dhole/Sh)+(1-dhole/Sh);
                break;
                }
 
 
                /*Different calculations of forces depending on the case*/
                if (X<=(H1/tan(beta*M_PI/180)))
                {
                   if ((X<((H1-L*tan(theta1*M_PI/180))/(tan(theta2*M_PI/180)-tan(theta1*M_PI/180))))&&(X+(H-X*tan(theta2*M_PI/180)/tan(theta1*M_PI/180))))
                   /*CASE 3*/
                   {
                   /*Weight of wedge 1*/
                   W1=0.5*gamma*b*u;
                   /*Weight of wedge 2*/
                   W2=0.5*gamma*b*X;
                   /*Pore water force acting on base of wedge 1*/
                   U1=0.5*ru*gamma*b*u/cos(theta1*M_PI/180);
                   /*Pore water force acting on base of wedge 2*/
                   U2=0.5*ru*gamma*b*m;
                   /*Cohesion force acting on base of wedge 1*/
                   K1=c*u/cos(theta1*M_PI/180);
                   /*Cohesion force acting on base of wedge 2*/
                   K2=c*m;
                   p=3;
                   }
 
 
                   else 
                   /*CASE 1*/
                   {
                   W1=0.5*gamma*((a+b)*(a+b)/tan(theta1*M_PI/180)-a*a/tan(beta*M_PI/180)+v*k);
                   W2=0.5*gamma*b*X;
                   U1=0.5*ru*gamma*(d*(e+w)+f*(d+b));
                   U2=0.5*ru*gamma*b*m;
                   K1=c*(g+w);
                   K2=c*m;
                   p=1;
                   }
 
                }
 
 
                else
                /*CASE 2*/
                {
                W1=0.5*gamma*(H1-Y)*(H1-Y)/tan(theta1*M_PI/180)+0.5*gamma*(v*k-t*z);
                W2=0.5*gamma*(2*X*H1-X*tan(theta2*M_PI/180)-H1*H1/tan(beta*M_PI/180)+t*t*z);
                U1=0.5*ru*gamma*(g+w)*(H1-Y+z);
                U2=0.5*ru*((H1-Y)*(X+t)/cos(theta2*M_PI/180)+j*m+z*t/cos(theta2*M_PI/180));
                K1=c*(g+w);
                K2=c*m;
                p=2;
                }   
 
                  if (theta1==50&&theta2==10&&X==1) 
                  {
                  printf("p=%f\n",p);
                  printf("W1=%f\n",W1);
                  printf("W2=%f\n",W2);
                  printf("U1=%f\n",U1);
                  printf("U2=%f\n",U2);
                  printf("K1=%f\n",K1);
                  printf("K2=%f\n",K2);
                  }
 
                  /*Total quantity of horizontal reinforcement force required*/
                  Tmax1=((W1*(tan(theta1*M_PI/180)-tan(fi*M_PI/180))+(U1*tan(fi*M_PI/180)-K1)/cos(theta1*M_PI/180))/(1+tan(theta1*M_PI/180)*tan(fi*M_PI/180)))+((W2*(tan(theta2*M_PI/180)-lambdas*tan(fi*M_PI/180))+lambdas*(U2*tan(fi*M_PI/180)-K2)/cos(theta2*M_PI/180))/(1+lambdas*tan(theta2*M_PI/180)*tan(fi*M_PI/180)));
 
                   /*Take the maximum value of Tmax*/
                   if (Tmax1>Tmax) Tmax=Tmax1;
 
                     }
 
             }
        }
        return (Tmax);
    }
 
////////////////////////////////////////////////////////////////////////////////

11/05/2007, 10h51
SofC++

Alors j'ai change mes bornes pour la variation de mes angles parce que la variations de 0 a 90 pour les deux n'était pas physique.:oops:
J'ai donc des valeurs de Tmax beaucoup moins aberrantes .... mais toujours fausses ! :(
J'ai bien vérifié mes expressions des différents termes, elles sont juste, j'ai même ajoute des parenthèses pour être sur des priorités sur les opérations.
Je demande toujours p et il me sort toujours une valeur bizarre ... :(
Merci de votre aide ! :king:
11/05/2007, 15h33
koala01

Salut,

Je me pose honnetement la question de savoir si tu n'aurais pas, de manière générale, intérêt à créer une (ou plusieurs) structures qui regroupe(nt) les différents parametres en fonction de leur utilité...

La raison avant l'explication: Lors de la création, et surtout de l'appel d'une fonction, il est déjà difficile de s'y retrouver dans les parametres à lui fournir quand on doit lui donner plus de trois ou quatre parametres... alors 12, dont un qui n'est pas du meme type que les autres au beau milieu :P:marteau:

Or, et c'est là l'explication, il semblerait (dis moi si je me trompe ;)) que qd,Hd,betad,id,fid,cd,rud,gammad,alphad, dholed,Shd,Tmaxd et typed soient destinés à "jouer en permance ensemble": alphad (par exemple) ne prend tout son sens que parce qu'il trouve gammad et betad pour pouvoir travailler :D (je n'ai pas vérifié le code pour m'en assurer:oops:), et, si tu modifie gammad, tu modifie la résistance du sol, l'inclinaison de la pente, l'endroit du plan que tu est en train de calculer, ou que sais-je:question:(c'est peut etre l'age du maçon qui préparera le mur de soutainement, qui sait :D)

Bref, ce que je veux dire, c'est qu'il y a une tres forte implication de chacune des variables par rapport aux autres, et qu'il peut sembler logique de représenter cette implication forte par la création d'une structure qui les regroupe ;)

L'énorme avantage, ce sera que, chaque fois que tu déclarera une variable du type de cette structure, tu n'auras plus à t'inquiéter de savoir si

Citation:

au fait, ai-je déjà déclaré ma variable qui doit contenir gammad:question:

et qu'il te suffira de fournir la structure comme parametre à ta fonction pour que, d'office, toutes les valeurs soient également passée, sans que tu ne doive réfléchir à

Citation:

dois-je passer gammad avant alphad ou l'inverse :question:... je sais pu:cry::cry:
11/05/2007, 15h59
SofC++

Merci de ta reponse !
Alors en fait les parametres rentres par l'utilisateur representent la géometrie du mur et le probleme est qu'il sont totalement indépendants entre eux. Ainsi, si je change n'importe laquelle de ces valeurs sans changer les autres, mon résultat sera différent.
Je suis d'accord qu'une fonction de 12 parametres c'est beaucoup :marteau: :marteau:(d'autant que comme je l'ai dit avant ce n'est que le debut de mon programme) mais comment puis je créer une structure comme tu l'appelles, j'ai peur que cela ne complique beaucoup les choses (je sais pas faire grand chose en C++...):cfou:
Je me penche actuellement sur des limitations sur les bornes de mes boucles for pour limiter le nombre de calculs, mais mes valeurs de sortie sont bizarres ....
Pour info, ce programme sert a calculer la tension a reprendre par des renforcements dans une pente instable. Par la suite, je voudrais qu'il fasse pareil pour les murs de soutenement :mur:(les calculs sont differents) puis qu'il me donne l'espacement, la longueur, la tension a prendre, etc... de chaque couche de renforcement. Enfin je me pencherai sur des murs et pentes hybrides renforcés par deux types de renforcement (en l'occurence des geosynthetiques et des clous).
Suis claire ?:?
Merci de votre aide ...
:merci:
11/05/2007, 17h02
ZeRiL

Bon Koala01 ayant fait un post plus complet que le mien je le supprime :)

:aie:

Tu n'as peut etre pas tout à fait saisi la portée de mon explication...

Bien sur, toutes les données peuvent etre susceptibles de changer selon les circonstances...

Mais il n'empeche qu'à un moment donné, ou, si tu préfères, dans une situation donnée, tu "gele" ces valeurs dans leur état précis, et tu lances une série de tests et d'actions sur ces valeurs précises...

Et, comme alpha dépend de type, que L dépend de H1 et de beta, et que H1 dépend lui meme de gamma, tu te rend compte que la relation entre toutes ces valeurs, à un moment donné, est finalement tres forte...

Rien que cela est de nature à suggérer l'utilisation d'une structure.

En plus, hormis l'idée de devoir dire que tu veux accéder "au champs machin" de la structure, ce sera de nature à simplifier énormément la lisibilité du code ;)

Une structure, en C++, cela se déclare, tout simplement sous la forme de
Code:

1 2 3 4 5 6 struct le_nom_de_structure_qui_va_bien { le_type_de_la_premiere_variabe nom_de_la_premiere_variable; le_type_de_la_deuxieme_variabe nom_de_la_deuxieme_variable; le_type_de_la_troisieme_variabe nom_de_la_troisieme_variable; };
Dans ton cas, ce pourrait tres bien prendre la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 struct valeurs { int typed; float alphad; float betad; float gammad; float cd; float fid; float id; float Hd; float qd; float rud; float dholed; float Shd; };
(je les ai juste écrit dans une autre ordre, mais ca n'a pas énormément d'importance ;) )

Tu déclarerais une variable du type valeurs sous la forme de
Code:

1 2 3 4 5 6 valeurs mesvaleurs; //peut etre te faut il trois fois ces valeurs mais avec des valeurs différentes? // rien de plus simple: valeurs deuxemevaleur;//voila le deuxieme exemplaire valeurs troisiemevaleur;//et voilà le troisième :D
Et, pour accéder aux différnentes valeurs, cela se fait sous la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 //exemple du clacul de H1 en utilisant mesvaleurs float H1=mevaleurs.Hd+(mesvaleurs.qd/mesvaleurs.gammad); //Tiens, peut etre est il intéressant de faire la comparaison avec ce // qu'on obtiendrait en changant uniquement gamma, et en prenant // le gamma de deuxiemevaleur float H2=mevaleurs.Hd+(mesvaleurs.qd/deuxiemvaleur.gammad); //définitivement, si H2 est plus grand que H1, je préfere utiliser le gamma // de deuxiemevaleur :P if(H2>H1) { mesvaleurs.gammad=deuxiemevaleur.gammad; }
Tu remarquera tout de suite un avantage supplémentaire à utiliser les structures: un seul et meme nom (gammad, par exemple) représente systématiquement la valeur (ici du gamma) pour la variable concernée...

Alors que, si tu travaille sans utiliser une structure, et qu'il te faut chaque variable en trois exemplaire, tu devras commencer à déclarer gamma1d, gamma2d, gamma3d, alpha1d, alpha2d, alpha3d ...

Et quand il s'agira de réfléchir à quel variable passer, pour, simplement, faire une multiplication ou une addition...:marteau:

[EDIT]grilled...:P

14/05/2007, 08h21
SofC++

Merci de vos reponse
je vais tenter d'utiliser les structures, maintenant que vous m'avez expliqué comment ça fonctionne ça me rappelle quelque chose ... j'ai du les utiliser dans le temps !!
:lun:

Si quelqu'un le courage de lire tout le code :oops: suivant, peut il me dire si j'ai bien utilisé la structure ? :arf:
Merci d'avance ...
:lol:

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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
/*Values declaration*/
struct valeurs
{
    int type;
    float alpha;
    float beta;
    float gamma;
    float c;
    float fi;
    float i;
    float H;
    float q;
    float ru;
    float dhole;
    float Sh;
};
 
/*Function declaration*/
float TMAXF (struct valeurs);
 
/*Main function*/
int main()
{
    struct valeurs donnees;
    float Tmax=0;
 
    /*Initialization*/
   donnees.dhole=0;/*Default value if other type than 3*/
   donnees.Sh=0;/*Default value if other type than 3*/
 
    /*Input values*/
    printf("Enter q value (kN/m2)\n");
    scanf("%f",&donnees.q);
    printf("Enter H value (m)\n");
    scanf("%f",&donnees.H);
    printf("Enter beta value (degrees)\n");
    scanf("%f",&donnees.beta);
    printf("Enter i value (degrees)\n");
    scanf("%f",&donnees.i);
    printf("Enter fi value (degrees)\n");
    scanf("%f",&donnees.fi);
    printf("Enter c value (kN/m2)\n");
    scanf("%f",&donnees.c);
    printf("Enter ru value\n");
    scanf("%f",&donnees.ru);
    printf("Enter gamma value (kN/m3)\n");
    scanf("%f",&donnees.gamma); 
    printf("Enter interface sliding value (Entry 000 for a default value)\n");
    scanf("%f",&donnees.alpha);
    printf("Type of reinforcement : 1->Geotextiles/Geogrids, 2->Strip reinforcement, 3->Soil nails\n");
    scanf("%d",&donnees.type);
    if (donnees.type==3)
    {
                printf("Enter the diameter of the grout hole around the nail\n");
                scanf("%f",&donnees.dhole);
                printf("Enter the horizontal spacing\n");
                scanf("%f",&donnees.Sh);
    }
 
     /*Return Tmax value*/
     Tmax=TMAXF(donnees);
     printf("Tmax=%f",Tmax);
 
    /*Wait before quit*/
    system("pause");
 
} 
 
 
 
 
 
 
 
 
 
 
 
/*TMAXF function*/
 
float TMAXF(struct valeurs def)
{
 
    struct valeurs;
    float H1,L,Xlim,theta1,theta2,Y,a,b,k,d,e,f,g,s,t,j,m,u,v,w,z,lambdas,W1,W2,U1,U2,K1,K2;
 
    /*Initialization*/
    float X=0;
    float Tmax=0;
    float Tmax1=0;
    int p=0;
 
    /*alpha default values*/
    if (def.alpha==000)
    {
       switch (def.type)
       {
       case 1:
       def.alpha=0.85;
       break;
       case 2:
       def.alpha=0.9;
       break;
       case 3:
       def.alpha=0.9;
       break;
       }
    }
 
    /*H1=Height with surcharge*/
    H1=def.H+(def.q/def.gamma);
    /*L=length from the toe to the crest*/
    L=H1/tan(def.beta*M_PI/180);
   /*Imposed limit value for X*/  
    Xlim=2.5*H1;   
 
    /*Scanning of all possible combinations for theta1, theta2 and X*/
    for (theta2=0;theta2<def.beta;theta2=theta2+1)
    {
        for (theta1=theta2;theta1<90;theta1=theta1+1)
        {
            for (X=0;X<Xlim;X=X+0.2)
            {
                /*Definition of parameters for all cases*/
                Y=(X*tan(theta1*M_PI/180));
                a=(H1-X*tan(def.beta*M_PI/180));
                b=(H1-Y-a);
                k=((a+b)/tan(theta1*M_PI/180))-a/tan(def.beta*M_PI/180);
                d=(k*tan(theta1*M_PI/180));
                e=(k/cos(theta1*M_PI/180));
                f=(((a+b)/sin(theta1*M_PI/180))-e);
                g=((a+b)/sin(theta1*M_PI/180));
                s=((a+b)/tan(theta1*M_PI/180));
                t=(k-s);
                j=(t*tan(theta2*M_PI/180));
                m=(sqrt(X+Y));
                u=(b/(tan(theta1*M_PI/180)-tan(def.beta*M_PI/180)));
                   if (def.i==0)
                   v=0;                
                   else 
                   v=(k/((1/tan(def.i*M_PI/180))-(1/tan(theta1*M_PI/180))));
                w=(v/sin(theta1*M_PI/180));
                z=(t*tan(def.i*M_PI/180));
 
                /*Different expressions of lambdas depending on the 
                reinforcement material*/
                switch (def.type)
                {
                case 1:
                lambdas=def.alpha;
                break;
                case 2:
                lambdas=def.alpha*b+(1-b);
                break;
                case 3:
                lambdas=(def.alpha*def.dhole/def.Sh)+(1-def.dhole/def.Sh);
                break;
                }
 
 
                /*Different calculations of forces depending on the case*/
                if (X<=(H1/tan(def.beta*M_PI/180)))
                {
                   if (X<((L*sqrt((tan(def.beta*M_PI)*tan(def.beta*M_PI))+1))/((sqrt((tan(theta2*M_PI)*tan(theta2*M_PI))+1))*(cos((def.beta-theta2)*M_PI/180)+(sin((def.beta-theta2)*M_PI/180)/tan((theta1-def.beta)*M_PI/180))))))
                   /*CASE 3*/
                   {
                   /*Weight of wedge 1*/
                   W1=(0.5*def.gamma*b*u);
                   /*Weight of wedge 2*/
                   W2=(0.5*def.gamma*b*X);
                   /*Pore water force acting on base of wedge 1*/
                   U1=(0.5*def.ru*def.gamma*b*u/cos(theta1*M_PI/180));
                   /*Pore water force acting on base of wedge 2*/
                   U2=(0.5*def.ru*def.gamma*b*m);
                   /*Cohesion force acting on base of wedge 1*/
                   K1=(def.c*u/cos(theta1*M_PI/180));
                   /*Cohesion force acting on base of wedge 2*/
                   K2=(def.c*m);
                   p=3;
                   }
 
 
                   else 
                   /*CASE 1*/
                   {
                   W1=(0.5*def.gamma*(((a+b)*(a+b)/tan(theta1*M_PI/180))-(a*a/tan(def.beta*M_PI/180))+(v*k)));
                   W2=(0.5*def.gamma*b*X);
                   U1=(0.5*def.ru*def.gamma*((d*(e+w))+(f*(d+b))));
                   U2=(0.5*def.ru*def.gamma*b*m);
                   K1=(def.c*(g+w));
                   K2=(def.c*m);
                   p=1;
                   }
 
                }
 
 
                else
                /*CASE 2*/
                {
                W1=((0.5*def.gamma*(H1-Y)*(H1-Y)/tan(theta1*M_PI/180))+(0.5*def.gamma*((v*k)-(t*z))));
                W2=(0.5*def.gamma*((2*X*H1)-(X*tan(theta2*M_PI/180))-(H1*H1/tan(def.beta*M_PI/180))+(t*t*z)));
                U1=(0.5*def.ru*def.gamma*(g+w)*(H1-Y+z));
                U2=0.5*def.ru*(((H1-Y)*(X+t)/cos(theta2*M_PI/180))+(j*m)+(z*t/cos(theta2*M_PI/180)));
                K1=(def.c*(g+w));
                K2=(def.c*m);
                p=2;
                }   
 
 
                  if (theta1==50&&theta2==10&&X==1) 
                  {
                  printf("p=%d\n",p);
                  printf("W1=%f\n",W1);
                  printf("W2=%f\n",W2);
                  printf("U1=%f\n",U1);
                  printf("U2=%f\n",U2);
                  printf("K1=%f\n",K1);
                  printf("K2=%f\n",K2);
                  }
 
                  /*Total quantity of horizontal reinforcement force required*/
                  Tmax1=((W1*(tan(theta1*M_PI/180)-tan(def.fi*M_PI/180))+(((U1*tan(def.fi*M_PI/180))-K1)/cos(theta1*M_PI/180)))/(1+(tan(theta1*M_PI/180)*tan(def.fi*M_PI/180))))+((W2*(tan(theta2*M_PI/180)-(lambdas*tan(def.fi*M_PI/180)))+(lambdas*((U2*tan(def.fi*M_PI/180))-K2)/cos(theta2*M_PI/180)))/(1+(lambdas*tan(theta2*M_PI/180)*tan(def.fi*M_PI/180))));
                   /*printf("Tmax=%f\n",Tmax);*/
 
 
                   /*Take the maximum value of Tmax*/
                   if (Tmax1>Tmax) Tmax=Tmax1;
 
                     }
 
             }
        }
        return (Tmax);
    }
 
////////////////////////////////////////////////////////////////////////////////

14/05/2007, 15h54
SofC++

Question sur les strcutures
Encore une question:
je veux créer une fonction qui vérifie que les valeurs entrées par l'utilisateur ne sont pas aberrantes. Je veux que les parametres d'entrée soient donnees.la_valeur_a_tester,min,max. Je pensais donc faire un truc du genre :

Dans le main :
Code:

1 2 3 printf("Enter q value (kN/m2)\n"); scanf("%f",&donnees.q); donnees.q=verif(donnees.q,0,70);
Pour la definition de la fonction :
Code:

1 2 3 4 5 6 7 8 9 10 float verif (XXX,min,max) { while XXX <min||XXX>max { printf("Invalid value.The value must be between %f. and %f..Enter a new value",min,max); scanf("%f",&v); XXX=v; } return(XXX); }
Le probleme est que je ne sais pas quoi mettre pour XXX, ni comment déclarer ma fonction!
:merci: et désolée pour mes questions con, je trouve pas la réponse dans les cours ou sur internet ...

Déjà, je ne sais plus si scanf("%f") demande un float ou un double; Il faudra vérifier cela si tu persistes à utiliser scanf().
Enfin, voici l'idée générale:
Code:

1 2 3 4 5 6 7 8 9 float verif(float x, float min, float max) { while(x<min || x>max) { printf("Invalid value.The value must be between %f. and %f..Enter a new value", min, max); scanf("%f", &x); } return x; }
Mais il faudrait aussi s'assurer que le buffer d'entrée est vide. Cela peut être fait en appelant cette fonction après chaque scanf() :
Code:

1 2 3 4 5 6 7 8 9 10 void purge(void) { int c; do { c = getchar(); } while(c != '\n' && c != EOF) }
Cette fonction lit et oublie tous les caractères jusqu'à la fin de la ligne (ou jusqu'à une erreur).

14/05/2007, 16h29
SofC++

Je veux bien plus utiliser des scanf mais je ne sais pas faire autrement ....
Désolée de "persister" !! :oops:
14/05/2007, 16h33
Médinoc

Ce n'était pas un reproche, désolé de t'avoir induit en erreur.

À la place des scanf(), on préfère généralement lire une ligne complète de texte avec fgets(), puis l'analyser avec sscanf() (même problème, consulter l'aide pour savoir si %f accepte un float* ou un double*) ou la convertir simplement en double avec la fonction strtod().