U.

E :INF1221 : Initiation à la Programmation Python

PROJET DE PYTHON

NOM :BIYAO
PRENOM :RIDWANE
FILIERE :INFORMATIQUE ET
SYSTEMES
PLAN DE TRAVAIL :

- Problème
- Résolution du problème
- Implémentation du code en python
- Résultat du code
- Rapport
Problème 1 : Opérations sur les vecteurs
On donne trois vecteurs

A ||, ||, ⃗
1. Calculer les normes ||⃗ C || . En déduire les vecteurs unitaires ⃗
B ,|| et ||⃗ U A,

⃗ ⃗C des directions, respectivement, de⃗

U B , et U A,⃗ ⃗.
B,C

2. Calculer cos( ) et cos( ), sachant que les angles sont compris

entre 0 et π.
3. Calculer les composantes des vecteurs e⃗ 1 = ⃗
U B ∧⃗
U C , e⃗ 2 = ⃗
U C ∧⃗
U A et e⃗ 3 = ⃗
U A ∧⃗
UB

4. En déduire sin( ) et sin( ). Vérifier ces résultats en utilisant la

question 2.
5. Montrer que e⃗ 1 , e⃗ 2 , ⃗e 3 peuvent constituer une base. Cette base est-elle orthogonale,
normée?

Résolution du problème :
1. on a les vecteurs

2) .déterminons la norme des vecteurs‖⃗c‖=√ 12+ 22+ 22

‖⃗A‖= √32 +22 + √ 3 =4

2

‖⃗B‖=√ 2+¿ ⋅√ 3 +√ 2 ¿= 3
2 2 2

‖⃗c‖=√ 12+ 22+ 22=3

 On sait que le vecteur unitaire u⃗ v de la direction d’un vecteur ⃗v , est définie par u⃗ v=
V /|| ⃗v ∨¿. De la mˆeme mani`ere, en appliquant ce résultat, on obtient

u⃗ A =¿

⃗ 2 √3 √2
U B( , , )
3 3 3

1 2 2
u⃗ c=( , , )
3 3 3

2- Pour déterminer les cosinus des angles entre les trois

vecteurs pris deux `a deux, nous utilisons la définition du
produit scalaire suivante ⃗ B=‖⃗
A ⋅⃗ A‖‖⃗ B‖cos ( ⃗
A ,⃗
B ) ce qui
donne

⃗
A⃗B
‖⃗A‖‖⃗B‖

6+2 √ 3+ √ 3 × √2
=
3×4

≃ 0.993

De meme

⃗
B ⋅⃗
C
cos ( ⃗
B,⃗
C )=
‖⃗B‖‖⃗
C‖

1× 3+2 √ 3+2 × √ 2
=
3 ×3

≃0,921

Et enfin
3-On sait que les composantes du vecteur produit vectoriel
entre ⃗
U B et ⃗
U C sont données par

4- calculons le sinus des angles

puisque u⃗ A et ⃗
U B sont unitaires. On utilise la même démarche pour les autres angles
Pour vérifier ces derniers résultats, on utilise les cosinus de ces mêmes angles déjà calculés
auparavant et on trouve

ce qui vérifie bien que les angles calculés dans cette questions sont les mêmes que ceux
calculés dans la question 2.
5- . Pour qu’une famille de vecteurs constitue une base, il suffit
— que le cardinal de la famille, c’est à dire le nombre de vecteurs de la famille, soit égal à la
dimension de l’espace vectoriel en question, et qui est dans notre cas 3. Ce qui est vérifié
pour ⃗
(e ¿ ¿1 , e⃗ 2 , ⃗e 3)¿ ¿

— et que la famille soit une famille libre, c’est `a dire que tout vecteur peut être écrit comme
combinaison linéaire de ces trois vecteurs. Pour démontrer cette propriété, il suffit que les
trois vecteurs ne soient pas coplanaires et donc leur produit mixte soit différent de zéro.
Calculons alors le produit mixte

et qui est donc différent de 0. D’ou les trois vecteurs forment une famille libre. On
en déduit que ⃗(e ¿ ¿1 , e⃗ 2 , ⃗e 3) ¿ ¿forment une base

6-. Elle n’est pas orthogonale car les produits scalaires entre ces vecteurs pris deux `a deux
ne sont pas nuls. Elle n’est pas non plus normée car les vecteurs de sa base ne n’ont pas une
norme égale `a l’unité 

Implémentation du code python :

# j' importe la bibliothrque numpy pour les differnts calcules
import numpy as np

#pour chaque question je vais creer une fonction qui traite la question
# et ensuite j'appelerai chaque fonction en bas pour repondre aux
#questions

# ici je commence par definir les differents vecteurs A, B et C .

# je definie les vecteurs grace a la fonction array integrer dans numpy qui
#permet de creer
#des tableau de vecteur. ici j'ai mis les crochet pour specifier que c la
#liste des elemets qui seront stocker dans le tableau
A = np.array([3, 2 * np.sqrt(2), np.sqrt(3)])
B = np.array([2, np.sqrt(3), np.sqrt(2)])
C = np.array([1, 2, 2])

#definie une fonction appele norme qui permet de calculer la norme de

chaque vecteur
def norme():
# Calcul des normes des vecteurs A, B et C
# ici j'utilise la fonction linalg qui est un module de la
#bibliothèque NumPy (alias de "Linear Algebra") qui fournit
# des fonctions et des outils pour effectuer des opérations linéaires
#et des calculs liés à l'algèbre .ici il prend en
#entrer chaque vecteur et calcul sa norme qu'il stocke dans chaque
#variable
norm_A = np.linalg.norm(A)
norm_B = np.linalg.norm(B)
norm_C = np.linalg.norm(C)
# retournons la norme de chaque vecteurs
return norm_A,norm_B,norm_C

# Calcul des vecteurs unitaires uA, uB et uC

#declare une fonction vecteurs_unitaire qui permet de calculer la norme de
chaque vecteur
def vecteurs_unitaires():
#le vecteurs de chaque n'est que la division du vecteurs propre par sa
#norme
#ici la fonction norme() sera qppele en bas et qui fournit la norme
#de chaque vecteur precedemnt calculer
uA = A / norm_A
uB = B / norm_B
uC = C / norm_C
# retournons chaque vecteurs unitaires Affichage des vecteurs unitaires
#uA, uB et uC
return uA,uB,uC

#une fonction pour calculer le cosinius des angles :r

#cos(~uA,~uB),cos(~uB,~uC) et cos(~uC,~uA)
def cosinus():
#cosinus entre 2 vecteurs sa fait le produit scalaire des 2 vecteurs
#sur la norme du vecteur * la norme du 2 vecteurs
# ici je fait appelle a la fonction DOT de numpy qui fournit le
#produit scalaire de mes vecteurs unitaire que j'ai
# precedement calculer .pour les obtenir je fait appel a la fonction
vecteurs_unitaires qui me fournira lesvecteurs en question
#puis je fait appel a la fonction norme que j'ai creer pour me fournir
#la norme de mes vecteurs
# Calcul des cosinus entre les vecteurs uA, uB et uC
cos_uA_uB = np.dot(A, B) / (norm_A * norm_B)
 cos_uB_uC = np.dot(B, C) / (norm_B * norm_C)
cos_uC_uA = np.dot(C, A) / (norm_C * norm_A)
# Retournons les cosinus entre les vecteurs
return cos_uA_uB, cos_uB_uC, cos_uC_uA

#fonction pour calculer les composantes des vecteurs(produit vectoriel)

def composante_vecteurs():
# Calcul des produits vectoriels e1 = uB ∧ uC, e2 = uC ∧ uA et e3 = uA
#∧ uB
# ici j' utilise la fonction cross de numpy qui permet de retourner le
#produit vecroriel de deux vecteurs
e1 = np.cross(uB, uC)
e2 = np.cross(uC, uA)
e3 = np.cross(uA, uB)
#retournons chaque vecteurs
return e1,e2,e3

#fonction qui determine le sinus des angles

def sinus():
# on connait deja le produit vectoriel entre les differents vecteurs.
#or pour calculer le sinus des
#angles sa fait le produit vectoriel des 2 vecteurs diviser par la
#norme des 2 vecteurs
#or dans notre cas il s'agit de la norme des vecteur unitaire donc ca
#fait 1
#ensuite la fonction np.lingalg .norm me fournit la norme de chque
#vecteur unitaire
sin_uA_uB= np.linalg.norm(e3)/(np.linalg.norm(uA))*(np.linalg.norm(uB))

sin_uB_uC=np.linalg.norm(e1)/(np.linalg.norm(uB))*round((np.linalg.norm(uC#
)))
sin_uA_uC=
np.linalg.norm(e2)/(np.linalg.norm(uA))*round((np.linalg.norm(uC)))
return sin_uA_uB,sin_uB_uC,sin_uA_uC

# ecrivons une fonction qui verifie les resultats obtenu en utilisant les
resultats precedents
def verification():
#verifions les resultats obtenues pour le calcul des sinus
# on sait que en general sin(x)=sqrt(1-cos**2(x)).donc utilisons cette
#formule pour la verification
sin2_uA_uB=np.sqrt(1-(cos_uA_uB)**2)
sin2_uB_uC=np.sqrt(1-(cos_uB_uC)**2)
sin2_uA_uC=np.sqrt(1-(cos_uC_uA)**2)
#ici if est utiliser pour verifier les differentes condition et round
#pour arrondir a 3 chifrre apres la virgule
#si la condition est vrai la fonction retourne un message de la cas
#contraire elle retourne false
if round(sin_uA_uB,4) == round(sin2_uA_uB,4) and round(sin_uB_uC,4)==
round(sin2_uB_uC,4) and round(sin_uA_uC,4) == round(sin2_uA_uC,4):
return "on verifie bien que les angles calculées dans cette
questions sont les memes que ceux calculées dans la question 2"
else:
return "false"

def base():
# pour que ces vecteurs forme une base d'abord: elle doit etre
independant(rang des 3 vecteurs doit donner 3)
#apres ils faut verifier que les 3 vecteurs ne sont pas coplanaire
(produit mixte doit etre different de 0)
# ici la fonction np.vstack() de numpy est une fonction utiliser
pour disposer les vecteurs e1, e2 et e3 verticalement pour former une
matrice
# Ensuite, la fonction np.linalg.matrix_rank(M) est utilisée pour
calculer le rang de cette matrice
M = np.vstack((e1, e2, e3))
R= np.linalg.matrix_rank(M)
#calcul le produit mixte avec np.dot(np.cross()) en specifiant
l'ordre des vecteurs ici c e2,e3,e1
produit_mixte = np.dot(np.cross(e2, e3), e1)
# if est utiliser pour verifier les differnt condition ci_dessous
if (R==3 and produit_mixte!=0 ):
return "les vecteurs e1,e2,e3 constituent une base"
else:
return "les vecteurs e1,e2,e3 ne constituent pas une base"

# definie une fonction pour verifier si les base sont orthogonale normee
def orthogonal_normee():
# Calcul des produits scalaires de ces 3 vecteurs pris 2 a 2 afin de
verifier orthogonalite de ces vecteurs
# calculon la norme de ces vecteurs
prod_e1_e2 = np.dot(e1, e2)
prod_e1_e3 = np.dot(e1, e3)
prod_e2_e3 = np.dot(e2, e3)
norm_e1 = np.linalg.norm(e1)
norm_e2 = np.linalg.norm(e2)
norm_e3 = np.linalg.norm(e3)
#if ici est aussi utiliser pour verifier les condition ci-dessous
if (prod_e1_e2==0 and prod_e1_e3==0 and prod_e2_e3==0 and
norm_e1== norm_e2== norm_e3):
return "cette base est orthogonale puis normee"
elif (prod_e1_e2!=0 and prod_e1_e3!=0 and prod_e2_e3!=0 and
norm_e1== norm_e2== norm_e3):
return "cette base n'est pas orthogonale mais elle est normee"
elif (prod_e1_e2==0 and prod_e1_e3==0 and prod_e2_e3==0 and
norm_e1!= norm_e2!= norm_e3):
return "cette base est orthogonale mais pas normee"
else:
return " cette base n'est pas orthogonal et elle n'est normee"

# ici je commence par resoudre l'exercice par appel de chaque fonction

#1/ calculons les normes des different vecteurs (||A||,|||A|| et ||C||)
norm_A,norm_B,norm_C=norme()
print(" a-/ les normes des different vecteurs sont :\n")
print(f"||A|| = {norm_A}")
print(f"||B|| = {norm_B}")
print(f"||C||= {norm_C}")
print()
#deduisons les vecteurs unitaires
uA,uB,uC=vecteurs_unitaires()
print(" b-/ les vecteurs unitaires pour chaque vecteurs sont:\n")
print(f"uA = {uA}")
print(f"uB = {uB}")
print(f"uC = {uC}")
print()
#2/calculons le cosinus des angles cos_uA_uB, cos_uB_uC, cos_uC_uA
cos_uA_uB, cos_uB_uC, cos_uC_uA=cosinus()
print("2-/ le cosinus des differentes angles sont :\n")
print(f"cos_uA_uB={cos_uA_uB}")
print(f"cos_uB_uC={cos_uB_uC}")
print(f"cos_uC_uA = {cos_uC_uA}")
print()
# 3/Calculer les composantes des vecteurs ~e1 = ~uB ∧~uC, ~e2 = ~uC ∧~uA et
~e3 = ~uA ∧~uB.
e1,e2,e3=composante_vecteurs()
print("3-/ les composantes des differents vecteurs sont :\n")
print(f"e1 = {e1}")
print(f"e2 = {e2}")
print(f"e3 = {e3}")
print()
#4/ En d´eduire sin(~uA, ~uB), sin(~uB, ~uC) et sin(~uA, ~uC)
sin_uA_uB,sin_uB_uC,sin_uA_uC=sinus()
print(" 4-/ deduisons de ce qui precede le sinus des angles:\n")
print(f"sin_uA_uB={round(sin_uA_uB,4)}")
print(f"sin_uB_uC={round(sin_uB_uC,4)}")
print(f"sin_uA_uC={round(sin_uA_uC,4)}")
print()
# verifions ces resultats en utilisant la question 2
#j'appele juste la fonction verification qui verifira les resultas
print("b-/ verification:\n")
print(verification())
print()
#5/Montrer que ~e1, ~e2, ~e3 peuvent constituer une base. Cette base est-
elle orthogonale, norme´e
#j'appelle les fonction base et orthogonal_normee pour resoudre cette
question
print(" 5-/ montrons:\n")
print(base())
print(orthogonal_normee())
Problème 2 : Excès de vitesse
Un conducteur roule `a une vitesse constante v0 = 120 km h −1 sur une route rectiligne
dépassant la limite autorisée. Un gendarme `a moto démarre `a l’instant ou` la
voiture passe `a sa hauteur et accélère uniformement. Le gendarme atteint la vitesse
100 km h −1 au bout de 12s.
1. Quel sera le temps nécessaire au gendarme pour rattraper la voiture?
2. Quelle distance aura-t-il parcourue?
3. Quelle vitesse aura-t-il atteinte?

Résolution du problème :

Un conducteur roule `a une vitesse constante v0 = 120 km h −1 sur une route rectiligne
dépassant la limite autorisée. Un gendarme `a moto démarre `a l’instant ou` la voiture passe
`a sa hauteur et accélère uniformément. Le gendarme atteint la vitesse 100 km h −1 au bout
de 12s.

Soit R(Oxyz) un référentiel et on prend la route parallèle `a l’axe Ox. A l’instant t = 0, ou` la
voiture passe, le gendarme est en O. La position de la voiture est repérée par xV = v0t,
puisque la voiture roule `a la vitesse constante v0.

1. Etablissons les ´équations de mouvement de la moto, repérée par xm, et la voiture

repérée par xV .
La moto accélère uniformément, ce qui implique que γm =constante. La moto
démarre, ce qui implique que v0m = 0. Aussi,

.
Quant `a la voiture, comme son mouvement est uniforme, la vitesse est constante,
alors la position de la voiture `a l’instant t est xV = v0t + x0V = v0t. Le temps tr nécessaire
au gendarme pour rattraper la voiture est le temps au bout duquel
 xm(t = tr) = xV (t = tr) ce qui implique

Or la moto atteint la vitesse v1 = 100 km h −1 au bout de t1 = 12 s. Comme vm = γmt =⇒

γm = v1/t1. Ainsi

A.N. : v0/v1 = 1.2 et tr = 2 × 12 × 1.2 = 28.8 s.

2. La distance L parcourue par le gendarme `a tr est alors égale `a

A.N. : t1 = 12/3600 = 0.00333h, et L = 2 × 1.2 × 100 × 0.00333 = 0.8km.

3. La vitesse atteinte par la moto est

A.N. : vr = 2 × 100 = 200 km h −1.

Implémentation du code python :

import sympy as sp
#j'ai importer la bibliothrque numpy pour exprimer les expression
necessaire sans les calculer
#grace a la fonction sp.symbls integrer dans sympy

# ici je commence par definir pour chaque question une fonction que
j'appelerai a la fin
# pour resoudre les questions.

#definie une fonction pour exprimer le vecteur position de la moto

def position_moto():
# La moto accelere uniformement, ce qui implique que γm =constante. La
moto
# démarre, ce qui implique que v0m = 0 et x0m =0 a t=0 s . donc on a
v0m=0
x0m=0
γm=sp.symbols("γm")
t = sp.symbols("t")
#vm = γm * t + v0m
#xm=sp.integrate(vm,t) xm n'est que une primitif de vm et avec les
condition initial v0m=0
#x0m=0 on obtient expression ci dessous
xm = 0.5 * γm * t**2 + v0m * t + x0m
return xm
def position_voiture():
# Quant `a la voiture, comme son mouvement est uniforme, la vitesse est
constante,
# alors la position de la voiture `a l’instant t est :
t = sp.symbols("t")
v0=sp.symbols("v0")
x0V=0
xV = v0*t + x0V # avec xov=0 car a t=0 xov=0
return xV

#fonction qui determine le temps necessaire pour ratrraper la voiture

def temps_rattrapage():
# ici le gendarme demare au moment ou la voiture passe a sa hauteur
et accelere uniformement
# donc on a xm(t = tr) = xV (t = tr) => que 0,5*γm*tr**2= v0*tr .en
tirant tr on obtient :
tr = (2 * v0) /γm
# avec γm = v1/t1 en remplacant dans
return tr

def distance():
#L =0,5*γm*tr**2 expression de equation horaire
# en ramplacant les expression de γm et de tr dans L on obtient
#L=0,5((v1*4*v0**2*tr**2)/(t1*v1**2)) ce qui donne
L=2*(v0**2*t1)/v1
return L
def vitesse_atteinte():
#la moto etait en mouvement uniformenet accelere donc vr= γm*tr
#vr=(v1*2*v0*t1)/(v1*t1) en simplifiant v1 et t1 , on obtient
vr=2*v0
return vr

#ici je definie juste les donnees du probleme qui seront utiliser par les
#differente fonction pour les calcules

t1=12
v0=(1000*100)/(3600)
v1=(1000*100)/(3600)
γm=(v1)/t1

#appel de chaque fonction pour resoudre l'exercice

#1-/ determinos le temps necessaire (tr) au gendarme pour rattraper la
voiture .
print(" 1-/ determinons tr le temps necessaire au gendarme pour rattraper
la voiture \n")
x0v=position_voiture()
xm=position_moto()
print(f"x0v = {x0v} = {xm}\n")
print("tr = (2 * v0 ) /γm avec γm = v1/t1 .\n ")
print("donc on obtient tr = (2 * v0 * t1 ) /v1 \n")
print(" - le temps necessaire (tr) au gendarme pour rattraper la
voiture .est alors :\n")
tr=temps_rattrapage()
print(f" tr= {tr} seconde")
print()

#2-/ determinos La distance L parcourue par le gendarme au bout du temps

tr:
print("2-/ La distance L parcourue par le gendarme au bout du temps tr
est:\n")
L=distance()
print(f"L= {L} m")
print()

# 3-/ La vitesse atteinte par la moto au bout de ce temps est:

print(" 3-/ La vitesse atteinte par la moto au bout de ce temps est:")
vr=vitesse_atteinte()
print(f" vr= {vr} m/s ")

Rapport :
Le code utilise la bibliothèque SymPy pour résoudre un problème de physique
impliquant une moto et une voiture. La moto accélère uniformément et la voiture se
déplace à vitesse constante. Le code définit plusieurs fonctions pour résoudre
différentes parties du problème, telles que la détermination de l’équation horaire du
mouvement de la moto, le temps nécessaire pour que la moto rattrape la voiture, la
distance parcourue par la moto, et la vitesse atteinte par la moto.
Les résultats sont obtenus en appelant ces fonctions avec des valeurs spécifiques
pour les paramètres tels que la vitesse initiale de la voiture v0, la vitesse maximale de
la moto v1 et le temps nécessaire pour atteindre cette vitesse t1. Le code affiche les
résultats sous forme d’expressions symboliques et numériques.

Le code utilise la bibliothèque NumPy pour résoudre un problème de physique

impliquant des vecteurs. Le code définit plusieurs fonctions pour résoudre
différentes parties du problème, telles que la détermination des normes des vecteurs,
le calcul des vecteurs unitaires, le calcul des cosinus et sinus des angles entre les
vecteurs, et le calcul des composantes des produits vectoriels.

Les résultats sont obtenus en appelant ces fonctions et en utilisant les valeurs
numériques des vecteurs A, B et C définis au début du code. Le code affiche les
résultats sous forme d’expressions numériques.