algorithme de RUNGE KUTA d'ordre 4 en langage C

[ALAHYANE]

bonjour svp j'ai un pb j'ecris ce code en langage C, mais les résultats sont toujours fausses je ss pas pourquoi.
voila le code:

/* [ programme de range kuta d'ordre 4 pour l'equation diff : y'(t)=-y+t+1
                                                             y(0)=1          t £ [0,1]
                                                                                         
                                                                                           */
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define h 0.1

 int main(){
    double y[11], ye[11], t[11], er[11],K1[11],K2[11],K3[11],K4[11],K[11];
    y[0]=1;
    t[0]=0;
    int N=10, n;
    //solutiion exacte
    for(n=0;n<N;n++) {
        t[n+1]=t[n]+h;
        ye[n+1]=exp(-t[n+1])+t[n+1];
        
      
        
    }
   
    //solution approchée par EULER
    for(n=0;n<2;n++){
   t[n+1]=t[n]+h;     
   K1[n+1]=h*(-y[n]+1+t[n]);
   K2[n+1]=h*(t[n]+(h/2)+1-y[n]-K1[n+1]/2);
   K3[n+1]=h*(t[n]+(h/2)+1-y[n]-K2[n+1]/2);
   K4[n+1]=h*(t[n]+h+1-y[n]-K3[n+1]);
   K[n+1]=(1/6)*(K1[n+1]+2*K2[n+1]+2*K3[n+1]+K4[n+1]); ( c'est là ou il ya le pb il donne toujour 0 comme calcul !!)
    y[n+1]=y[n]+K[n+1];
    er[n+1]=fabs(y[n+1]-ye[n+1])/fabs(ye[n+1]);
    printf("t[%d]= %.1f\t",n+1,t[n+1]);
   printf("ye[%.1f]=%lf\t",t[n+1],ye[n+1]);
  printf("y[%d]= %lf \t",n+1,y[n+1]);
  printf("er[%d]= %lf\n",n+1,er[n+1]);
    }
        
    system("pause");
    return 0;
}

-----

[LeMulet]

   K1[n+1]=h*(-y[n]+1+t[n]);
   K2[n+1]=h*(t[n]+(h/2)+1-y[n]-K1[n+1]/2);
   K3[n+1]=h*(t[n]+(h/2)+1-y[n]-K2[n+1]/2);
   K4[n+1]=h*(t[n]+h+1-y[n]-K3[n+1]);

en jetant un oeil vite fait, il me semble que tous les Kx[n+1] valent 0
Donc le K[n+1] vaut aussi 0

je ne connais pas l'algorithme en question, par contre pour éviter de commencer avec un K1 à 0, il faudrait avoir, par exemple, et c'est juste une piste, la formule suivante :

K1[n+1]=h*(-y[n]+1+t[n+1]);

au lieu du

K1[n+1]=h*(-y[n]+1+t[n]);

Sinon, à quoi servirait le code

t[n+1]=t[n]+h;

?
On aurait aussi bien pu le mettre à la fin de la boucle puisque le t[n+1] n'est pas employé dans les formules.
C'est le t[n] qui est employé, et il vaut 0 lorsque n=0 puisque la boucle précédente

    for(n=0;n<N;n++) {
        t[n+1]=t[n]+h;
        ye[n+1]=exp(-t[n+1])+t[n+1];

ne touche pas à t[0] (on commence à t[1] via le t[n+1] avec n commençant à 0)
Puisqu'on a écrit au tout début que :

    t[0]=0;

[LeMulet]

Ca c'était pour n=0,

mais pire, lorsque n=1 (pour n allant de 0 à 2)
Comme y[n+1] se base sur y[n] auquel on ajoute le K1[n+1] (qui vaut 0), alors y[n+1] vaut encore 0 et ainsi de suite

[lou_ibmix_xi]

K[n+1]=(1/6)*(K1[n+1]+2*K2[n+1]+2*K3[n+1]+K4[n+1]);

1 et 6 sont des entier, 1/6 donne donc 0.

[A voir en vidéo sur Futura]

[dugh]

C'est tout à fait ça. 1/6 donne toujours 0.
Il faut plutôt taper 1.0/6

[masterclassic]

Bonjour.

Une question là-dessus:
L'expression 1.0/6 donnera un nombre réel, simple précision je pense.
Les K1, K2, K3, K4 sont définis double précision, leur somme avec les multiplications par 2 sera calculé entièrement à double précision. Mais si on multiplie par la valeur simple précision de (1.0/6) on va perdre un peu par les décimales perdues par rapport à une valeur calculée avec les valeurs numériques 1 et 6 double précision.
Si on utilisait simplement une division par 6 au lieu de la multiplication par 1.0/6, n' aurait-t-on pas une meilleure approximation?

K[n+1]=(K1[n+1]+2*K2[n+1]+2*K3[n+1]+K4[n+1])/6;

Le calcul de la division double precision / entier se fera avec le code de la double précision, je pense. Est-ce correct?

[dugh]

Tout à fait pertinent, excellente remarque. Validé !

[ALAHYANE]

merciii bcp les amis, la faute était la multiplication (1/6)