# 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"

#resolvons 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())

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

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 ")