Pour Kibest: DM de programmation

  • Auteur de la discussion magellan
  • Date de début

magellan

Modérâleur
Staff
#1
Voilà ce que @Kibest demande: en gros il dispose d'un DM de programmation en python qui se base sur des calculs d'Euler (ahhh souvenir souvenir)

Je mets ici son code et ses interrogations.
Salut magellan !
Je suis étudiant en classe prépa TSI, et pour demain j'ai un programme sur python à rendre, je t'avoue que je ne suis pas vraiment talentueux en programmation.... Est-ce que tu pourrais m'aider et m'expliquer stp ?
Il y a 2 exercices, ces 2 exercices sont en rapport avec la méthode Euler, le premier exercice portait sur faire un programme devant afficher des graphiques de vitesse, accélération, déplacement, d'un skieur qui descendait une piste, j'y suis plutôt bien arrivé, même si ma dernière courbe n'est pas vraiment celle souhaitée (elle est à peine décalée de ce qu'elle devrait être...). Et le deuxième exercice porte sur "Euler et la loi normale".
J'essais de t'envoyer mon programme que j'ai fait avec python et mon sujet de DM.
Je te remercie par avance d'ailleurs.

J'ai fait un lien mediafire, j'espère que ça va marcher, je ne sais pas comment envoyer des fichiers directement sur la conversation....
http://www.mediafire.com/folder/k1lb2yo7l6e5l/DM_Euler
Python:
import matplotlib.pyplot as plt
import numpy as np
from math import *

def MethodeEuler(e,a,b,y0,N):
# Données : e est une fonction, a,b,y0 sont des réels et N un entier naturel
# Résultat : retourne une liste de deux listes de longueur N+1:
#     la 1ère correspond au découpage de l'intervalle [a,b]
#     la 2ème correspond à une approximation de la fonction y
#      solution de l'équation différentielle y'=e(y,t) selon la méthode d'Euler
#   a et b sont les bornes de y, y0 est la condition initiale
#   N est le nombre d'itérations souhaitées dans la méthode d'Euler
    y=np.zeros(N+1)
    t=np.zeros(N+1)
    y[0]=y0
    t[0]=a
    h=(b-a)/N
    for i in range(1,N+1):
        y[i]=y[i-1]+h*e(y[i-1],t[i-1])
        t[i]=t[i-1]+h
    return t,y

yp=lambda y,t:np.exp(-(t**2)/2)
a=0
b=200
y0=0
N=200

plt.subplot(2,1,1)
approx=MethodeEuler(yp,a,b,y0,N)
x=approx[0]
euler=approx[1]
P=0.5+(1/sqrt(2*pi))*euler
print(P)
plt.plot(x,P,label="Solution exacte")
#plt.scatter(x,euler,label="Approximation d'Euler")
plt.title('Comparaison Euler et solution exacte pour N=5')
plt.xlabel('Valeur de x')
plt.ylabel('Ordonnées')
#plt.legend(loc='upper left')
plt.grid()
plt.show()
Ainsi que le DM lui-même
 

Fichiers joints

Kibest

Expert
#2
J'ai modifié un peu le code, à partir du plt.subplot (par rapport au code du #1):
Python:
plt.subplot(2,1,1)

approx=MethodeEuler(yp,a,b,y0,N)
x=approx[0]
euler=approx[1]
Px=0.5+(1/sqrt(2*pi))*x
Peuler=0.5+(1/sqrt(2*pi))*euler
plt.plot(Px,Peuler,label="")
#plt.scatter(x,euler,label="Approximation d'Euler")
plt.title('Courbe de la loi normale centrée')
plt.xlabel('Valeur de x')
plt.ylabel('Ordonnées')
#plt.legend(loc='upper left')
plt.grid()
Quand j'exécute le programme, en voyant le graphique ç'a l'air cohérent (avec le fait qu'une probabilité ne dépasse jamais 1), on ne dépasse jamais 1 sur l'axe des ordonnées:
graphique_TH's.PNG
 
Dernière édition:

AccroPC2

Fou du PC
Staff
#3
Hello,

Honnêtement ça m'intéresse mais je viens de finir le boulot ... et là j'ai plus envie :'(

Bye
 

drul

Obscur pro du hardware
Staff
#5
Fait le en VBA, je me lancerai :D
Il y a trop longtemps que j'ai plus utilisé un "vrai" langage de prog, je fais plus que du parsing et de l'analyse de donnée brut sous vba, et encore pas souvent :/
 

LeeLarant

Speedy Configales, le plus rapide de tout TH
Staff
#6
Puté vous me tuez!
En fait je pense que je suis déjà mort... :censored::censored::ROFLMAO::ROFLMAO::ROFLMAO:
Autrefois j'ai appris le C, avec Mathieu Nebra et son "cours".
D'ailleurs je pense que c'est à cause de son cours que j'ai laissé tombé...
Et le temps aussi.
Maintenant c'est C#, avec Unity, et c'est déjà pas mal.
;)
 

magellan

Modérâleur
Staff
#7
Pour l'exo 1
A ce que je comprends il serait utile de reprendre la formule où t et v sont dans la fonction, et de partir qu'on fait varier t (temps) pour trouver v... Et de là tracer la courbe.
 

Kibest

Expert
#8
Voici mon code pour l'exercice 1 magellan :
Python:
import matplotlib.pyplot as plt
import numpy as np
from math import *

def MethodeEuler(e,a,b,y0,N):
# Données : e est une fonction, a,b,y0 sont des réels et N un entier naturel
# Résultat : retourne une liste de deux listes de longueur N+1:
#     la 1ère correspond au découpage de l'intervalle [a,b]
#     la 2ème correspond à une approximation de la fonction y
#      solution de l'équation différentielle y'=e(y,t) selon la méthode d'Euler
#   a et b sont les bornes de y, y0 est la condition initiale
#   N est le nombre d'itérations souhaitées dans la méthode d'Euler
    y=np.zeros(N+1)
    t=np.zeros(N+1)
    y[0]=y0
    t[0]=a
    h=(b-a)/N
    for i in range(1,N+1):
        y[i]=y[i-1]+h*e(y[i-1],t[i-1])
        t[i]=t[i-1]+h
    return t,y

a=0
b=50
y0=0
N=100
alpha=28*pi/180
m=80
g=9.81
rho=1.008
S=0.55
C=0.35
k=(1/2)*rho*S*C
L0=0
D0=0
yp=lambda y,t:g*sin(alpha)-(k/m)*y**2

approx=MethodeEuler(yp,a,b,y0,N)
x=approx[0]
euler=approx[1]

vitesse=approx[1]
gamma=(g*sin(alpha)-(k/m)*vitesse**2)/g

Lp=lambda gamma,t:g*sin(alpha)-(k/m)*(gamma*g**3)/3
dist=MethodeEuler(Lp,a,b,L0,N)
x1=dist[0]
euler1=dist[1]

#COURBE VITESSE
plt.subplot(3,1,2)
plt.plot(x,euler*3.6,label="Solution exacte")
plt.ylabel('vitesse en km/h')

#COURBE ACCELERATION
plt.subplot(3,1,1)
plt.plot(x,gamma,label="Solution exacte")
plt.ylabel('accélération en g')

#COURBE DISTANCE
plt.subplot(3,1,3)
plt.plot(x,euler1*x1*3.6,label="Solution exacte")
plt.ylabel('distance en m')
plt.xlabel('temps en s')
plt.grid()
plt.show()
 
Dernière édition:

AccroPC2

Fou du PC
Staff
#9
@drul je pense que si tu lui donnes l'algo, il peut le refaire en python ;)
 

Kibest

Expert
#10
Ahah @AccroPC2 :p
Je vais attaquer la question 2 de l'exo 2, je vous posterai mon avancée sur cette question, si pour l'exo 1 (poste #8) et la question 1 de l'exo 2 (postes #1 et #2) vous voyez des incohérences ou des trucs faux, n'hésitez pas :)

Merci en tout cas
 
Dernière édition:

Kibest

Expert
#11
@LeeLarant , c'est énervant la programmation quand le cours que l'on suit est lassant ou compliqué (surtout quand on est débutant...), moi perso j'ai appris quelques bases sur Python en regardant Graven sur youtube, il a fait une mini-série, et à la fin de chaque épisode il donnait un petit exo qu'il corrigeait au début de chaque épisode, c'était sympa :)
 

magellan

Modérâleur
Staff
#12
@LeeLarant , c'est énervant la programmation quand le cours que l'on suit est lassant ou compliqué (surtout quand on est débutant...), moi perso j'ai appris quelques bases sur Python en regardant Graven sur youtube, il a fait une mini-série, et à la fin de chaque épisode il donnait un petit exo qu'il corrigeait au début de chaque épisode, c'était sympa :)
Disons que la programmation c'est parler une langue... le problème pour moi n'est pas la syntaxe mais la grammaire! Trop de cours se basent sur "faut faire ceci ou faire cela", sans passer par l'enseignement de l’algorithmique . Tu peux coder en gros en ce que tu veux, si tu ne sais pas faire des boucles, des gestions de cas, et de tout imbriquer intelligemment... ça ne sert à rien.
 

Kibest

Expert
#13
J'ai essayé de me pencher sur la question 2 de l'exo 2,
de ce que j'ai compris :
Il faut que le programme retourne le nombre d'itération pour laquelle la méthode d'Euler a "juste" jusqu'à 5 chiffres après la virgule.
Mais je suis complètement largué, j'ai fait ce qui était écrit dans le sujet :

import scipy as sp
from scipy.stats import norm
print(norm.cdf(0.75))

Mais je suis bloqué là, je ne sais pas du tout comment m'y prendre....
Est-ce que vous pourriez me donner un petit coup de pouce svp ? Ou essayer de me réexpliquer pour que ça me paraisse plus clair...
Voilà ce que j'ai fait (en reprenant ce qui avait fait pour la question n°1):

Python:
import matplotlib.pyplot as plt
import numpy as np
from math import *
import scipy as sp
from scipy.stats import norm

def MethodeEuler(e,a,b,y0,N):
# Données : e est une fonction, a,b,y0 sont des réels et N un entier naturel
# Résultat : retourne une liste de deux listes de longueur N+1:
#     la 1ère correspond au découpage de l'intervalle [a,b]
#     la 2ème correspond à une approximation de la fonction y
#      solution de l'équation différentielle y'=e(y,t) selon la méthode d'Euler
#   a et b sont les bornes de y, y0 est la condition initiale
#   N est le nombre d'itérations souhaitées dans la méthode d'Euler
    y=np.zeros(N+1)
    t=np.zeros(N+1)
    y[0]=y0
    t[0]=a
    h=(b-a)/N
    for i in range(1,N+1):
        y[i]=y[i-1]+h*e(y[i-1],t[i-1])
        t[i]=t[i-1]+h
    return t,y

yp=lambda y,t:np.exp(-(t**2)/2)
a=0
b=200
y0=0
N=10**4

approx=MethodeEuler(yp,a,b,y0,N)
x=approx[0]
euler=approx[1]
Px=0.5+(1/sqrt(2*pi))*x
Peuler=0.5+(1/sqrt(2*pi))*euler

print(norm.cdf(0.75))
 

magellan

Modérâleur
Staff
#14
Bon bon bon.
La formule de calcul est une intégrale allant de 0 à A et il faut que tu calcules les valeurs approchantes selon la notion suivante:
a a une valeur variable. Pour que tu sois précis à 5 chiffres après la virgule, tu pars du principe que ton A est une valeur en réel qu'on incrémente de 0.0001.... tu vois l'idée?
Une fois que tu as calculé les valeurs, tu peux tracer chaque point pour une valeur de A.
En gros si tu regardes l'équation:
1591807456535.png
Ton calcul va devoir établir une constante pour e (qui est 2.7.. etc je ne me souviens plus de la valeur, mais mets la sur cinq chiffres après la virgule)
En terme d'algo tu as alors:
- Saisie de a
Calcul 1/racine(2pi)
Boucle de 0 à a en incrémentant de 0.0001 pour en établir une somme
Par exemple tu mets une variable intermédiaire xtemp où tu as
avant la boucle!
xtemp=0
Pendant la boucle
xtemp=xtemp+résultat du calcul de l'intégrale

Enfin, tu sommes 0.5+1/racine(2pi)+Somme de l'intégrale xtemp

Ensuite pour l'exo 2, tu n'as quasi rien à faire si je comprends bien le délire
En gros, avec ton calcul à la Euler, tu dois avoir une valeur pour une entrée de A

Exemple: si je mets a=5 tu obtiens un chiffre quelconque (par ex 12.245896)
Ensuite
Si tu utilises ton algo pour la valeur de A=5, l'idée est de calculer le résultat "valide" avec la méthode donnée en exemple. Vu que pour être le plus précis possible, il faut boucler comme un bourrin (cf ce que je dis plus haut), plus ta précision est élevée (c'est l'incrémentation de 0 à 5 qui fait le job), tu peux dire "si je fais de 1 en 1 c'est pourri, si je fais de 0.1 en 0.1 c'est plus précis etc etc)
 

Kibest

Expert
#15
Ok je vois,merci pour tes explications @magellan, j'ai rendu mon dm mais ça m'intéresserait bien de réussir à le finir même si ça ne sera pas noté, j'essais de programmer ça quand j'ai un peu de temps et je posterai ce que j'ai pu programmer.
Merci encore !
 

Kibest

Expert
#17
Salut !
Je suis en vacances à partir de mardi prochain, du coup je m'attaquerai à ce fameux exo dans la semaine qui suivra, je ne l'ai pas oublié :)
 

LeeLarant

Speedy Configales, le plus rapide de tout TH
Staff
#18
Salut !
Je suis en vacances à partir de mardi prochain, du coup je m'attaquerai à ce fameux exo dans la semaine qui suivra, je ne l'ai pas oublié :)
C'est chouette ça.
De mon côté je suis ravi, c'est génial d'apprendre c# en codant dans Unity.
Tu vois ton projet qui avance, c'est chouette. (En plus Unity prévoit plein de systèmes de debug au cas où ton code ne fonctionnerait pas ou mal)
:)
 

Kibest

Expert
#19
C'est chouette ça.
De mon côté je suis ravi, c'est génial d'apprendre c# en codant dans Unity.
Tu vois ton projet qui avance, c'est chouette. (En plus Unity prévoit plein de systèmes de debug au cas où ton code ne fonctionnerait pas ou mal)
:)
Tu fais quoi comme jeu ? ahah :p

Edit:
(En plus Unity prévoit plein de systèmes de debug au cas où ton code ne fonctionnerait pas ou mal)
Ouais ça c'est bien, pas comme le python-idle (une version portable 3.2.5.1; plus pratique car y a toutes les bibliothèques d'installées, mais mon environnement pycharm me manque ahah :p) que j'utilise où tu dois te débrouiller pour trouver ton erreur, ça te dit la ligne et c'est tout ahah, mais bon, au moins tu tu creuses la tête, mais des fois tu restes bloqué 30min sur un problème tout con
 

LeeLarant

Speedy Configales, le plus rapide de tout TH
Staff
#20
Tu fais quoi comme jeu ? ahah :p

Edit:

Ouais ça c'est bien, pas comme le python-idle (une version portable 3.2.5.1; plus pratique car y a toutes les bibliothèques d'installées, mais mon environnement pycharm me manque ahah :p) que j'utilise où tu dois te débrouiller pour trouver ton erreur, ça te dit la ligne et c'est tout ahah, mais bon, au moins tu tu creuses la tête, mais des fois tu restes bloqué 30min sur un problème tout con
Je chipote beaucoup pour le moment, j'avais pensé à un truc dans l'espace.
Sinon en fait dans Unity, le truc génial c'est ce fameux "Debug.log ();".
Cette ligne toute bête affiche du texte dans la console.
Sauf que tu peux mettre genre n'importe quoi dedans comme variable, et surtout tu peux la mettre n'importe où dans ton code (et voir en fonction de si elle s'affiche ou pas voir où ça débloque)
Cette ligne m'a déjà sauvé beaucoup de temps.
:)
 
Vous devez vous inscrire ou vous connecter pour répondre ici.
Membres en ligne
  • hein
  • labul671
Derniers messages publiés
Statistiques globales
Discussions
845 276
Messages
7 569 255
Membres
1 582 997
Dernier membre
Xullragh
Partager cette page
Haut