begin process at 2012 05 27 19:03:11
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > RÉSOLUTION ÉQUATION DIFFERENTIELLE DU PENDULE PAR LA METHODE DE RUNGE KUTTA ORDRE 4

RÉSOLUTION ÉQUATION DIFFERENTIELLE DU PENDULE PAR LA METHODE DE RUNGE KUTTA ORDRE 4


 Information sur la source

Note :
5 / 10 - par 1 personne
5,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Maths & Algorithmes Niveau :Débutant Date de création :30/01/2004 Vu :12 235

Auteur : Jarod1980

Ecrire un message privé
Commentaire sur cette source (2)
Ajouter un commentaire et/ou une note

 Description

Ce programme permet de résoudre numeriquement une équation differentielle par la methode Runge Kutta ordre 4. Cette methode de résolution numerique donne une meilleur precision que l'algorithme d'Euler.
Vous pouvez changer dans le programme le pas TAU et les conditions initiales. Les résultats sont enregistrés dans le fichier output.
Vous pouvez vous amusez à changer les paramètres X0, MU, A et OM.
Ici dans le code source du programme XO, MU, A et OM definissent un cas chaostique pour le pendule (essayer de tracer à l'aide d'un tableur l'espace des phases xy).

Source

  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <math.h>
  • #define PI acos(-1.0)
  • #define A 3.0
  • #define OM 1.0
  • #define TAU 0.01
  • #define MU 0.3
  • #define X0 1.0
  • #define PI 2*acos(-1.0)
  • /* Fonction Runge kutta ordre 4 */
  • void rk4(double *x, double *y , double *z)
  • {
  • double f(double x, double y, double z);
  • double g(double x, double y, double z);
  • double h(double x, double y, double z);
  • double k1x,k2x,k1y,k2y,xi,yi,xi2,yi2,xi3,yi3;
  • double k3x,k3y,k4x,k4y;
  • */ Condition pour empêcher le pendule de faire un tour sur lui même */
  • if(*x>PI)(*x)=*x-DPI;
  • else if (*x<-PI)(*x)=DPI+*x;
  • /* ALGORITHME RUNGE KUTTA 4 */
  • xi = *x;
  • yi = *y;
  • zi = *z;
  • k1x = TAU * f(xi,yi,zi);
  • k1y = TAU * g(xi,yi,zi);
  • k1z = TAU * h(xi,yi,zi);
  • xi = *x + 0.5*k1x;
  • yi = *y + 0.5*k1y;
  • zi = *z + 0.5*k1z;
  • k2x = TAU * f(xi,yi,zi);
  • k2y = TAU * g(xi,yi,zi);
  • k2z = TAU * h(xi,yi,zi);
  • xi2 = *x + 0.5*k2x;
  • yi2 = *y + 0.5*k2y;
  • zi2 = *z + 0.5*k2z;
  • k3x = TAU * f(xi2,yi2,zi2);
  • k3y = TAU * g(xi2,yi2,zi2);
  • k3z = TAU * h(xi2,yi2,zi2);
  • xi3 = *x + k3x;
  • yi3 = *y + k3y;
  • zi3 = *z + k3z;
  • k4x = TAU * f(xi3,yi3,zi3);
  • k4y = TAU * g(xi3,yi3,zi3);
  • k4z = TAU * h(xi3,yi3,zi3);
  • /* INTEGRATION */
  • *x = *x + (1.0/6.0) * (k1x + k4x) + (1.0/3.0) * (k2x + k3x);
  • *y = *y + (1.0/6.0) * (k1y + k4y) + (1.0/3.0) * (k2y + k3y);
  • *z = *z + (1.0/6.0) * (k1z + k4z) + (1.0/3.0) * (k2z + k3z);
  • }
  • double f(double x, double y,double z)
  • {
  • return y;
  • }
  • double g(double x, double y,double z)
  • {
  • return A*cos(z) - sin(x) - MU*y;
  • }
  • double h(double x, double y, double z)
  • {
  • return OM;
  • }
  • /* PROGRAMME PRINCIPAL */
  • void main(void)
  • {
  • int nbrIT, i;
  • double cn1,cn2,cn3;
  • FILE *output;
  • output=fopen("donnees","w");
  • printf("\nEntrer le nombre d'itérations:);
  • scanf("%d", &nbrIT);
  • /* Conditions initiales */
  • cn1 = X0;
  • cn2 = 0.0;
  • cn3 = OM;
  • for(i=1;i<=nbrIT;i++)
  • {
  • rk4(&cn1, &cn2, &cn3); /* On appel la fonction rk4 */
  • fprintf(output,"%f %lf %lf %lf \n", i*TAU, cn1,cn2, cn3); /* On sauve périodiquement les résultats */
  • }
  • fclose(output); /* On ferme le fichier */
  • } /* fin programme */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define PI acos(-1.0)
#define A 3.0
#define OM 1.0
#define TAU 0.01
#define MU 0.3
#define X0 1.0
#define PI 2*acos(-1.0)

/* Fonction Runge kutta ordre 4 */
void rk4(double *x, double *y , double *z)
{
	double f(double x, double y, double z);
	double g(double x, double y, double z);
	double h(double x, double y, double z);
        double k1x,k2x,k1y,k2y,xi,yi,xi2,yi2,xi3,yi3;
	double k3x,k3y,k4x,k4y;

	*/ Condition pour empêcher le pendule de faire un tour sur lui même */
		if(*x>PI)(*x)=*x-DPI;
		else if (*x<-PI)(*x)=DPI+*x;

        /* ALGORITHME RUNGE KUTTA 4 */
	xi = *x;
	yi = *y;
	zi = *z;

	k1x = TAU * f(xi,yi,zi);
	k1y = TAU * g(xi,yi,zi);
	k1z = TAU * h(xi,yi,zi);

	xi = *x + 0.5*k1x;
	yi = *y + 0.5*k1y;
	zi = *z + 0.5*k1z;

	k2x = TAU * f(xi,yi,zi);
	k2y = TAU * g(xi,yi,zi);
	k2z = TAU * h(xi,yi,zi);

	xi2 = *x + 0.5*k2x;
	yi2 = *y + 0.5*k2y;
	zi2 = *z + 0.5*k2z;

	k3x = TAU * f(xi2,yi2,zi2);
	k3y = TAU * g(xi2,yi2,zi2);
	k3z = TAU * h(xi2,yi2,zi2);

	xi3 = *x + k3x;
	yi3 = *y + k3y;
	zi3 = *z + k3z;

	k4x = TAU * f(xi3,yi3,zi3);
	k4y = TAU * g(xi3,yi3,zi3);
	k4z = TAU * h(xi3,yi3,zi3);

    /* INTEGRATION */
    *x = *x + (1.0/6.0) * (k1x + k4x) + (1.0/3.0) * (k2x + k3x);
    *y = *y + (1.0/6.0) * (k1y + k4y) + (1.0/3.0) * (k2y + k3y);	
    *z = *z + (1.0/6.0) * (k1z + k4z) + (1.0/3.0) * (k2z + k3z);
}
double f(double x, double y,double z)
{
	return y;
}

double g(double x, double y,double z)
{
       return A*cos(z) - sin(x) - MU*y;
}
double h(double x, double y, double z)
{
       return OM;
}

/* PROGRAMME PRINCIPAL */
void main(void)
{
	int nbrIT, i;
	double cn1,cn2,cn3;
	FILE *output;
	output=fopen("donnees","w");

	printf("\nEntrer le nombre d'itérations:);
	scanf("%d", &nbrIT);

	/* Conditions initiales */
	cn1 = X0;
	cn2 = 0.0;
	cn3 = OM;
       
	for(i=1;i<=nbrIT;i++)
	{
		rk4(&cn1, &cn2, &cn3); /* On appel la fonction rk4 */
		fprintf(output,"%f %lf %lf %lf \n", i*TAU, cn1,cn2, cn3); /* On sauve périodiquement les résultats */
	}
	fclose(output); /* On ferme le fichier */
} /* fin programme */

 Conclusion

-


 Sources du même auteur

Source avec une capture FRACTALE NEWTON-RAPHSON VERSION GLUT
Source avec Zip FAST FOURIER TRANSFORM
TRANSFORMEE DE FOURIER DISCRETE
Source avec une capture FRACTALE TREE (ARBRE) VERSION GLUT
Source avec une capture COURBE DE GUMOWSKI & MIRA VERSION GLUT

 Sources de la même categorie

Source avec Zip UN EXAMPLE D'APPLICATION EN CUDA DE L'ALGORITHME DE SCAN POU... par oguzaras
Source avec Zip Source avec une capture CHIFFREMENT DE VIGENERE par lajouad
Source avec Zip Source avec une capture ANALYSE SYNTAXIQUE par lajouad
Source avec Zip Source avec une capture STRUCTURE D'UNE MATRICE PAR LES LISTE LINÉAIRE (NON CONTUGUS... par benzarabel
Source avec Zip Source avec une capture DESSINER UNE ARBRE BINAIRE( MODE CONSOLE): par benzarabel

Commentaires et avis

Commentaire de JCDjcd le 30/01/2004 17:15:18

J'aime bien cette source, elle montre des bonnes methodes en programmation pour resoudre des equa. diff..

Deux-tois petites choses cependant :
- pour avoir la la valeur de PI, il ne vaut pas faire l'arccos, tu met directmeent la valeur 3.1415926535 (par coeur !)
- verifier que le fichier a bien ete ouvert
- ouvir le ficheir en mode "wt" et non "w", tu ecris en texte donc ...

Commentaire de skone007 le 22/06/2007 18:16:21

Il me semble que pour PI arccos est mieu enfin si il renvoi un double. Puisque ici il boss avec des double et 3.1415926535 est pas assez précis contrairement à 3.1415926535897932. Puisque un double à 15 chiffres significatif dans l'ANSI. Corrigés moi si je me trompes.

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,421 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales