UNIVERSITÉ SIDI MOHAMED BEN ABDELLAH

ECOLE NORMALE SUPERIEURE – FES -

Projet de physique
numérique
Programmation Python (PyCharm Community)

1 Recherche des zéros d’une fonction

2 Calcul formels, et représentation des nombres, des
vecteurs, des matrices, dans un ordinateur
3 Calcul des intégrales, Calcul des dérivés, Résolution
équation différentielles
4 Echantillonnages, interpolation
5 Modélisation de données expérimentales.
Données et moindres carrées, ajustement d’une fonction
linéaire, ajustement d’un polynôme, dérivée locale d’une
courbe expérimentale, et lissage
6 La question du calcul formel
6-1 Calcul formel, calcul numérique : quelle différence
6-2 Quelques exemples à l’aide de logiciel formel : Python/
Matlab/Octave/ Maple
6- 2.1 a*x + b = 0
6-2.2 Le gaz de Van der Waals : code source(programme)
6-2.3 Modèle de Brillouin-Weiss: code source(programme)
6-2.4 Le projectile

Préparé par :
-HAMZA EL ATIQY

Encadré par :

-Mostafa Elmallahi
 1. Recherche des zéros d’une fonction
La recherche des zéros d'une fonction réelle à variable réelle est une occupation fort prenante en
analyse numérique et donc en physique numérique. Rappelons que l'on appelle "zéro" d'une
fonction, ou encore "racine", la(les) solution(s) de l'équation f(x) = 0.

Il y a plusieurs méthodes de Recherche des zéros d’une fonction on donner deux méthodes très
classiques avec des exemples de programmation en Python.

1.1-Méthode de dichotomie
Une dichotomie permet de trouver rapidement une valeur approchée de x telle que f (x) = 0, Le principe
est simple nous avons obtenu un intervalle de longueur moitié dans lequel l’équation (f (x) = 0) admet
une solution. On itère alors le procédé pour diviser de nouveau l’intervalle en deux.

Soit f une fonction telle que :

• f(a) et f(b) sont de signes opposés

• f est continue strictement croissante (ou décroissante) sur [a, b]

Méthode

1. partir du couple de valeurs (a, b)

2. évaluer la fonction en a+ b 2

3. si f*(a + b/ 2) a le même signe que f(a), remplacer a par a+ b/ 2, sinon remplacer b par a+ b/ 2

4. aller en 2 avec le nouveau couple de valeurs (a, b) jusqu'à ce que la différence entre a et b soit inférieure
à la précision voulue.

Comment implémenter La dichotomie dans le langage Python

exemple f (x) = x**2-x-1) ,[a=1 , b=5]:

def dichotomie(f, a, b,):

fa = f(a)
fb = f(b)
if fa*fb > 0:
print("f(a) et f(b)doit avoir un signe différent.")
return None
for _ in range(100):
c=(a+b)/2
fc=f(c)

if fc==0:
return c
if fa*fc > 0:
a=c
fa=fc
if fb * fc > 0:
b = c
fb = fc
return c

func = lambda x: x**2-x-1

2|Page
 a=1
b=5
x= dichotomie(func,a,b)
print("solution found:{}".format(x))

1.2-Méthode de Newton (exemple f(x) = x*x + 3*x – 5)

En analyse numérique, la méthode de Newton-Raphson, est un algorithme efficace pour approcher un zéro
d'une fonction. De manière informelle, le nombre de décimales correctes double à chaque étape. Partant
d'une valeur approximative raisonnable d'un zéro x0 d'une fonction f, on approche la fonction par sa
tangente au point (x0 ; f (x0)). Cette tangente est une fonction affine dont on sait trouver l'unique zéro (que
l'on appellera x1). Ce zéro de la tangente sera généralement plus proche du « vrai » zéro de la fonction.

Un petit programme écrit en Python qui permet de calculer le zéro d'une fonction notée f(x)f(x) par la méthode
de Newton à partir de la suite suivante : xk+1= xk – f(xk)/f′(xk)
import numpy as np
import matplotlib.pyplot as plt

def ma_fonction(x):
y = x*x + 3*x - 5
return (y)
def ma_derivee(x):
y = 2*x + 3
return (y)
def NewtonsMethod( x, epsilon=0.000001):
n = 0
dif = 2 * epsilon
while dif > epsilon :
x1 = x - ma_fonction(x) / ma_derivee(x)
dif = abs(x1 - x)
x = x1
n = n+1
return (x, n)
# Programme principal
x = float(input("Quelle est la valeur de départ ? : "))
(x,n) = NewtonsMethod(x)
print('x=%f n=%d' % (x, n) )
tab_x = np.linspace(-6,6,100)
tab_y = ma_fonction(tab_x)

plt.figure()
plt.plot(tab_x,tab_y, color='red')
plt.grid()
plt.show()
3|Page
2.Calcul formels, et représentation des nombres, des vecteurs, des matrices,
dans un ordinateur
2.1 Calcul formels ou symbolique :

Le calcul formel manipule des entités mathématiques de manière exacte. Tous les objets manipulés DOIVENT
ainsi être construits/décrits de manière finie.

Que fait un système de calcul formel ?

Résolution d’équations, factorisation, simplification d’expressions contenant des variables ; les réécrire.
Calcul symbolique dans des structures algébriques (groupes, anneaux, corps…). Plus généralement, travailler
sur des expressions de façon symbolique (plutôt que numérique).

Deux logiciels libres récents offrent les fonctionnalités du calcul symbolique :

SageMath : rassemble un certain nombre de systèmes de calcul symbolique au sein d’une interface standardisée
avec un gros noyau

SymPy : est un module Python. Son intérêt est d’être léger et de fonctionner sur tout système capable d’exécuter
Python. Il utilise NumPy pour le calcul numérique et Matplotlib pour le graphisme. On privilégiera l’utilisation des
feuilles de calcul fournies par Jupyter.

Exemple avec sympu

from sympy import*

print(1+sqrt(3))
#1+sqrt(3):pas d’évolution de la racine carre
print(1+sqrt(3*3))
#output 4 : calcul exact avec simplification
print(N(1+sqrt(3)))
#2.73205080756888

2.2-représentation des nombres 

Les nombres entiers dans Python
Il a été mentionné que les nombres avaient une représentation binaire, c’est-`a-dire constituée de 0
et de 1. Ainsi pour les nombres entiers, on obtient la correspondance habituelle entre
représentation décimale (1ére ligne) et binaire (2éme ligne) :
0 1 2 3 4 5 6 7 8 ...
0 1 10 11 100 101 110 111 1000 ...
Une case contenant un 0 ou un 1 s’appelle un bit.

Pour pouvoir représenter les nombres négatifs, on doit changer la convention et l’on prend le complément à
deux, qui consiste `à remplacer les 1 par des 0, et inversement, puis ajouter 1 au résultat ; soit, toujours sur
un octet : 00000001 = 1 et 11111111 = −1.

si on entre :
a=3
print(type(a))
b=3.14
print(type(b))
c=int(b)
print(c)

4|Page
 output :

<class 'int'>
<class 'float'>
3

On constate que Python sait que a est entier, que b ne l'est pas, et que c peut être entier bien qu'obtenu à partir
de b (qui est réel).

Les nombres réels.

Parler de nombres réels est un abus de langage puisque l’on ne peut traiter que les nombres rationnels.
Ainsi, √2 sera approximé par, par exemple, 1,414213562. De plus, on est obligé de se restreindre encore
davantage aux nombres rationnels `a un nombre fini de chiffres : 1/3 devient par exemple 0,3333333333. Un
tel nombre rationnel, si l’on supprime la virgule, est un nombre entier : il suffit de préciser l’emplacement de
la virgule, par une puissance de 10, par exemple. Ainsi, 1,4142135 peut s’écrire 14142135*10 9 -
2.3- représentation des vecteurs et des matrices
1- Représentation des matrices à deux dimensions en Python.
Les deux objets usuels utilisés pour représenter les matrices sont les listes de listes et les tableaux numpy. La
bibliothèque numpy propose un autre type, numpy.matrix, spécifiquement adapté au calcul matriciel.

Représentation par une liste de listes (type list)

Avec les objets de base de Python, chaque ligne peut être représentée par une liste. La matrice est définie
par une liste de lignes, soit par une liste de listes.

L0 = [2., 2, -3] # première ligne

L1 = [-2, -1, 1] # deuxième ligne
L2 = [4, 1, 1] # troisième ligne
A =[L0, L1, L2] # matrice

On préfèrera une définition sans variables intermédiaires :

A = [[2., 2, -3], [-2, -1, 1], [4, 1, 1]]

Ou, pour plus de lisibilité (un passage à la ligne est possible entre les éléments d’une liste) :
A = [[2., 2, -3],
[-2, -1, 1],
[4, 1, 1]]

Représentation par un tableau numpy (type np.array)

Le type array du module numpy permet une représentation de tableaux à plusieurs dimensions. Tous les
éléments du tableau sont du même type (tableau homogène).

La création d’un tableau de n lignes par m colonnes peut être réalisé avec les fonctions :

 np.zeros((n,m)) : tableau rempli de flottants zeros ;

 np.ones((n,m)) : tableau rempli de flottants 1 ;
 np.empty((n,m)) : tableau de valeurs non initialisées (quelconques).

Noter que ces fonctions ne prennent qu’un seul argument. Les différentes dimensions sont spécifiées par un objet
itérable, liste ou tuple, comme dans ces exemples.

5|Page
 Pour la définition de la matrice A , on utilise une conversion à partir d’une liste de lignes :

A = np.array([[2., 2, -3],
[-2, -1, 1],
[4, 1, 1]])

Exemples de valeurs retournées par les différentes lignes de code suivantes :

2- Représentation des vecteurs en Python

Que ce soit avec des listes ou des tableaux numpy, il faut distinguer :
 les tableaux unidimensionnels qui n’ont qu’une seule dimension ;
 les tableaux bidimensionnelsayant une dimension unitaire.

Exemples de création de vecteurs en listes et en tableaux numpy.

Représentation avec Vecteur unidimensionnel Vecteur ligne Vecteur colonne

Des listes B = [2, -5, 16] B = [[2, -5, 16]] B = [[2], [-5], [16]]
3 éléments 1 ligne de 3 éléments 3 lignes de 1 élément
Des tableaux numpy B=np.array([2,-5,16]) B=np.array([[2,-5,16]]) B=np.array([[2],[-5],[16]])
B.shape : (3) (1 ,3) (3,1)
len(B.shape) : 1 (une dimension) 2 (deux dimensions) 2 (deux dimensions)
print(B.T) : [ 2 -5 16] [[ 2] [[ 2 -5 16]]
[-5]
[16]]

Pour les tableaux numpy, la propriété .T retourne la transposée du vecteur.

 Un tableau unidimensionnel ne distingue pas un vecteur ligne d’un vecteur colonne. La transposée d’un
tableau unidimensionnel retourne le même vecteur.

Les tableaux bidimensionnels permettent de distinguer les vecteurs lignes des vecteurs colonnes. La transposée d’un
vecteur ligne retourne un vecteur colonne et réciproquement.

 Lignes et colonnes d’un tableau numpy sont des tableaux unidimensionnels

6|Page
3-Calcul des intégrales, Calcul des dérivés, Résolution équation différentielles
a.Calcul des intégrales :

Calcul approché d'intégrale d'une fonction entre les abscisses x1 et x2. utilisant les méthodes des
rectangles.

 Le programme découpe l'intervalle [x1;x2] en 10000 rectangles.

I =∫ [x1; x2] f(x)dx

La fonction considérée pour l'exemple ci-dessous est x2+3x−5x2+3x−5.

import math
import numpy as np
import matplotlib.pyplot as plt

def ma_fonction(x):

y = x*x + 3*x -5
return(y)

def calcul_integrale(x1, x2, dx):

x = x1
I = 0
while x <= x2:
y = ma_fonction(x)
petite_I = y*dx
I = I + petite_I
x = x + dx

return(I)
x1 = float(input("Quelle est la valeur de x1 "))
x2 = float(input("Quelle est la valeur de x2 "))
dx = abs(x2-x1)/10000
I = calcul_integrale(x1, x2, dx)

tab_x = np.linspace(x1,x2,10)
tab_y = ma_fonction(tab_x)

plt.figure()
plt.plot(tab_x,tab_y, color='red', marker='o', markeredgecolor='b')
mon_titre = 'I entre %.1f et %.1f est égale à %.2f' % (x1, x2, I)
plt.title(mon_titre)
plt.show()

b.Calcul des dérivés :

Pour calculer la dérivée première, deuxième ou troisième d'une fonction f(x) avec le langage
python, nous utilisons la fonction diff() de la bibliothèque sympy.

diff(y,x) ou la méthode y.diff(x)

La fonction diff() a au moins deux paramètres

 Le premier argument y est la fonction à dériver.

7|Page
  Le deuxième argument x est la variable de dérivation.

La fonction diff() génère la dérivée première.

Exemple de calcul
Exemple 1 (dérivée première)

Ce script calcule la dérivée première de f(x)= x2+1

import sympy as sp
x = sp.Symbol('x')
y = x**2 + 1
sp.diff(y,x)

Exemple 2 (dérivée seconde)

Ce script calcule la dérivée seconde de la fonction f(x)=x2

import sympy as sp
x = sp.Symbol('x')
y = x**2
sp.diff(y,x,x)

Exemple 3 (troisième dérivée)

Ce script calcule la dérivée troisième de la fonction f(x)=x2+4x

import sympy as sp
x = sp.Symbol('x')
y = x**2 +4x
sp.diff(y,x,3)

C. Résolution équation différentielles :

La résolution numérique d'équations différentielles ordinaires en python. Pour cela, nous allons utiliser la
fonction odeint du module scipy.

Equations différentielles d'ordre 1

Commençons simplement par une équation de la forme y ′= a*y comme on peut croiser en étudiant la
radioactivité par exemple.

import matplotlib.pyplot as plt
import numpy as np
from scipy.integrate import odeint

# On précise notre constante
a=-0.1
# On crée la liste des temps : 1000 points entre t=0 et t=50. 
# Plus on met de points plus la résolution sera précise
temps = np.linspace(0, 50,1000)

# L'équation différentielle sous forme de fonction :
def equation(Y,temps):
    return a*Y

#On résout notre équation différentielle et on récupère la liste des résultats
Y=odeint(equation, [10], temps)

8|Page
 #On affiche le résultat des Y en fonction du temps
plt.plot(temps,Y)
# On montre le résultat
plt.show()

Equations différentielles d'ordre 2

La fonction odeint se sait résoudre que des équations d'ordre 1 mais peut en résoudre plusieurs
d'un coup. Autrement dit, on peut résoudre Y'= A*Y où Y est un vecteur et A une matrice.
Ainsi, si on veut résoudre l'équation différentielle y''= a*y on va poser :

Et notre équation d'ordre 2 se ramène à résoudre

import matplotlib.pyplot as plt
import numpy as np
from scipy.integrate import odeint

a=-1
temps = np.linspace(0, 50,1000)

# L'équation différentielle sous forme de fonction
def equation(Y,temps):
    # On décompose notre Y en (y,dy) :
    (y,dy)=Y
    # On renvoie ce que vaut Y' :
    return [dy,a*y]

# Pour que odeint renvoit séparément les valeurs de Y et de Y', il faut rajouter.T à la fin
Y,dY=odeint(equation, [1,0], temps).T
plt.plot(temps,Y)
plt.show()

4.1-Echantillonnages .
- Principe
Pour enregistre un signal dans un format numérique, on mesure ses valeurs sur une grille de
points [ti] avec i∈[0,N−1], c’est l’échantillonnage. On enregistre donc N valeurs. Une grande
quantité d’information est donc perdue par ce procédé. On définit aussi la fréquence
d’échantillonnage:

Dans l’exemple ci-dessous, les pastilles rouges représentent les points pour lesquelles les valeurs
du signal réel sont enregistrées. On remarque les pastilles rouges décrivent bien la forme du signal
réel, l’échantillonnage est donc réussi.

import numpy as np
import matplotlib.pyplot as plt

# Signal
T = 1.
def signal(t): return np.sin(2. * np.pi * t / T)
# Echantillonnage
D = 2. # Duree d'observation
fe = 10. # Frequence d'echantillonnage
N = int(D * fe) + 1 # Nombre de points enregistres

9|Page
 te = np.linspace(0., (N-1)/fe, N) # Grille d'echantillonnage
tp = np.linspace(0., D, 1000) # Grille plus fine pour tracer l'allure du signal parfait
# Trace du signal
plt.plot(te, signal(te), 'or-', label = u"Signal echantillonne")
plt.plot(tp, signal(tp), 'b--', label = u"Signal reel")
plt.grid()
plt.xlabel("Temps $t$")
plt.ylabel("Amplitude $x(t)$")
plt.legend()
plt.show()

4.2-interpolation.

L'interpolation est un processus par lequel des « lacunes » dans un ensemble de données peuvent être
comblées à l'aide d'équations relativement simples. L'interpolation diffère de l'ajustement en ce que :

 Des interpolations sont nécessaires pour atteindre exactement tous les points de données, tandis
que les ajustements peuvent ne toucher aucun des points de données,
 Les interpolations sont basées sur des formules mathématiques, souvent simples, sans tenir compte
du système sous-jacent qui a produit les données.

Plusieurs méthodes d'interpolation définissent sous formes de classes il est possible d'utiliser des
interpolations linéaires ou cubiques

from scipy.interpolate import interp1d

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 20, 20)

y = np.cos(-x**2/8.0)
y = np.cos(x)

f = interp1d(x, y)
f2 = interp1d(x, y, kind='cubic')

xnew = np.linspace(0, 20, 80)

plt.plot(x,y,'o',xnew,f(xnew),'-', xnew, f2(xnew),'--')

plt.legend(['data', 'linear', 'cubic'], loc='best')
plt.ylim(-1.2,1.2)

10 | P a g e
 plt.savefig('InterpolationPython.png')
plt.show()

5.Modélisation de données expérimentales

5.1- Données et moindres carrées : (régression linéaire)

La méthode des moindres carrés permet de comparer des données expérimentales, généralement
entachées d’erreurs de mesure à un modèle mathématique censé décrire ces données.

from scipy import size, array, mean

from matplotlib.pyplot import figure, plot, xlim, ylim, xlabel,ylabel,title,scatter,show

def CalculCoefficients(x, y):

n = size(x)
m_x, m_y = mean(x), mean(y)
Somme_xy = sum(y * x) - n * m_y * m_x
Somme_xx = sum(x * x) - n * m_x * m_x
a = Somme_xy / Somme_xx
b = m_y - a * m_x
return (a, b)

def TraceRegressionLineaire(x, y, coeff):

figure(1)
xlabel('x');
ylabel('y')
xlim(0, max(x));
ylim(0, max(y))
title("Regression lineaire")
# tracé des points de mesure
scatter(x, y, color="red", marker="o", s=30)
# tracé de la droite de régression
y_reg = coeff[0] * x + coeff[1]
plot(x, y_reg, color="g")
show()
return

11 | P a g e
 # mesures
x = array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
y = array([0, 9, 19, 29, 41, 50, 62, 69, 83, 95, 101, 109, 119, 130, 142, 149])
# calcul des coefficients a et b
coeff = CalculCoefficients(x, y)
# tracé de la courbe de regression
TraceRegressionLineaire(x, y, coeff)
print("Coefficients de regression : \a = {} \b = {}".format(coeff[0], coeff[1]))

5.2- ajustement d’un polynôme

Ajustement polynomial simple de 3 degrés utilisant numpy.polyfit et poly1d, le premier effectue un

ajustement polynomial aux moindres carrés et le second calcule les nouveaux points:

import numpy as np
import matplotlib.pyplot as plt

points = np.array([(1, 1), (2, 4), (3, 1), (9, 3)])

# get x and y vectors
x = points[:,0]
y = points[:,1]

# calculate polynomial
z = np.polyfit(x, y, 3)
f = np.poly1d(z)

# calculate new x's and y's

x_new = np.linspace(x[0], x[-1], 50)
y_new = f(x_new)

plt.plot(x,y,'o', x_new, y_new)

plt.xlim([x[0]-1, x[-1] + 1 ])
plt.show()

12 | P a g e
5.3-dérivée locale d’une courbe expérimentale

- Calcul de la dérivée de la fonction cosinus

import numpy as np
import matplotlib.pyplot as plt

nbx = 101
x = np.linspace(0, 10, nbx)
y = np.cos(x)

# préparation des tableaux qui vont recevoir les valeurs

xnew = np.zeros(nbx-1)
yp = np.zeros(nbx-1)

# calcul des abscisses et des valeurs de la dérivée

for i in range(nbx-1):
xnew[i] = (x[i] + x[i+1]) / 2
yp[i] = (y[i+1] - y[i]) / (x[i+1] - x[i])

plt.plot(x, y, label="f(x)")
plt.plot(xnew, yp, label="f'(x)")

plt.legend()
plt.show()

5.4-lissage d'un courbe python

####Fonction de lissage
def lissage(Lx, Ly, p):
'''Fonction qui débruite une courbe par une moyenne glissante
sur 2P+1 points'''

13 | P a g e
 Lxout = []
Lyout = []
for i in range(p, len(Lx) - p):
Lxout.append(Lx[i])
for i in range(p, len(Ly) - p):
val = 0
for k in range(2 * p):
val += Ly[i - p + k]
Lyout.append(val / 2 / p)

return Lxout, Lyout

6-1 a*x + b = 0

Exemples à l’aide de logiciel formel : Python

print("ce programme est de donner la solution de l'équation ax + b = 0")

a=float(input("donner la valeur de a :"))
b=float(input("donner la valeur de b :"))
if a!=0:
x = -b/a
else:
if b == 0:
x ="indeterminer"
else:
x ="imposible"
print("la solution x est :" + str(x))

Exemples logiciels de calculs formels comme Maple

solve(a*x+b=0,x);
-b/a
#est la résolution formelle de l’équation, alors que :

f = (a,b)->fsolve(a*x+b=0,x);
f = (a, b) → fsolve(a x + b = 0, x)

6-2 Le gaz de Van der Waals : code source(programme)

L’équation de Van der Waals introduit des termes correctifs dans l’équation des gaz parfait (PV= nRT) afin
de tenir compte les interactions autres que les simples chocs élastiques et le volume du gaz .
L’équation de Van der Waals s’écrit sous la forme :

(𝑃 + 𝑛²𝑎/ v²) (V − 𝑛𝑏) = 𝑛𝑅𝑇

Avec, a : constante et b : Le covolume

On entre donc l’expression de la pression : p = R*T/(v-b) - a/v**2

# variables
V = 0.6 #m**3 vessel
T = 473. #K temperature
N = 1. * 10 ** 3 #mol
R = 8.314 #Pa * m**3/molK

# Calculation
P = N * R * T / (V * 10**5)

# Result

14 | P a g e
 print ("(a)Pressure calculated using ideal gas equation = %.2f bar"%P)
a = 0.4233 #N * m**4 / mol**2
b = 3.73 * 10**-5 #m**3/mol
# (P+a/Vm^2) * (Vm - b) = RT
P1 = (R*T/(V/N - b)-a/(V/N)**2)/10**5
print ("(a)Pressure calculated using van der waals equation = %.2f bar"%P1)

6.3-Modèle de Brillouin-Weiss: code source(programme)

L'aimantation spontanée d'une substance ferromagnétique, lorsque le champ magnétique extérieur est
nul, peut être décrit simplement par le modèle de Brillouin-Weiss.

Où M est l'aimantation à la température T, Ms l'aimantation spontanée à 0 K, q une caractéristique du

matériau étudié.
Résolution numérique

Nous allons maintenant nous ramener au problème général de la recherche des zéros d'une expression
f(x) = 0

Pour cela posons :

µ est appelé aimantation réduite.

Le problème à résoudre est maintenant la recherche du zéro de l'équation :

Ou on utiliser Langage Maple

solve(tanh(Tc/T*M/Ms)=M/Ms,M)
# Maple ne sait pas répondre au question. Tentons donc une r´esolution numérique, en nous placant pour
simplifier dans un systéme d’unités dans lequel Ms = 1 et Tc = 1 :

f:=T->fsolve(tanh(M/T)=M,M)
plot(f,0..1)
# On obtient la solution nulle. . . C’est exactement comme lorsqu’on cherche `a résoudre un problème `a l’aid
de la m´méthode de la dichotomie ou Newton ! Reformulons alors le problème pour éliminer cette solution
nulle :
g:=T->fsolve(tanh(M/T)/M=1,M);
plot(g,0..1);

C'est mieux, mais on préfèrerait une solution positive ; imposons alors le domaine de recherche des solutions
(entre0 et 1) :
h:=T->fsolve(tanh(M/T)/M=1,M,0..1);
plot(h,0..1);

15 | P a g e
6.4-Le projectile
Le programme suivant sert à représenter la trajectoire d'un projectile lancé dans le vide, à une vitesse
initiale de 300 m/s et avec un angle initial de 45°.

from __future__ import division # on réalise un hack, pour éviter que 1/2==0
(division euclidienne) et obtenir plutôt 1/2==0.5
from sympy import symbols, S, pi, solve, sin, cos
from sympy.plotting import plot_parametric # on importe des éléments nécessaires au
programme

g = 9.81 # force de gravitation

v0 = 300 # vitesse du projectile à la sortie du canon
en m/s
alpha_deg = 45 # angle de tir de 45°
t = symbols("t") # on définit la variable t au sens sympy
alpha_rad = S(alpha_deg) * pi / 180 # angle en radian
z = v0 * sin(alpha_rad)*t - 1/2*g*t**2 # équation de z en fonction du temps
# les deux étoiles symbolisent la puissance
en Python
impact = solve(z,t) # résolution de l'équation z(t) = 0
tMax = max(impact) # calcul du temps maximum de tir (impact)
x = v0*cos(alpha_rad)* t # calcul de x en fonction de t
serie = (x,z, (t,0,tMax)) # affichage des points (x(t),z(t)) pour t <
tMax
p = plot_parametric(serie)

En modifiant légèrement le programme, on peut représenter 5 trajectoires différentes avec les mêmes
données initiales mais nous étudierons 5 angles différents dits complémentaires.

from __future__ import division

from sympy import symbols, S, pi, solve, sin, cos
from sympy.plotting import plot_parametric

g = 9.81 # force de gravitation

v0 = 300 # vitesse du projectile à la sortie du canon en m/s
series = [] # liste de stockage des séries
# itération sur les angles de tirs de 15, 30, 45, 60 et 75 degrés
for alpha_deg in (15., 30., 45., 60, 75):
t = symbols("t") # temps
alpha_rad = S(alpha_deg) * pi / 180 # angle en radian
z = v0 * sin(alpha_rad) * t - 1 / 2 * g * t ** 2 # équation de z en fonction du
temps

impact = solve(z, t) # résolution de l'équation z(t) = 0

tMax = max(impact) # calcul du temps max de tir (impact)
x = v0 * cos(alpha_rad) * t # calcul de x en fonction de t
serie = (x, z, (t, 0, tMax)) # affichage des points (x(t),z(t)) pour t dans < tMax)

series.append(serie) # ajout dans la liste des séries

# préparation de l'affichage des séries
p = plot_parametric(*series, show=False) # à noter, le show=False pour éviter
l'affichage immédiat
# configuration des couleurs des séries
p[0].line_color = "red"
p[1].line_color = "purple"
p[2].line_color = "black"
p[3].line_color = "purple"
p[4].line_color = "red"
p.show() # déclenchement de l'affichage

16 | P a g e
17 | P a g e