Sélection d'un environnement de développement. où y est la fonction souhaitée, x est la variable indépendante, f(x,y) est une fonction continue de x et y. Cependant, il n'est pas possible d'obtenir une solution analytique de cette équation pour une fonction f suffisamment arbitraire, et seulement pour certains cas particuliers
Soit une équation différentielle du premier ordre avec la condition initiale y(x 0)=y 0. Choisissons l'étape h et introduisons la notation :
x i = x 0 + ih et y i = y(x i), où i = 0, 1, 2, ... .
Semblable à la méthode décrite ci-dessus, la solution est faite
équation différentielle. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge-Kutta du quatrième ordre, les valeurs successives y i de la fonction y souhaitée sont déterminées par la formule :
y je+1 = y je +?y je
où je = 0, 1, 2...
Y=(k1+2*k2+2*k3+k4)/6
les nombres k1, k2, k3, k4 à chaque étape sont calculés à l'aide des formules :
k1 = h*f(x je, y je)
k2 = f (x je +h/2, y je +k1 /2)*h
k3 = F(x je +h/2, y je +k2 /2)*h
k4 = F(x je +h, y je +k3)*h
Il s’agit d’une méthode explicite en quatre étapes avec 4 ordres de précision.
Un organigramme de la procédure de résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta est présenté à la figure 6.
F(x, y) - une fonction donnée - doit être décrite séparément.
Paramètres d'entrée :
X0, XK - initial et final
valeurs d'indépendance
variable;
Y0 - valeur y 0 de la condition initiale
N - nombre de segments de partition ;
Paramètres de sortie :
Y - tableau de valeurs de la solution requise
aux nœuds de la grille.
Algorithme pour résoudre le problème
Solution dans MathCAD
Liste des programmes en langage Visual Basic
Dim xr(), yr(), xe(), ye(), xo(), yo() en tant que simple
Privé x0, y0, h, xk, k1, k2, c, k3, k4, yd comme simple
Privé n, i sous forme d'entier
Fonction publique f (ByVal a, ByVal b) comme unique
f = -(une - b) / une
Sous-bouton privé Button1_Click (expéditeur ByVal en tant que System.Object, ByVal et en tant que System.EventArgs) gère Button1.Click
x0 = Val(TexteBox1.Texte)
xk = Val(TexteBox2.Texte)
y0 = Val(TexteBox4.Texte)
h = Val(TexteBox3.Texte)
n = (xk - x0) /h
c = y0 / x0 + Math.Log(x0)
DataGridView1.ColumnCount = 4
DataGridView1.RowCount = n + 2
DataGridView1.Item(0, 0).Value = "x"!}
DataGridView1.Item(1, 0).Value = "Général"!}
DataGridView1.Item(2, 0).Value = "Euler M"!}
DataGridView1.Item(3, 0).Value = "Runge Kutt"!}
Pour i = 0 À n - 1
xe(i) = Math.Round((xe(0) + i * h), 2)
vous(i + 1) = vous(i) + h * f(xe(i) + h / 2, vous(i) + h / 2 * f(xe(i), vous(i)))
DataGridView1.Item(2, 1).Value = vous(0)
DataGridView1.Item(0, 1).Value = xe(0)
DataGridView1.Item(0, i + 1).Value = xe(i)
DataGridView1.Item(2, i + 1).Value = Str(ye(i))
Pour i = 0 À n - 1
xr(i) = Math.Round((xe(0) + i * h), 2)
k1 = h * f(xr(i), an(i))
k2 = h * f(xr(i) + h / 2, an(i) + k1 / 2)
k3 = h * f(xr(i) + h / 2, an(i) + k2 / 2)
k4 = h * f(xr(i) + h, an(i) + k3)
yd = (k1 + 2 * k2 + 2 * k3 + k4) / 6
année(i + 1) = année(i) + yd
DataGridView1.Item(3, 1).Value = année(0)
DataGridView1.Item(3, i + 1).Value = Str(an(i))
Pour i = 0 À n - 1
xo(i) = Math.Round((xe(0) + i * h), 2)
yo(i) = xo(i) * (c - Math.Log(xo(i)))
DataGridView1.Item(1, 1).Value = yo(0)
DataGridView1.Item(1, i + 1).Value = Str(yo(i))
Chart1.Series.Add("Solution générale")
Chart1.Series("Solution générale").ChartType = SeriesChartType.Line
Pour i = 0 À n - 1
Chart1.Series("Solution générale").Points.AddXY(xo(i), yo(i))
Chart1.Series("Solution générale").ChartArea = "ChartArea1"
Chart1.Series.Add("Euler M")
Chart1.Series("Euler M").ChartType = SeriesChartType.Point
Pour i = 0 À n - 1
Chart1.Series("Euler M").Points.AddXY(xe(i), vous(i))
Chart1.Series("Euler M").ChartArea = "ChartArea1"
Chart1.Series("Euler M").Couleur = Couleur.Bleu
Chart1.Series.Add("Runge Kutt")
Chart1.Series("Runge Kutt").ChartType = SeriesChartType.Line
Pour i = 0 À n - 1
Chart1.Series("Runge Kutt").Points.AddXY(xr(i), an(i))
Chart1.Series("Runge Kutt").ChartArea = "ChartArea1"
Chart1.Series("Runge Kutt").Color = Couleur.Vert
Soumettre votre bon travail à la base de connaissances est facile. Utilisez le formulaire ci-dessous
Les étudiants, étudiants diplômés, jeunes scientifiques qui utilisent la base de connaissances dans leurs études et leur travail vous seront très reconnaissants.
Publié sur http://www.allbest.ru/
Établissement d'enseignement AUTONOME de l'État FÉDÉRAL Formation professionnelle supérieure
"NATIONAL DE L'ÉTAT DE BELGOROD
UNIVERSITÉ DE RECHERCHE"
Institut des technologies de l'ingénierie et des sciences naturelles
Département des systèmes d'information mathématiques et logiciels
implémentation logicielle de résolution d'un système d'équations différentielles ordinaires à l'aide de la méthode Runge-Kutta du 4ème ordre
Cours
dans la discipline "Méthodes de calcul"
étudiant à temps plein
domaines de formation 010500.62
"Soutien mathématique et administration
systèmes d'informations"
Groupe de 3ème année 07001302
Dankov Nikolaï Alekseïevitch
BELGOROD 2016
Introduction
1. Partie théorique
1.1 Équation différentielle ordinaire du premier ordre. Problème de Cauchy
1.2 L'essence de la méthode Runge-Kutta
1.3 Sélection d'un environnement de développement
2. Partie pratique
2.1 Implémentation logicielle de la méthode Runge-Kutta du 4ème ordre
3. Tests
3.1 Exemple
Conclusion
Application
Introduction
Lorsqu'ils étudient une grande variété de phénomènes dans le monde environnant, liés à la fois aux sciences exactes et aux sciences humaines, les chercheurs sont souvent confrontés au fait que les dépendances fonctionnelles entre les quantités sont trouvées à partir d'équations dans lesquelles les dérivées des fonctions souhaitées sont présent. Les plus simples d'entre eux sont ceux qui ne contiennent que des dérivées du premier ordre et peuvent s'écrire sous la forme
= f(x, y) ,
où y est la fonction souhaitée, x est la variable indépendante, f(x,y) est une fonction continue de x et y. Cependant, il n'est pas possible d'obtenir une solution analytique de cette équation pour une fonction f assez arbitraire, et seulement pour quelques cas particuliers, que l'on retrouve dans la littérature de référence.
En raison du développement rapide de la technologie informatique électronique au cours des dernières décennies, il est devenu possible d’utiliser des méthodes mathématiques approchées pour résoudre des problèmes de ce type. L'une de ces approches s'appelle la méthode Runge-Kutta et combine tout un groupe de modifications liées à la méthode de leur préparation.
Le but du cours : étudier la méthode Runge-Kutta du 4ème ordre pour résoudre des équations différentielles ordinaires.
Énoncé du problème : il est nécessaire de créer un programme permettant de résoudre des équations différentielles ordinaires en utilisant la méthode Runge-Kutta du 4ème ordre.
Le travail de cours se compose de 3 sections, contient 6 dessins, 3 listes, 1 annexe et 18 pages.
1. Partie théorique
1.1 Équation différentielle ordinaire du premier ordre. Problème de Cauchy
Pour plus de simplicité, nous considérons un espace bidimensionnel de variables x et y et un ensemble ouvert G qui lui appartient. Soit une fonction continûment différentiable f(x, y) définie sur cet ouvert et étant donné l'équation
= f(x, y) (1)
D'après le théorème d'existence et d'unicité, pour tout point (x 0 ,y 0) ?G il existe une solution y = y(x), définie sur un certain intervalle (x 0 -d, x 0 +d), satisfaisant le condition y(x 0) = y 0, telle que les points (x,y(x)) ?G et y` x ? f(x, y(x)), et cette solution sera unique. Le problème de l'équation (1) avec la condition initiale y(x 0) = y 0 (problème de Cauchy) est de trouver la fonction y(x) qui transforme à la fois l'équation (1) et la condition initiale en une identité. Supposons que les valeurs prises par la variable indépendante x appartiennent à l'intervalle (X 0, X N) et écrivons le problème de Cauchy :
(2)
Divisons le segment [X 0, X N] en N parties pour que x n +1 - x n = h n,
n = 0,…,N-1. Dans ce qui suit, sans perte de généralité, nous considérerons le cas où la partition est uniforme, c'est-à-dire tout h n = h = = const,
n = 0 ,… ,N-1.
1.2 L'essence de la méthode Runge-Kutta
Les méthodes Runge-Kutta sont largement utilisées pour résoudre des équations différentielles. La méthode la plus utilisée est la méthode du 4ème ordre.
(3)
(4)
(5)
- un paramètre qui détermine la valeur de la fonction à proximité d'un point du domaine de définition.
Méthode courante du 4ème ordre :
(6)
(7)
(8)
(9)
(10)
L'erreur de la formule (10) est proportionnelle à h 5 .
Cette méthode est beaucoup plus précise que les méthodes d'Euler, mais nécessite également plus de calculs : la position du point (x i +1, y i +1) est déterminée en calculant la valeur de la fonction f (x,y) 4 fois. Avec l'avènement des ordinateurs, cet inconvénient a cessé d'être significatif et la méthode Runge-Kutta du 4ème ordre est extrêmement largement utilisée dans la pratique.
Le nombre de micro-segments en lesquels le segment d'origine est divisé est déterminé par la précision de calcul requise. Pour obtenir la précision requise, le problème est résolu plusieurs fois en doublant successivement le nombre de microsegments n. La précision est considérée comme atteinte si, avec le nombre initial et doublé n, les valeurs de y i et y 2i (aux points coïncidents x) ne diffèrent pas de plus d'un montant donné :
, je =0, ..,n, (11)
où p est l’ordre de précision de la méthode.
La méthode Rugne-Kutta possède les propriétés suivantes :
1. La méthode se déroule en une seule étape (pour trouver, il faut des informations sur le point précédent)
2. Ne nécessite pas le calcul des dérivées de f(x,y), mais nécessite le calcul de la fonction elle-même
3. A une petite erreur
1.3 Sélection d'un environnement de développement
C++ Builder est un produit logiciel, un outil de développement rapide d'applications (RAD), un environnement de programmation intégré (IDE), un système utilisé par les programmeurs pour développer des logiciels dans le langage de programmation C++. Ce produit vous permet de créer à la fois des applications console et des applications avec une interface graphique.
Microsoft Visual Studio est une gamme de produits Microsoft qui comprend un environnement de développement logiciel intégré et un certain nombre d'autres outils. À l'aide de ce produit, vous pouvez développer des applications console, des applications GUI, ainsi que des sites Web, des applications Web et des services Web en code natif et géré pour toutes les plates-formes prises en charge par Windows, Windows Mobile, Windows CE, NET Framework, Xbox, Windows Phone. .NET Compact Framework et Silverlight.
Pour réaliser cette tâche, le produit logiciel C++ Builder a été choisi. Puisqu'il est plus facile à utiliser et répond à toutes les exigences nécessaires pour créer une application console.
2. Partie pratique
2.1 Implémentation logicielle de la méthode Prknge-Kutta du 4ème ordre
programmation de Cauchy équation différentielle
Le développement du programme commence par une description des fonctions. Pour ce faire, nous utilisons l'instruction switch.
Listing 1 « description des fonctions »
double s = 0 ;
interrupteur(astuce)(
cas 1 : (
casser; )
cas 2 : (
casser; )
cas 3 : (
casser; )
cas 4 : (
s = a*(b*x+c*y)/(e*f)*d;
casser; )
défaut:
( s =0; )
}
retourner s ;
}
Vient ensuite la déclaration et l'initialisation des variables qui participent au processus de calcul : coefficients d'équation, limites de segments, pas, condition initiale.
Lorsque toutes les données nécessaires ont été obtenues, nous procédons directement à la résolution de l'ODE en utilisant la méthode Runge-Kutta du 4ème ordre.
Listing 2 « implémentation logicielle de résolution d'EDO à l'aide de la méthode Runge-Kutta
4ème commande"
pour (i=0;i<=n;i++) {
x=x[i]+h;
cout<<"y"<
}
3. Tests
Après avoir lancé le programme, nous verrons les équations proposées à la sélection.
Riz. 1 "sélection d'équation"
Si vous entrez un nombre qui ne correspond pas aux numéros d'équation présentés, le programme réagira à cela.
Riz. 2 "saisie d'un paramètre incorrect"
Après avoir sélectionné l'équation souhaitée, entrez les coefficients.
Riz. 3 «saisie des coefficients»
Ensuite, on rentre le début et la fin du segment sur lequel le calcul sera effectué, l'étape et la condition initiale. Le dernier paramètre doit être sélectionné par l'utilisateur indépendamment.
Riz. 4 "saisie des paramètres requis"
Après avoir terminé le calcul, le programme affiche la solution.
Riz. 5 « sortie du résultat »
3.1 Exemple
Résolvez le problème de Cauchy :
sur le segment. Trouver une solution sur une grille uniforme avec un pas de 0,1
Solution. Puisque f(x,y) = x + y, on obtient
= + ,
= ++ ,
= ++ ,
= +h+ ,
= +() ,
= +h ,
pour les valeurs i = 1, 2, 3, 4.
En supposant =0, = 1, on trouve successivement :
pour je = 1
= 0,1(0 +1) = 0,1 ,
= 0,1(0 + 0,05 +1 + 0,05) = 0,11 ,
= 0,1(0 + 0,05 +1 + 0,055) = 0,1105 ,
= 0,1(0 + 0,1 +1 + 0,1105) = 0,121050 ,
= 1 + *(0,1 + 2*0,11+2*0,1105 + 0,12105) = 1,110342 ,
= 0+0,1=0.1 ,
à je = 2
= 0,1*(0 + 1,110342) = 0,121034 ,
= 0,1*(0,1 + 0,05 +1,110342 + 0,0605171) = 0,1320859 ,
= 0,1*(0,1 + 0,05+1,110342 + 0,06604295) = 0,1326385 ,
= 0,1*(0,1 + 0,1 + 1,110342 + 0,11326385)= 0,1442980 ,
= 1,110342 + *(0,121034 + 2*0,1320859+2*0,1326385 + 0,1442980) = 1,242805 ,
= 0,1+0,1 ,
Nous obtenons ensuite :
avec je = 3 = 0,3, =1,399717,
à je = 4 = 0,4, = 1,583648.
L'erreur de la solution obtenue ne dépasse pas la valeur
|y 4 - q(x 4) | ? 0,000001.
Pour plus de clarté, le tableau 1 présente des solutions numériques du même problème de Cauchy en utilisant les méthodes d'Euler, Euler-Cauchy et Runge-Kutta.
Tableau 1 Solutions numériques du problème de Cauchy utilisant différentes méthodes
Valeurs trouvées par la méthode
Solution exacte
c(x je)=2- x je -1
Euler - Cauchy
Runge - Kutta
Comparons maintenant les résultats obtenus avec les calculs de notre programme.
Riz. 6 « résultat du programme »
Comme le montre l'exemple, la précision du calcul est maintenue jusqu'à la cinquième décimale.
Conclusion
Au cours du cours, la tâche assignée a été réalisée, à savoir, un programme a été compilé qui permet de résoudre des équations différentielles ordinaires à l'aide de la méthode Runge-Kutta du 4ème ordre.
Lors des tests du programme, des résultats ont été obtenus qui montrent que les résultats de la solution par la méthode Runge-Kutta du 4ème ordre coïncident, avec une précision suffisante, avec ceux analytiques.
Liste des sources utilisées
1. Berezin I.S., Zhidkov N.P., Méthodes informatiques : T.2 - M. : GIFML, 1960. - 620 p.
2. Bakhvalov N. S., Zhidkov N. P., Kobelkov G. M. Méthodes numériques. - M. : Binom, 2001 - p. 363-375.
3. Kopchenova N.V., Maron I.A., Mathématiques computationnelles dans des exemples et des problèmes - M. : Nauka, 1972. - 368 p.
4. https://ru.wikipedia.org/wiki/Microsoft_Visual_Studio
5. https://ru.wikipedia.org/wiki/C%2B%2B_Builder
Annexe 1
#inclure
#inclure
#inclure
#inclure
en utilisant l'espace de noms std ;
char* rus(const char* texte) (
char *buffRus=nouveau char;
CharToOem(texte, buffRus);
retourner buffRus ;
}
double fonction (pointe int, double x, double y, double a, double b, double c, double d, double e, double f) (
double s = 0 ;
interrupteur (pointe) (
cas 1 : (
s = a+b*(y*c*sin(d*x))-(e*y*f*y);
casser; )
cas 2 : (
s =a*cos(b*x+c*y)+d*(e*x-f*y);
casser; )
cas 3 : (
s=((a*cos(b*x)/(x+c))-(d*y*e*y)*f);
casser; )
cas 4 : (
s = a*(b*x+c*y)/(e*f)*d;
casser; )
défaut:
( s =0; )
}
retourner s ;
}
int main() (
int pointe, je = 0, n = 0 ;
double h=0,0, ot1=1,0, ot2=0,0, k1=0,0, k2=0,0, k3=0,0, k4=0,0, a=1,0, b=1,0, c=1,0, d=1,0, e=1,0, f =1,0, rés=0,0 ;
indicateur booléen = 0 ;
cout<
cout<<" 1. y"=a+b*(y*c*sin(d*x))-(e*y*f*y)\n 2. y"=a*cos(b*x+c*y)+d*(e*x-f*y)\n 3. y"=((a*cos(b*x)/(x+c))-(d*y*e*y)*f)\n 4. y"=a*(b*x+c*y)/(e*f)*d\n";
tandis que (!flag) (
cout<
cin>>astuce ;
if((astuce == 1) || (astuce == 2) || (astuce == 3) || (astuce == 4))(
drapeau=1 ; )
autre(
cout<
}
}
cout<
cout<<" a= ";cin>>une ;
cout<<" b= ";cin>>b;
cout<<" c= ";cin>>c;
cout<<" d= ";cin>>d;
cout<<" e= ";cin>>e;
cout<<" f= ";cin>>f;
cout<
tandis que (ot1>ot2) (
cout<
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je
la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant. Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire
}
3. Tests
Après avoir lancé le programme, nous verrons les équations proposées à la sélection.
Riz. 1 "sélection d'équation"
Si vous entrez un nombre qui ne correspond pas aux numéros d'équation présentés, le programme réagira à cela.
Riz. 2 "saisie d'un paramètre incorrect"
Après avoir sélectionné l'équation souhaitée, entrez les coefficients.
Riz. 3 «saisie des coefficients»
Ensuite, on rentre le début et la fin du segment sur lequel le calcul sera effectué, l'étape et la condition initiale. Le dernier paramètre doit être sélectionné par l'utilisateur indépendamment.
Riz. 4 "saisie des paramètres requis"
Après avoir terminé le calcul, le programme affiche la solution.
Riz. 5 « sortie du résultat »
3.1 Exemple
Résolvez le problème de Cauchy :
sur le segment. Trouver une solution sur une grille uniforme avec un pas de 0,1
Solution. Puisque f(x,y) = x + y, on obtient
= + ,
= ++ ,
= ++ ,
= +h+ ,
= +() ,
= +h ,
pour les valeurs i = 1, 2, 3, 4.
En supposant =0, = 1, on trouve successivement :
pour je = 1
= 0,1(0 +1) = 0,1 ,
= 0,1(0 + 0,05 +1 + 0,05) = 0,11 ,
= 0,1(0 + 0,05 +1 + 0,055) = 0,1105 ,
= 0,1(0 + 0,1 +1 + 0,1105) = 0,121050 ,
= 1 + *(0,1 + 2*0,11+2*0,1105 + 0,12105) = 1,110342 ,
= 0+0,1=0.1 ,
à je = 2
= 0,1*(0 + 1,110342) = 0,121034 ,
= 0,1*(0,1 + 0,05 +1,110342 + 0,0605171) = 0,1320859 ,
= 0,1*(0,1 + 0,05+1,110342 + 0,06604295) = 0,1326385 ,
= 0,1*(0,1 + 0,1 + 1,110342 + 0,11326385)= 0,1442980 ,
= 1,110342 + *(0,121034 + 2*0,1320859+2*0,1326385 + 0,1442980) = 1,242805 ,
= 0,1+0,1 ,
Nous obtenons ensuite :
avec je = 3 = 0,3, =1,399717,
à je = 4 = 0,4, = 1,583648.
L'erreur de la solution obtenue ne dépasse pas la valeur
|y 4 - q(x 4) | ? 0,000001.
Pour plus de clarté, le tableau 1 présente des solutions numériques du même problème de Cauchy en utilisant les méthodes d'Euler, Euler-Cauchy et Runge-Kutta.
Tableau 1 Solutions numériques du problème de Cauchy utilisant différentes méthodes
|
Valeurs trouvées par la méthode |
Solution exactec(x je)=2- x je -1 |
|||||
|
Euler - Cauchy |
Runge - Kutta |
|||||
Comparons maintenant les résultats obtenus avec les calculs de notre programme.
Riz. 6 « résultat du programme »
Comme le montre l'exemple, la précision du calcul est maintenue jusqu'à la cinquième décimale.
Conclusion
Au cours du cours, la tâche assignée a été réalisée, à savoir, un programme a été compilé qui permet de résoudre des équations différentielles ordinaires à l'aide de la méthode Runge-Kutta du 4ème ordre.
Lors des tests du programme, des résultats ont été obtenus qui montrent que les résultats de la solution par la méthode Runge-Kutta du 4ème ordre coïncident, avec une précision suffisante, avec ceux analytiques.
Liste des sources utilisées
1. Berezin I.S., Zhidkov N.P., Méthodes informatiques : T.2 - M. : GIFML, 1960. - 620 p.
2. Bakhvalov N. S., Zhidkov N. P., Kobelkov G. M. Méthodes numériques. - M. : Binom, 2001 - p. 363-375.
3. Kopchenova N.V., Maron I.A., Mathématiques computationnelles dans des exemples et des problèmes - M. : Nauka, 1972. - 368 p.
4. https://ru.wikipedia.org/wiki/Microsoft_Visual_Studio
5. https://ru.wikipedia.org/wiki/C%2B%2B_Builder
Annexe 1
#inclure
#inclure
#inclure
#inclure
en utilisant l'espace de noms std ;
char* rus(const char* texte) (
char *buffRus=nouveau char;
CharToOem(texte, buffRus);
retourner buffRus ;
}
double fonction (pointe int, double x, double y, double a, double b, double c, double d, double e, double f) (
double s = 0 ;
interrupteur (pointe) (
cas 1 : (
s = a+b*(y*c*sin(d*x))-(e*y*f*y);
casser; )
cas 2 : (
s =a*cos(b*x+c*y)+d*(e*x-f*y);
casser; )
cas 3 : (
s=((a*cos(b*x)/(x+c))-(d*y*e*y)*f);
casser; )
cas 4 : (
s = a*(b*x+c*y)/(e*f)*d;
casser; )
défaut:
( s =0; )
}
retourner s ;
}
int main() (
int pointe, je = 0, n = 0 ;
double h=0,0, ot1=1,0, ot2=0,0, k1=0,0, k2=0,0, k3=0,0, k4=0,0, a=1,0, b=1,0, c=1,0, d=1,0, e=1,0, f =1,0, rés=0,0 ;
indicateur booléen = 0 ;
cout<
cout<<" 1. y"=a+b*(y*c*sin(d*x))-(e*y*f*y)\n 2. y"=a*cos(b*x+c*y)+d*(e*x-f*y)\n 3. y"=((a*cos(b*x)/(x+c))-(d*y*e*y)*f)\n 4. y"=a*(b*x+c*y)/(e*f)*d\n";
tandis que (!flag) (
cout<
cin>>astuce ;
if((astuce == 1) || (astuce == 2) || (astuce == 3) || (astuce == 4))(
drapeau=1 ; )
autre(
cout<
}
}
cout<
cout<<" a= ";cin>>une ;
cout<<" b= ";cin>>b;
cout<<" c= ";cin>>c;
cout<<" d= ";cin>>d;
cout<<" e= ";cin>>e;
cout<<" f= ";cin>>f;
cout<
tandis que (ot1>ot2) (
cout<
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je
la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant. Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire
cout<<" 1. y"=a+b*(y*c*sin(d*x))-(e*y*f*y)\n 2. y"=a*cos(b*x+c*y)+d*(e*x-f*y)\n 3. y"=((a*cos(b*x)/(x+c))-(d*y*e*y)*f)\n 4. y"=a*(b*x+c*y)/(e*f)*d\n";
tandis que (!flag) (
cout<
cin>>astuce ;
if((astuce == 1) || (astuce == 2) || (astuce == 3) || (astuce == 4))(
drapeau=1 ; )
autre(
cout<
}
}
cout<
cout<<" a= ";cin>>une ;
cout<<" b= ";cin>>b;
cout<<" c= ";cin>>c;
cout<<" d= ";cin>>d;
cout<<" e= ";cin>>e;
cout<<" f= ";cin>>f;
cout<
tandis que (ot1>ot2) (
cout<
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je
la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant. Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire
cin>>astuce ;
if((astuce == 1) || (astuce == 2) || (astuce == 3) || (astuce == 4))(
drapeau=1 ; )
autre(
cout<
}
}
cout<
cout<<" a= ";cin>>une ;
cout<<" b= ";cin>>b;
cout<<" c= ";cin>>c;
cout<<" d= ";cin>>d;
cout<<" e= ";cin>>e;
cout<<" f= ";cin>>f;
cout<
tandis que (ot1>ot2) (
cout<
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je
la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant. Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire
}
}
cout<
cout<<" a= ";cin>>une ;
cout<<" b= ";cin>>b;
cout<<" c= ";cin>>c;
cout<<" d= ";cin>>d;
cout<<" e= ";cin>>e;
cout<<" f= ";cin>>f;
cout<
tandis que (ot1>ot2) (
cout<
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je
la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant. Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire
cout<<" a= ";cin>>une ;
cout<<" b= ";cin>>b;
cout<<" c= ";cin>>c;
cout<<" d= ";cin>>d;
cout<<" e= ";cin>>e;
cout<<" f= ";cin>>f;
cout<
tandis que (ot1>ot2) (
cout<
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je
la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant. Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire
tandis que (ot1>ot2) (
cout<
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je
la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant. Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire
renvoie 0 ;
}
Annexe 2
Publié sur Allbest.ru
Documents similaires
Analyse du domaine de la programmation orientée objet. Langages Delphi, Object Pascal - environnement de programmation orienté objet. Solutions algorithmiques de base. Résolution d'une équation différentielle à l'aide de la méthode Runge-Kutta dans Excel.
travail de cours, ajouté le 02/04/2011
Compilation d'un programme dans le langage algorithmique Turbo Pascal. Développement d'un schéma fonctionnel d'un algorithme pour le résoudre. Compilation d'un premier programme Pascal et mise en œuvre des calculs à l'aide du programme compilé. Application des méthodes Runge-Kutta et Runge-Kutta-Merson.
travail de cours, ajouté le 17/09/2009
L'essence de la méthode Runge-Kutta et ses propriétés. Résolution d'équations différentielles du premier ordre. Bloc de calcul Given/Odesolve. Fonctions intégrées rkfixed, Rkadapt, Bulstoer. Solutions d'équations algébriques linéaires dans MathCad et Microsoft Excel.
travail de cours, ajouté le 02/06/2014
Revue des méthodes de résolution dans Excel. Formules récursives de la méthode d'Euler. Méthode Runge-Kutta du quatrième ordre pour résoudre des équations du premier ordre. Méthode Euler avec étape h/2. Résolution d'équations différentielles avec Mathcad. Méthode Euler modifiée.
travail de cours, ajouté le 18/01/2011
Description mathématique du problème de résolution d'une équation différentielle ordinaire à l'aide de la méthode numérique explicite de Runge-Kutta, développement d'un diagramme algorithmique et écriture d'un programme dans l'environnement de programmation Microsoft Visual Studio 2010. Test du programme.
travail de cours, ajouté le 22/01/2014
Mise en œuvre de la résolution d'équations différentielles ordinaires du 1er et du 2ème ordre par la méthode Runge-Kutta. Construction sur ordinateur d'un système d'affichage de résultats sous forme tabulaire et sous forme graphique. Architecture et exigences pour les logiciels développés.
travail de cours, ajouté le 11/05/2011
Résolution d'équations différentielles du premier ordre. Variantes de méthodes Runge-Kutta de divers ordres. Méthodes de base pour la solution numérique du problème de Cauchy. Augmentation de la précision des calculs et de la méthode de raffinement itératif. Séquence de nombres discrets.
travaux de laboratoire, ajouté le 14/05/2012
Méthodes numériques de résolution du problème de Cauchy pour les équations différentielles ordinaires : Euler, Runge-Kutta, Adams et Runge. Techniques de résolution approximative de ces équations : méthode des différences finies, balayage des différences, collocations ; analyse des résultats.
travail de cours, ajouté le 14/01/2014
Analyse des avantages et des inconvénients de diverses méthodes numériques pour résoudre des équations différentielles d'ordre supérieur. Justification du choix de la méthode Runge-Kutta du quatrième ordre. Développement d'un programme modélisant le comportement physique et mathématique d'un pendule.
travail de cours, ajouté le 11/07/2012
Résolution d'équations différentielles à l'aide des algorithmes classiques des méthodes numériques d'Euler et Runge-Kutta du 4ème ordre. Commandes utilisées pour résoudre des équations différentielles ordinaires dans un système informatique. Le résultat du programme.
Soit une équation différentielle du premier ordre
avec condition initiale
y(x 0) = y 0.
Choisissons l'étape h et introduisons la notation suivante :
X je = X 0 + je . h et y je = y(x je) ,
où je = 0, 1, 2, …
x i – nœuds de grille,
y i - valeur de la fonction intégrale dans les nœuds .
L'équation différentielle est résolue de la même manière que les méthodes décrites ci-dessus. La différence est que l’étape est divisée en 4 parties.
Selon la méthode Runge – Kutta du quatrième ordre, les valeurs successives oui je la fonction souhaitée oui sont déterminés par la formule :
, je = 0, 1, 2, …
et les chiffres k 1 (i) , k 2 (i) , k 3 (i) , k 4 (i)à chaque étape sont calculés à l'aide des formules :
Il s’agit d’une méthode explicite en quatre étapes avec une précision du quatrième ordre.
Les méthodes Runge-Kutta sont faciles à programmer et offrent une précision et une stabilité significatives pour un large éventail de problèmes.
La figure 6 montre un organigramme de la procédure COURSE(X0, XK, Y0, N, Y) pour résoudre le problème de Cauchy en utilisant la méthode Runge – Kutta décrite ci-dessus.
je = 0, … , N-1
K1 = h * F(x, Yi)
K2 = h * F(x + h/2, Yi + K1 / 2)
K3 = h * F(x + h/2, Yi + K2 / 2)
K4 = h * F(x + h, Yi + K3)
K = (K1 + 2*K2 + 2*K3 + K4) / 6
Figure 6 - Organigramme de la procédure RUNGE
La figure 7 montre un schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy et obtenir des résultats avec un nombre fixe de segments de partition N. Dans le programme principal, la procédure est appelée RANGE(X0, XK, Y0, N, Y), calculer la valeur de la fonction souhaitée yj aux points xj par la méthode Runge-Kutta.
Données initiales dans ce problème sont :
X0, XK – valeurs initiales et finales de la variable indépendante ;
Y0 – valeur oui 0 de la condition initiale y(x 0) = y 0;
N – nombre de segments de partition.
Résultats du programme sont affichés dans deux colonnes :
X – tableau de valeurs de nœuds de grille ;
Y – tableau de valeurs de la solution recherchée dans les nœuds de grille correspondants.
Entrée X0, XK, Y0, N
| |
RANGÉE(X0,XK,Y0,N,Y)
je=0…N
Sortie X, Y i
Figure 7 - Schéma fonctionnel de l'algorithme du programme principal pour résoudre le problème de Cauchy avec un nombre fixe de segments de partition N
Résolution d'équations différentielles dans MathCad
Figure 8 - Un exemple de résolution d'une équation différentielle à l'aide de la méthode
Commandes Runge-Kutta 4 dans l'environnement MathCad.
Fonctions graphiques dans l'environnement Visual Basic
La tâche de tabuler les fonctions et de construire leurs graphiques est l'une des tâches principales du processus de résolution d'équations différentielles ordinaires. Considérons cette tâche plus en détail.
Tâche.
Construisez un graphique de la fonction y=sin(x) sur le segment. Prenez le pas de tabulation égal à h.
Solution.
Pour tracer un graphe de fonctions dans l'environnement Visual Basic, il est pratique d'utiliser certains composants graphiques.
Figure 9 - Emplacement des principaux composants dans la fenêtre Général
| |
Le composant Picture Box() est utilisé comme conteneur pour le traçage. Il s'agit d'une matrice de points (pixels) et il est possible de contrôler la couleur de chaque point individuel. Les coordonnées de n'importe quel point sont déterminées par une paire d'entiers - son numéro de série dans la ligne X et le numéro de série de la ligne à l'intérieur de l'objet Y. Ainsi, les coordonnées du coin supérieur gauche du composant sont (0, 0). . Le nombre de points par ligne et le nombre de lignes sont déterminés par la taille du composant.
Figure 10 - Coordonnées de l'objet PictureBox
Sur la fig. La figure 10 montre l'emplacement des axes et les coordonnées des points d'angle de l'objet.
Le composant Line() est utilisé pour tracer les axes et les segments d'un graphique polygonal d'une fonction.
L'essence de la construction d'un graphique se résume au fait que la fonction doit être présentée sous la forme d'un tableau (tabulé), puis marquer les points sur le modèle de graphique et les relier entre eux.
L'algorithme de construction d'un graphe de fonctions est présenté à la figure 12. L'algorithme peut être modifié. En particulier, certaines procédures peuvent être combinées et la procédure peut être modifiée dans certains cas.
Examinons l'algorithme plus en détail.
Avant d'implémenter l'algorithme, il est nécessaire de décrire la fonction du sous-programme permettant de tracer le graphique. Ceci est nécessaire pour faciliter la modification du programme. Si vous devez tracer un graphique d'une autre fonction, il vous suffit de modifier le sous-programme.
De plus, avant de tracer un graphique, vous devez créer et modifier un formulaire. Un exemple de développement d'un formulaire est présenté dans la figure 11. Sur le formulaire, vous devez placer des composants pour saisir les données initiales, un composant pour imprimer un tableau, un bouton de commande et un conteneur pour placer un graphique (PictureBox). À l'intérieur de PictureBox, vous devez tracer des axes de coordonnées à l'aide de lignes droites et placer des étiquettes pour enregistrer les limites du segment des valeurs d'argument de fonction et des extrema de fonction sur le segment en question.
La saisie des données initiales s'effectue dans le programme en question en appuyant sur le bouton de commande. Très souvent, la saisie des données est implémentée à l'aide du composant TextBox.
Il est pratique d'effectuer la procédure de tabulation des fonctions dans une boucle avec un paramètre, puisque le nombre de points du graphique à calculer est connu. Avant d'exécuter la procédure, vous devez définir le nombre de lignes du tableau.
Le nombre de lignes est calculé par la formule k=n+2, où k est le nombre de lignes et n est le nombre de sections de tabulation. Le nombre de lignes doit être supérieur de 2 au nombre de segments, car il faut prendre en compte le point de départ (zéro) et la ligne d'enregistrement des en-têtes de colonnes de page.
Dans la procédure de tabulation elle-même, vous pouvez combiner deux actions : la tabulation et le calcul des extrêmes. Cette solution est présentée dans la liste des programmes de la figure 13.
La principale difficulté du tracé est la transition de la valeur mathématique de la fonction et de l'argument aux coordonnées d'écran utilisées pour tracer le tracé. Lors de la résolution de ce problème, il est nécessaire de prendre en compte la direction opposée des axes sur le graphique mathématique et sur l'objet PictureBox et la nécessité de redimensionner l'image.
Les facteurs de mise à l'échelle du graphique sont calculés à l'aide des formules suivantes :
où kx est le facteur d'échelle le long de l'axe OX,
NPX – le nombre de pixels de l'objet PictureBox alloués pour tracer le graphique horizontal,
a – la valeur initiale du segment d'argument de fonction,
b – la valeur finale du segment de l'argument de la fonction.
,
où Ky est le facteur d'échelle le long de l'axe OY,
NPY – le nombre de pixels de l'objet PictureBox alloués à la construction d'un graphique vertical,
min – valeur minimale de la fonction,
max – valeur maximale de la fonction.
La traduction des coordonnées mathématiques du point courant en coordonnées écran s'effectue à l'aide des formules :
zx = Rond(bœuf + (x(i) - a) * kx),
zy = Rond(oy - (y(i) - Min) * ky),
où zx, zy – coordonnées d'écran du point actuel,
ox, oy - coordonnées du point d'intersection des axes dans le composant PictureBox,
x(i), y(i) – coordonnées mathématiques du point actuel,
kx, ky – facteurs d'échelle.
Dans la formule de calcul de l'ordonnée écran du point courant, le signe moins est utilisé pour prendre en compte le sens opposé des axes (à l'écran et sur le graphique).
La liste du programme permettant de tracer une fonction est présentée dans la figure 13.
Des exemples de formulaires avec les résultats du programme pour diverses données initiales sont présentés dans les figures 14 et 15.
Figure 11 - Exemple de développement de formulaire
Figure 12 - Algorithme de tracé d'un graphe de fonction
Rem Description des variables
Dim x() comme simple, y() comme simple
Privé comme célibataire