ANNEE ACADEMIQUE : 2022-2023

RAPPORT DU PROJET DE PROGRAMMATION PYTHON (INF1221)

<< Développement : Mécanique du point>>

ETUDIANT : RESPONSABLES DE L’UE :

TAGBA Tchédré Saturnin Pr, PhD Adekuné Akim SALAMI.

Filière : IA & BIG DATA Dr Séna APEKE.

Numéro de carte : 573268

Vendredi 30 JUIN 2023

SOMMAIRE

SOMMAIRE : …........................................................................................................2

Projet 1 : …...............................................................................................................3

Introduction : …........................................................................................................3

1- énoncé du problème : …....................................................................................3

2 résolution du problème et implémentation en python : …................................5

3 Résultats …..........................................................................................................8

4.Conclusion ….......................................................................... ...............................9

Projet 2 ….................................................................................................................10

Introduction : …................................................................................. ......................10

1-1 énoncé du problème : …....................................................................................11

1-2 résolution du problème et implémentation en python : …...............................11

3 Résultats …............................................................................................................15

4.Conclusion …..........................................................................................................16
PROJET 1:

1.INTRODUCTION

Dans cette introduction, nous expliquons brièvement l'objectif de l'exercice, qui est de calculer
différentes propriétés des vecteurs donnés. Nous indiquons les différentes étapes que le
programme Python effectuera pour résoudre l'exercice, notamment le calcul des normes, des
vecteurs unitaires, des angles, des produits vectoriels, etc.

Nous mentionnons également l'utilisation de fonctionnalités mathématiques disponibles dans la

bibliothèque standard de Python, telles que le module math pour les fonctions trigonométriques
et les calculs mathématiques.

2.ENONCER DU PROBLEME

Opérations sur les vecteurs

On donne trois vecteurs A~ (3, 2 √ 2, √ 3), B~ (2, √ 3, √ 2) et C~ (1, 2, 2).

1. Calculer les normes A~, B~ et C~ . En déduire les vecteurs unitaires uA , uB et uC des directions,
respectivement, de A~, B~ et C~.

2. Calculer cos (uA, uB), cos (uB, uC) et cos (uC, uA), sachant que les angles sont compris entre 0 et
π.

3. Calculer les composantes des vecteurs ~e1 = ~uB ∧~uC, ~e2 = ~uC ∧~uA et ~e3 = ~uA ∧~uB.

4. En déduire sin (~uAd, ~uB), sin (~uBd, ~uC) et sin (~uAd, ~uC). Vérifier ces résultats en utilisant la
question 2.

5. Montrer que ~e1, ~e2, ~e3 peuvent constituer une base. Cette base est-elle orthogonale,
3.RESOLUTION DU PROBLEME

• Les normes des vecteurs A, B et C ont été calculées avec succès, nous permettant de
quantifier leur magnitude ou leur longueur.
• Les vecteurs unitaires uA, uB et uC ont été déterminés en divisant chaque composante des
vecteurs respectivement par leur norme. Ces vecteurs unitaires indiquent la direction des
vecteurs A, B et C avec une magnitude de 1.
• Les cosinus des angles formés entre les vecteurs unitaires ont été calculés, nous donnant
une mesure de la similarité ou de la corrélation entre les directions des vecteurs.
• Les composants des vecteurs e1, e2 et e3 ont été obtenus en utilisant les produits vectoriels
entre les vecteurs unitaires. Ces vecteurs perpendiculaires entre eux peuvent former une
base dans l'espace vectoriel.
• Les sinus des angles formés entre les vecteurs unitaires ont également été calculés et
vérifiés à l'aide des cosinus précédemment calculés, en accord avec la relation
trigonométrique sin^2(x) + cos^2(x) = 1.
• Enfin, nous avons évalué l'orthogonalité et la norme des vecteurs e1, e2 et e3 pour
déterminer s'ils forment une base orthogonale et normée.
4. IMPLEMENTATION DU PROBLEME EN PYTHON

import math

# Vecteurs donnés

A = [3, 2*math.sqrt(2), math.sqrt(3)]

B = [2, math.sqrt(3), math.sqrt(2)]

C = [1, 2, 2]

# Fonction pour calculer la norme d'un vecteur

def norm(vector) :

return math.sqrt(sum([component**2 for component in vector]))

# Calcul des normes des vecteurs A, B et C

norm_A = norm(A)

norm_B = norm(B)

norm_C = norm(C)

Print(“1. Calculons les normes A~, B~ et C~: “)

print("Norme de A : ", norm_A)

print("Norme de B : ", norm_B)

print("Norme de C : ", norm_C)

# Calcul des vecteurs unitaires

uA = [component/norm_A for component in A]

uB = [component/norm_B for component in B]

uC = [component/norm_C for component in C]

Print(“déduisons les vecteurs unitaires : ”)

print("Vecteur unitaire uA: ", uA)

print("Vecteur unitaire uB: ", uB)

print("Vecteur unitaire uC: ", uC)

# Fonction pour calculer le produit scalaire entre deux vecteurs

def dot_product(vector1, vector2) :

return sum([component1 * component2 for component1, component2 in zip (vector1, vector2)])

# Fonction pour calculer l'angle entre deux vecteurs en radians

def angle_between_vectors(vector1, vector2) :

dot = dot_product(vector1, vector2)

return math.acos(dot)

# Calcul des angles entre les vecteurs unitaires

angle_uA_uB = angle_between_vectors(uA, uB)

angle_uB_uC = angle_between_vectors(uB, uC)

angle_uC_uA = angle_between_vectors(uC, uA)

cos_angle_uA_uB = math.cos(angle_uA_uB)

cos_angle_uB_uC = math.cos(angle_uB_uC)

cos_angle_uC_uA = math.cos(angle_uC_uA)

Print(“2. Calculons les cosinus entre les deux vecteurs : ”)

print("Cosinus de l'angle entre uA et uB: ", cos_angle_uA_uB)

print("Cosinus de l'angle entre uB et uC: ", cos_angle_uB_uC)

print("Cosinus de l'angle entre uC et uA: ", cos_angle_uC_uA)

# Calcul des composantes des vecteurs e1, e2 et e3

e1 = [uB[1] *uC[2] - uB[2] *uC[1], uB[2] *uC[0] - uB[0] *uC[2], uB[0] *uC[1] - uB[1] *uC[0]]

e2 = [uC[1] *uA[2] - uC[2] *uA[1], uC[2] *uA[0] - uC[0] *uA[2], uC[0] *uA[1] - uC[1] *uA[0]]

e3 = [uA[1] *uB[2] - uA[2] *uB[1], uA[2] *uB[0] - uA[0] *uB[2], uA[0] *uB[1] - uA[1] *uB[0]]

Print(“3. Calculons les composantes des vecteurs e1, e2, e3: “)

print("Composantes de e1 : ", e1)

print("Composantes de e2 : ", e2)

print("Composantes de e3 : ", e3)

# Calcul des sinus des angles en utilisant la relation sin^2(x) + cos^2(x) = 1

sin_angle_uA_uB = math.sqrt(1 - cos_angle_uA_uB**2)

sin_angle_uB_uC = math.sqrt(1 - cos_angle_uB_uC**2)

sin_angle_uC_uA = math.sqrt(1 - cos_angle_uC_uA**2)

Print(“4. Calculons le sinus entre les vecteurs :”)

print("Sinus de l'angle entre uA et uB: ", sin_angle_uA_uB)

print("Sinus de l'angle entre uB et uC: ", sin_angle_uB_uC)

print("Sinus de l'angle entre uC et uA: ", sin_angle_uC_uA)

# Vérification de l'orthogonalité des vecteurs e1, e2 et e3

Print(“5. Montrer que ~e1, ~e2, ~e3 peuvent constituer une base. Cette base est-elle orthogonale,,
normée ?”)

is_orthogonal = dot_product(e1, e2) == 0 and dot_product(e2, e3) == 0 and dot_product(e3, e1) == 0

if is_orthogonal:

print("Les vecteurs e1, e2 et e3 forment une base orthogonale.")

else:

print("Les vecteurs e1, e2 et e3 ne forment pas une base orthogonale.")

4.RESULTATS

L’exécution de ce programme nous donne :

C:\Users\USER\PycharmProjects\pythonProject\venv\Scripts\python.exe
"C:\Users\USER\Downloads\PROJET EXAMEN\Proj.py"

1. Calculons les normes A~, B~ et C~:

Norme de A : 4.47213595499958

Norme de B : 3.0

Norme de C : 3.0

Déduisons les vecteurs unitaires :

Vecteur unitaire uA: [0.6708203932499369, 0.6324555320336759, 0.38729833462074165]

Vecteur unitaire uB: [0.6666666666666666, 0.5773502691896257, 0.47140452079103173]

Vecteur unitaire uC: [0.3333333333333333, 0.6666666666666666, 0.6666666666666666]

2. calculons les cosinus entre les deux vecteurs :

Cosinus de l'angle entre uA et uB: 0.994936153005124

Cosinus de l'angle entre uB et uC: 0.9213920822093272

Cosinus de l'angle entre uC et uA: 0.903442708852924

3.calculons les composantes des vecteurs e1, e2, e3 :

Composantes de e1 : [0.07063049893239598, -0.2873096041807672, 0.2519943547145692]

Composantes de e2 : [-0.1634381316086228, 0.3181141506263774, -0.23639508482206598]

Composantes de e3 : [0.07453559924999309, -0.0580288762696769, -0.034338686735042256]

4. calculons le sinus entre les vecteurs :

Sinus de l'angle entre uA et uB: 0.10050896200520938

Sinus de l'angle entre uB et uC: 0.3886343150597492

Sinus de l'angle entre uC et uA: 0.4287088427131995

5. Montrer que ~e1, ~e2, ~e3 peuvent constituer une base. Cette base est-elle orthogonale,, normée
?

Les vecteurs e1, e2 et e3 ne forment pas une base orthogonale.

Process finished with exit code 0

5.CONCLUSION

En conclusion, cet exercice nous permet d'explorer diverses opérations vectorielles et de

calculer différentes quantités associées aux vecteurs donnés.
PROJET2 : Spirale logarithmique

1.INTRODUCTION

Dans ce projet, nous allons simuler le mouvement d'un point M dans un référentiel R(O,
~i, ~j, ~k). Les équations horaires du mouvement de ce point sont données par les
fonctions suivantes :
x(t) = be^(-kt) * cos(kt) y(t) = be^(-kt) * sin(kt) z(t) = 0
Où t est le temps, b est une constante positive et k est un coefficient positif.
L'objectif de ce projet est de comprendre et d'analyser le mouvement du point M en
fonction des paramètres t, b et k. Pour cela, nous allons résoudre plusieurs questions et
visualiser la trajectoire du point M.
2.ENONCER DU PROBLEME

Les équations horaires du mouvement de M par rapport `a R(O,~i,~j,~k) sont données par x(t) =
be−ktcos(kt), y(t) = be−ktsin(kt) et z(t) = 0.

1. a- Calculer les coordonnées polaires ρ et ϕ de M en fonction de t. b- En déduire l’équation polaire

de la trajectoire ρ(ϕ).

2. a- Déterminer les composantes polaires du vecteur vitesse V~ (M/R) en fonction de t.

b- Calculer l’angle α = (−−→OM, V~d(M/R)). Conclure.

c- Quelle est la nature du mouvement ?

3. a- Déterminer les composantes polaires de l’accélération.

b- En déduire la direction et le sens de l’accélération.

4. a- Calculer les vecteurs unitaires de la base de Fresnet.

b- En déduire les composantes tangentielle et normale de l’accélération.

c- Déterminer le rayon de courbure de la trajectoire au point M.

3.RESOLUTION DU PROBLEME:

Pour résoudre ce problème, nous allons suivre les étapes suivantes :

• Calcul des coordonnées polaires ρ et ϕ de M en fonction de t : Pour obtenir les coordonnées

polaires ρ et ϕ en fonction du temps t, nous utiliserons les équations horaires x(t) et y(t)
données dans l'énoncé. En utilisant la formule de conversion des coordonnées cartésiennes
aux coordonnées polaires, nous pourrons exprimer les coordonnées (x, y) en fonction de ρ et
ϕ.
• Équation polaire de la trajectoire ρ(ϕ) : En utilisant les coordonnées polaires ρ et ϕ obtenues
précédemment, nous pourrons exprimer l'équation polaire de la trajectoire. Cela nous
permettra de visualiser la forme de la trajectoire du point M en termes de distance ρ par
rapport à l'origine O en fonction de l'angle ϕ.
• Calcul des composantes polaires du vecteur vitesse V~ (M/R) en fonction de t : Pour calculer
les composantes polaires du vecteur vitesse de M par rapport à R en fonction du temps t,
nous dériverons les équations horaires x(t) et y (t) par rapport à t. Cela nous permettra
d'obtenir les dérivées de x et y par rapport à t, représentant les caractéristiques de la vitesse
V~ (M/R).
• Calcul de l'angle α = (−−→OM, V~d(M/R)) : Pour calculer l'angle α entre le vecteur position
OM et le vecteur vitesse Vd(M/R), nous utiliserons les coordonnées du vecteur position et
du vecteur vitesse obtenue précédemment. Cela nous aide à analyser la direction du
mouvement.
• Nature du mouvement : En fonction de l'angle α, nous pourrons conclure sur la nature du
mouvement. Si α est nul, cela indique un mouvement rectiligne, sinon, cela indique un
mouvement courbe.
• Calcul des caractéristiques polaires de l'accélération : Pour calculer les caractéristiques
polaires de l'accélération de M, nous devrons dériver les équations de caractéristiques de
vitesse par rapport au temps t une deuxième fois. Cela nous permettra d'obtenir les
caractéristiques de l'accélération en fonction de t.
• Direction et sens de l'accélération : En analysant les composantes polaires de l'accélération,
nous pourrons déterminer la direction et le sens de l'accélération par rapport à la
trajectoire.
• Calcul des vecteurs unitaires de la base de Fresnet : Les vecteurs unitaires de la base de
Fresnet peuvent être calculés en fonction de l'angle ϕ. Ces vecteurs nous permettent de
calculer les composantes tangentielles et normales de l'accélération.
 • Calcul des composantes tangentielles et normales de l'accélération : en utilisant les vecteurs
unitaires de la base de Fresnet et les composantes de l'accélération, nous pourrons
déterminer les composantes tangentielles et normales de l'accélération.
• Détermination du rayon de courbure de la trajectoire au point M : Pour déterminer le rayon
de courbe

4.IMPLEMENTATION DU PROGRAMME EN PYTHON

import math

# Fonction pour calculer les coordonnées polaires ρ et ϕ en fonction de t

def coordonnees_polaires(t, b, k) :

x = b * math.exp(-k*t) * math.cos(k*t)

y = b * math.exp(-k*t) * math.sin(k*t)

rho = math.sqrt(x**2 + y**2)

phi = math.atan2(y, x)

return rho, phi

# 1. a) Calcul des coordonnées polaires ρ et ϕ en fonction de t

t = 2.5 # Valeur de t donnée (vous pouvez la changer selon vos besoins)

b = 1.0 # Valeur de b

k = 0.5 # Valeur de k

rho, phi = coordonnees_polaires(t, b, k)

print("1. a) Coordonnées polaires :")

print(" ρ =", rho)

print(" ϕ =", phi)

# 1. b) Équation polaire de la trajectoire ρ(ϕ)

def equation_polaire(b, k):

return f"ρ = {b * math.exp(-k*t)}"

equation = equation_polaire(b, k)

print("1. b) Équation polaire de la trajectoire :")

print(" ", equation)

# 2. a) Calcul des composantes polaires du vecteur vitesse V~ (M/R) en fonction de t

def composantes_vitesse(t, b, k):

x_prime = -b * math.exp(-k*t) * math.cos(k*t) * (k + math.sin(k*t))

y_prime = -b * math.exp(-k*t) * math.sin(k*t) * (k - math.cos(k*t))

return x_prime, y_prime

v_x, v_y = composantes_vitesse(t, b, k)

print("2. a) Composantes polaires du vecteur vitesse :")

print(" Vx =", v_x)

print(" Vy =", v_y)

# 2. b) Calcul de l'angle α = (−−→OM, V~d(M/R))

alpha = math.atan2(v_y, v_x) - phi

print("2. b) Angle α = ", alpha)

# 2. c) Nature du mouvement

if alpha == 0:

print("2. c) Le mouvement est rectiligne.")

else:

print("2. c) Le mouvement est courbe.")

# 3. a) Calcul des composantes polaires de l'accélération

def composantes_acceleration(t, b, k):

x_double_prime = b * math.exp(-k*t) * (

(k**2 - 2*k**2*math.cos(k*t) - math.sin(k*t) + k*math.cos(k*t)**2) * math.exp(k*t)

y_double_prime = b * math.exp(-k*t) * (

(k**2 - 2*k**2*math.cos(k*t) + math.cos(k*t) - k*math.sin(k*t) *math.cos(k*t)) * math.exp(k*t)

return x_double_prime, y_double_prime

a_x, a_y = composantes_acceleration(t, b, k)

print("3. a) Composantes polaires de l'accélération :")

print(" Ax =", a_x)

print(" Ay =", a_y)

# 3. b) Direction et sens de l'accélération

if a_x > 0 and a_y > 0:

print("3. b) L'accélération est dirigée vers l'extérieur de la trajectoire.")

elif a_x < 0 and a_y > 0:

print("3. b) L'accélération est dirigée vers l'intérieur de la trajectoire.")

else:

print("3. b) L'accélération n'est pas clairement dirigée vers l'extérieur ou l'intérieur de la

trajectoire.")
# 4. a) Calcul des vecteurs unitaires de la base de Fresnet

def vecteurs_unitaires(phi) :

i_fresnet = math.cos(phi)

j_fresnet = math.sin(phi)

return i_fresnet, j_fresnet

i_fresnet, j_fresnet = vecteurs_unitaires(phi)

print("4. a) Vecteurs unitaires de la base de Fresnet :")

print(" i_fresnet =", i_fresnet)

print(" j_fresnet =", j_fresnet)

# 4. b) Calcul des composantes tangentielle et normale de l'accélération

a_tangentielle = a_x * i_fresnet + a_y * j_fresnet

a_normale = a_x * j_fresnet - a_y * i_fresnet

print("4. b) Composantes tangentielle et normale de l'accélération :")

print(" Accélération tangentielle =", a_tangentielle)

print(" Accélération normale =", a_normale)

# 4. c) Calcul du rayon de courbure de la trajectoire au point M

rayon_courbure = abs(math.pow((v_x**2 + v_y**2), 1.5) / (v_x*a_y - v_y*a_x))

print("4. c) Rayon de courbure de la trajectoire au point M =", rayon_courbure)

5.RESULTAT:

Le résultat de ce programme donne:

C:\Users\USER\PycharmProjects\pythonProject\venv\Scripts\python.exe
C:\Users\USER\PycharmProjects\pythonProject\main.py

1. a) Coordonnées polaires :

ρ = 0.2865047968601901

ϕ = 1.25

1. b) Équation polaire de la trajectoire :

 ρ = 0.2865047968601901

2. a) Composantes polaires du vecteur vitesse :

Vx = -0.1309032547282591

Vy = -0.05021175275946529

2. b) Angle α = -4.025321875034706

2. c) Le mouvement est courbe.

3. a) Composantes polaires de l'accélération :

Ax = -0.8069317044399539

Ay = 0.25804314517164517

3. b) L'accélération est dirigée vers l'intérieur de la trajectoire.

4. a) Vecteurs unitaires de la base de Fresnet :

i_fresnet = 0.3153223623952687

j_fresnet = 0.9489846193555862

4. b) Composantes tangentielle et normale de l'accélération :

Accélération tangentielle = -0.009564635437615016

Accélération normale = -0.8471325505193323

4. c) Rayon de courbure de la trajectoire au point M = 0.03709417236945311

Process finished with exit code 0

6.CONCLUSION:

Après avoir résolu cet exercice et analysé le mouvement du point M dans le référentiel
R, nous pouvons tirer les conclusions suivantes : 1. Trajectoire polaire : La trajectoire du
point M est décrite par une équation polaire ρ(ϕ) où ρ représente la distance du point M
par rapport à l'origine O et ϕ représente l'angle par rapport à l'axe x. Selon les valeurs
de b et k, la trajectoire peut être une spirale, une courbe fermée ou une ligne droite, en
fonction de l'effet combiné de la décroissance exponentielle et de la fonction
trigonométrique