Discussion :

[nevertheless]

bonjour, je suis nouveau ici
je suis actuellement en 1er année d'école d'ingénieur et j'ai un problème sur l'un de mes TP de C.
Le sujet traite de la résolution d'une équation différentielle par la méthode de Runge-Kutta...enfin la n'est pas le problème.

j'ai deux fonctions :

Code :

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

1
2
double f(double z, double v, double t)
double g(double z, double v, double t)

et j'ai déclaré comme dit dans mon sujet "un nouveau type correspondant a un pointeur sur une fonction renvoyant un double et recevant 3 paramètres"

Code :

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

typedef double *fonc(double z, double v, double t);

J'espère que le problème ne vient pas d'une mauvaise déclaration du nouveau type.

Ensuite j'ai une fonction rk4 qui utilise les fonctions f et g.

Dans mon programme principal je souhaite appeler cette fonction rk4, mais je ne sais pas sur quoi faire pointer mon nouveau type 'fonc'

si joint mon programme (non fini).
merci de votre aide.

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
119
120
121
122
123
124
125
126
127
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
/* Déclaration des variables du problèmes */
const double m=3;
const double p=1.22;
const double S=0.3;
const double alpha0=10;
const double k=980;
const double Pi=3.141592654;
 
int vent; /*Permet de choisir le type de vent*/
double coeffw; /*coefficient devant w*/
double alpha;
 
/* Convertit un angle en degré */
double rad2deg(double angle)
{
       return angle*180/Pi;
}
 
/* Convertit un angle en radian */
double deg2rad(double angle)
{
       return angle*Pi/180;
}
 
/* fonction créant un vent sinusoidal */
double ventSinus(double t)
{
       double u,w0=sqrt(k/m);
       if(t <= 0) u=0;
       else u=7.5+1.5*sin(coeffw*w0*t);
       return u;
}
 
/* fonction créant un vent de type échelon */
double ventEchelon(double t)
{
       double u;
       if(t<1) u=0;
       else
       {
             if((1<=t) && (t<4)) u=1.5;
             else u=0;
       }
       return u;
 
}
 
/* calcul en coefficient de portance en fonction de l'angle */
double coeffPortance(double angle)
{
       double Cz,a=deg2rad(angle);
       if(-18<=angle && angle<=18) Cz=2*Pi*a;
       else Cz=0;
       return Cz;
}
 
/* fonction de la 1er eq différentielle */
double f(double z, double v, double t)
{
       return v;
}
 
/* fonction de la 2er eq différentielle */
double g(double z, double v, double t)
{
       double Cz, u;
       if(vent==1) u=ventSinus(t);
       else u=ventEchelon(t);   
       alpha=alpha0-atan(v/u);
       Cz=coeffPortance(alpha);
       return Cz*p*S*u*sqrt(u*u+v*v)/(2*m)-k*z/m;
}
 
typedef double *fonc(double z, double v, double t);
 
/* fonction de Runge-Kutta utilisant les fonctions f et g */
/* et permettent de définir z(n+1) en fonction de z(n) */
/* idem pour u(n+1) */
void rk4(double *z, double *v, double *t, double dt, fonc f, fonc g)
{
     double kz1=*f(*z,*v,*t)*dt;
     double kv1=*g(*z,*v,*t)*dt;
     double kz2=*f(*z+kz1/2,*v+kv1/2,*t+dt/2)*dt;
     double kv2=*g(*z+kz1/2,*v+kv1/2,*t+dt/2)*dt;
     double kz3=*f(*z+kz2/2,*v+kv2/2,*t+dt/2)*dt;
     double kv3=*g(*z+kz2/2,*v+kv2/2,*t+dt/2)*dt;
     double kz4=*f(*z+kz3,*v+kv3,*t+dt)*dt;
     double kv4=*g(*z+kz3,*v+kv3,*t+dt)*dt;
 
     *z=*z+(kz1+2*kz2+2*kz3+kz4)/6;
     *v=*v+(kv1+2*kv2+2*kv3+kv4)/6;
}
 
/* programme principal */
int main()
{
     FILE *fp;
     double *pz,*pv,*pt;
     double z,v,t,dt=0.1;
     fonc pf,pg;
     z=0;v=0;
     pz=&z;pv=&v;pt=&t;
 
 
     printf("type de vent :\n 1 : vent sinusoidal\n 2 : vent indiciel\nChoix ? ");
     scanf("%d",&vent);
     if(vent!=1 && vent!=2){
         printf("erreur");
         return 0;
     }
 
     printf("\nValeur de w :\nw=k.w0 avec k=");
     scanf("%lf",&coeffw);
 
     /* Appel de rk4 avec les bons paramètres.... */
 
 
 
 
  system("PAUSE");	
  return 0;
}

[hegros]

Il faut les initialiser de la sorte

Code :

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

fonc pf=f, pg=g;

pour rk4 qui attends 2 fonc tu pourras utiliser pf et pg

[Emmanuel Delahaye]

bonjour, je suis nouveau ici
je suis actuellement en 1er année d'école d'ingénieur et j'ai un problème sur l'un de mes TP de C.
Le sujet traite de la résolution d'une équation différentielle par la méthode de Runge-Kutta...enfin la n'est pas le problème.

j'ai deux fonctions :

Code :

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

1
2
double f(double z, double v, double t)
double g(double z, double v, double t)

et j'ai déclaré comme dit dans mon sujet "un nouveau type correspondant a un pointeur sur une fonction renvoyant un double et recevant 3 paramètres"

Code :

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

typedef double *fonc(double z, double v, double t);

Attention, les fonction f et g retournent un double et non un double*.

KISS :

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
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
 
/* http://delahaye.emmanuel.free.fr/clib */
#include "ed/inc/prt.h"
 
#include <stdio.h>
#include <math.h>
 
/* Déclaration des variables du problèmes */
#define  M 3.0
#define  P 1.22
#define  S 0.3
#define  ALPHA0 10.0
#define  K 980.0
#define  PI 3.141592654
 
typedef double fonc (int vent, double coeffw, double z, double v, double t);
 
/* Convertit un angle en degré */
double rad2deg (double angle)
{
   return angle * 180 / PI;
}
 
/* Convertit un angle en radian */
double deg2rad (double angle)
{
   return angle * PI / 180;
}
 
/* fonction créant un vent sinusoidal */
double ventSinus (double t, double coeffw)
{
   double u, w0 = sqrt (K / M);
   if (t <= 0)
      u = 0;
   else
      u = 7.5 + 1.5 * sin (coeffw * w0 * t);
   return u;
}
 
/* fonction créant un vent de type échelon */
double ventEchelon (double t)
{
   double u;
   if (t < 1)
      u = 0;
   else
   {
      if ((1 <= t) && (t < 4))
         u = 1.5;
      else
         u = 0;
   }
   return u;
 
}
 
/* calcul en coefficient de portance en fonction de l'angle */
double coeffPortance (double angle)
{
   double Cz, a = deg2rad (angle);
   if (-18 <= angle && angle <= 18)
      Cz = 2 * PI * a;
   else
      Cz = 0;
   return Cz;
}
 
/* fonction de la 1er eq différentielle */
double f (int vent, double coeffw, double z, double v, double t)
{
   return v;
}
 
/* fonction de la 2er eq différentielle */
double g (int vent, double coeffw, double z, double v, double t)
{
   double Cz, u;
   if (vent == 1)
      u = ventSinus (t, coeffw);
   else
      u = ventEchelon (t);
   {
      double alpha = ALPHA0 - atan (v / u);
      Cz = coeffPortance (alpha);
   }
   return Cz * P * S * u * sqrt (u * u + v * v) / (2 * M) - K * z / M;
}
 
/* fonction de Runge-Kutta utilisant les fonctions f et g */
/* et permettent de définir z(n+1) en fonction de z(n) */
/* idem pour u(n+1) */
void rk4 (int vent, double coeffw, double *z, double *v, double *t, double dt,
          fonc * f, fonc * g)
{
   double kz1 = f (vent, coeffw, *z, *v, *t) * dt;
   double kv1 = g (vent, coeffw, *z, *v, *t) * dt;
   double kz2 =
      f (vent, coeffw, *z + kz1 / 2, *v + kv1 / 2, *t + dt / 2) * dt;
   double kv2 =
      g (vent, coeffw, *z + kz1 / 2, *v + kv1 / 2, *t + dt / 2) * dt;
   double kz3 =
      f (vent, coeffw, *z + kz2 / 2, *v + kv2 / 2, *t + dt / 2) * dt;
   double kv3 =
      g (vent, coeffw, *z + kz2 / 2, *v + kv2 / 2, *t + dt / 2) * dt;
   double kz4 = f (vent, coeffw, *z + kz3, *v + kv3, *t + dt) * dt;
   double kv4 = g (vent, coeffw, *z + kz3, *v + kv3, *t + dt) * dt;
 
   *z = *z + (kz1 + 2 * kz2 + 2 * kz3 + kz4) / 6;
   *v = *v + (kv1 + 2 * kv2 + 2 * kv3 + kv4) / 6;
}
 
/* programme principal */
int main (void)
{
   int vent = 0;                /* Permet de choisir le type de vent */
   double coeffw = 0;           /* coefficient devant w */
 
   double dt = 0.1;
   double t = 0;
   double z = 0;
   double v = 0;
 
   printf ("type de vent :\n"
           " 1 : vent sinusoidal\n" " 2 : vent indiciel\n" "Choix ? ");
   scanf ("%d", &vent);
   if (vent != 1 && vent != 2)
   {
      printf ("erreur");
      return 0;
   }
 
   printf ("\nValeur de w :\nw=k.w0 avec k=");
   scanf ("%lf", &coeffw);
 
   /* Appel de rk4 avec les bons paramètres.... */
 
   rk4 (vent, coeffw, &z, &v, &t, dt, f, g);
 
   PRT_D (z);
   PRT_D (v);
 
   return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
type de vent :
 1 : vent sinusoidal
 2 : vent indiciel
Choix ? 1
 
Valeur de w :
w=k.w0 avec k=12
z            = 0.01
v            = 0.17
 
Press ENTER to continue.

[nevertheless]

ah ok merci bien j'ai compris mon erreur je pense.
merci a tout les deux pour avoir répondu aussi vite

[diogene]

nevertheless :

et j'ai déclaré comme dit dans mon sujet "un nouveau type correspondant a un pointeur sur une fonction renvoyant un double et recevant 3 paramètres"

Code :

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

typedef double *fonc(double z, double v, double t);

Ceci définit un type fonction renvoyant une adresse de double

Code :

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

typedef double fonc(double z, double v, double t);

définit un type fonction renvoyant un double

Code :

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

typedef double (*fonc)(double z, double v, double t);

définit un type adresse de fonction renvoyant un double (pointeur sur fonction)