I. Introduction▲
Après avoir donné une rapide présentation des vecteurs et des opérations qui leur sont associées, nous allons montrer comment les définir avec NumPy et les représenter graphiquement à l'aide de Matplotlib.
Ensuite, nous allons réaliser différentes opérations dans l'environnement Python, comme l'addition de deux vecteurs NumPy, la multiplication par un scalaire, ou encore la transformation d'un vecteur via une fonction mathématique.
L'objectif est surtout de découvrir le calcul vectoriel avec NumPy à travers des exemples concrets : addition vectorielle, calcul du barycentre de trois points, détermination du centre de masse d'un demi-disque.
II. Vecteur▲
D'après Wikipédia, en mathématiques, un vecteur est un objet généralisant plusieurs notions provenant de la géométrie (couples de points, translations, etc.), de l'algèbre (« solution » d'un système d'équations à plusieurs inconnues), ou encore de la physique (forces, vitesses, accélérations, etc.).
Dans un espace vectoriel, il est possible d'additionner des vecteurs et de les multiplier par un scalaire (c'est-à-dire un nombre).
Un couple ou un triplet de nombres réels peut être vu comme un vecteur de ℝ2 ou ℝ3. L'addition et la multiplication par un nombre réel se font alors composante par composante.
II-A. Représentation algébrique d'un vecteur▲
Dans un repère orthonormé, un vecteur du plan est représenté par une composante suivant l’axe x et une autre suivant l’axe y :
kitxmlcodelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodelatexdvp
Dans l'espace, un vecteur est défini par ses composantes selon les axes x, y et z :
On peut de la même manière imaginer une représentation d'un vecteur à n composantes dans un espace à n dimensions.
II-B. Addition de vecteurs▲
Soient les vecteurs du plan :
kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp{\vec {v}}{\begin{pmatrix}v_{x}\\v_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp
L'addition de ces deux vecteurs composante par composante nous donne :
II-C. Multiplication d'un vecteur par un scalaire▲
Prenons maintenant le vecteur :
kitxmlcodelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodelatexdvp
La multiplication de ce vecteur par un scalaire s (nombre réel) nous donne cette fois :
II-D. Produit scalaire▲
Le produit scalaire possède de multiples applications. En physique, il est, par exemple, utilisé pour modéliser le travail d'une force.
Le produit scalaire des vecteurs kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp{\vec {v}}{\begin{pmatrix}v_{x}\\v_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp s'écrit :
kitxmlcodelatexdvp{\overrightarrow{u}\cdot\overrightarrow{v} =u_{x}v_{x}+u_{y}v_{y}}finkitxmlcodelatexdvpII-E. Norme d'un vecteur▲
En physique, une force est représentée par un vecteur dont la norme correspond à son intensité.
La norme d'un vecteur kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp peut se calculer à l'aide du produit scalaire :
kitxmlcodelatexdvp{\left\| \overrightarrow{u} \right\|=\sqrt{\overrightarrow{u}\cdot \overrightarrow{u}}=\sqrt{u_{x}^{2}+u_{y}^{2}}}finkitxmlcodelatexdvpII-F. Application d'une fonction à un vecteur▲
Soit une fonction de la variable réelle qui à x associe f(x) :
kitxmlcodelatexdvp{\begin{matrix}f:&\mathbb {R} &\longrightarrow &\mathbb {R} \\&x&\longmapsto &f(x)\end{matrix}}finkitxmlcodelatexdvpLe vecteur kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp est transformé en le vecteur kitxmlcodeinlinelatexdvp{\vec {v}}{\begin{pmatrix}f(u_{x})\\f(u_{y})\end{pmatrix}}finkitxmlcodeinlinelatexdvp par l’application de la fonction f.
Dans la même idée, on verra par la suite comment transformer un vecteur NumPy en lui appliquant une fonction mathématique.
II-G. Barycentre et centre de masse▲
On définit le barycentre de deux points A et B du plan affectés des coefficients de pondération a et b (avec la somme a + b non nulle) comme l'unique point G vérifiant la relation vectorielle :
kitxmlcodelatexdvp{a\overrightarrow{GA}+b\overrightarrow{GB}=\overrightarrow{0}}finkitxmlcodelatexdvp
Plus généralement, le barycentre des n points kitxmlcodeinlinelatexdvp{A_{1},\cdots ,A_{n}}finkitxmlcodeinlinelatexdvp affectés des coefficients kitxmlcodeinlinelatexdvp{a_{1},\cdots ,a_{n}}finkitxmlcodeinlinelatexdvp est l'unique point G tel que :
Si tous les coefficients sont égaux, on parle d’isobarycentre. Dans ce cas, le point G est tel que :
En introduisant le point origine O(0, 0) dans la relation, on obtient :
Ce qui est équivalent à :
Cette dernière formule va nous permettre de déterminer les coordonnées du point G, à partir des positions des n points.
Le centre de masse est le point d’équilibre d’un objet. En géométrie, lorsqu’on considère un ensemble fini de points associés à des masses ponctuelles, le centre de masse correspond exactement au barycentre de ces points pondérés.
Nous montrerons d’ailleurs, à la fin de l'article, que le barycentre G de n points uniformément répartis dans un disque coïncide avec le centre de masse de ce disque homogène.
En statistiques, le point G est appelé le point moyen des n points A1, … , An. La formule du barycentre est ainsi utilisée dans la méthode des k-moyennes pour déterminer le centroïde de chaque groupe de points.
III. Les vecteurs avec NumPy et Matplotlib▲
Partant de là, voyons maintenant comment manipuler et visualiser ces vecteurs avec NumPy et Matplotlib.
III-A. Représentation des vecteurs▲
Un vecteur kitxmlcodeinlinelatexdvp{{\vec {u}}{\begin{pmatrix}3\\2\end{pmatrix}}}finkitxmlcodeinlinelatexdvp est défini avec la bibliothèque NumPy par un tableau unidimensionnel numpy.array([3, 2]) :
>>> import numpy as np
>>> u = np.array([3, 2])
>>> u
array([3, 2])
Ou en affichant le contenu du vecteur avec la fonction print() :
>>> import numpy as np
>>> u = np.array([3, 2])
>>> print(u)
[3 2]
Les composantes d'un vecteur correspondent donc aux éléments d'un tableau 1D, par exemple des nombres réels ou entiers.
Si vous souhaitez avoir plus d'informations sur les tableaux NumPy, je vous invite à consulter cette documentation.
On peut ensuite tracer ce vecteur sur un graphique en partant de l’origine (0,0) et à l'aide de la fonction pyplot.quiver() du module matplotlib :
import matplotlib.pyplot as plt
# Trace le vecteur u d'origine (0,0) et de composantes (3, 2)
plt.quiver(0, 0, 3, 2, color = 'b', angles ='xy', scale_units = 'xy', scale = 1)
Arguments de la fonction plt.quiver() :
- 0, 0 : origine du vecteur ;
- 3, 2 : composantes du vecteur ;
- color = 'b' : couleur du vecteur, ici bleu ;
- angles ='xy' : indique que les vecteurs sont tracés dans le système de coordonnées de l’axe (x, y) ;
- scale_units = 'xy' : signifie que les unités de l’échelle sont les mêmes que celles des axes x et y ;
- scale = 1 : échelle du tracé, 1 pour taille réelle, 0.5 pour un facteur 2. Plus la valeur est faible, plus le vecteur représenté est long.
La méthode pyplot.quiver() offre davantage de fonctionnalités que pyplot.arrow() : gestion de l'échelle, respect des unités du repère cartésien, rendu plus précis, etc.
Ce qui nous donne :
import numpy as np
import matplotlib.pyplot as plt
# Place deux points qu'on n'affiche pas afin de délimiter l'étendue des axes
plt.plot(-2, -2, "None")
plt.plot(5, 5, "None")
# Trace un repère orthonormé
plt.axis('equal')
# création du vecteur numpy
u = np.array([3,2])
# Trace le vecteur u d'origine (0,0) et de composantes (u[0], u[1])
plt.quiver(0, 0, u[0], u[1], color='b', angles='xy', scale_units = 'xy', scale = 1)
plt.title("Vecteur u(3, 2) d'origine (0, 0)")
# ajout de la grille sur le graphique
plt.grid()
# On affiche le graphique
plt.show()
Lors de son exécution, le script affiche :
III-B. Addition de vecteurs▲
Comme pour des vecteurs classiques, l'addition de deux vecteurs NumPy se fait composante par composante :
>>> u = np.array([2, 3])
>>> v = np.array([3, -1])
>>> u+v
array([5, 2])
On peut maintenant tracer les vecteurs sur un graphique à l'aide du module Matplotlib :
import numpy as np
import matplotlib.pyplot as plt
# On place deux points qu'on n'affiche pas afin de délimiter l'étendue des axes
plt.plot(-2, -2, "None")
plt.plot(5, 5, "None")
# Trace un repère orthonormé
plt.axis('equal')
# création des vecteurs numpy
u = np.array([2,3])
v = np.array([3,-1])
# addition des vecteurs
w = u + v
# Trace le vecteur u d'origine (0,0) et de composantes (u[0], u[1])
plt.quiver(0, 0, u[0], u[1], color='b', angles='xy', scale_units = 'xy', scale = 1)
# Trace le vecteur v d'origine (u[0],u[1]) et de composantes (v[0], v[1])
plt.quiver(u[0], u[1], v[0], v[1], color='g', angles='xy', scale_units = 'xy', scale = 1)
# Trace le vecteur w d'origine (0,0) et de composantes (w[0], w[1])
plt.quiver(0, 0, w[0], w[1], color='r', angles='xy', scale_units = 'xy', scale = 1)
# ajout du titre
plt.title('Addition de vecteurs')
# ajout de la grille sur le graphique
plt.grid()
# On affiche la fenêtre graphique
plt.show()
Le code affiche :
L'addition du vecteur kitxmlcodeinlinelatexdvp{\overrightarrow{u}}finkitxmlcodeinlinelatexdvp en bleu et du vecteur kitxmlcodeinlinelatexdvp{\overrightarrow{v}}finkitxmlcodeinlinelatexdvp en vert donne un troisième vecteur affiché en rouge.
III-C. Multiplication par un scalaire▲
La multiplication d'un vecteur u par un scalaire 2 se fait ainsi :
>>> u = np.array([2, 3])
>>> 2*u
array([4, 6])
Traçons maintenant les vecteurs sur un graphique en utilisant le module Matplotlib :
import numpy as np
import matplotlib.pyplot as plt
# On place deux points qu'on n'affiche pas afin de délimiter l'étendue des axes
plt.plot(-2, -2, "None")
plt.plot(10, 10, "None")
# Trace un repère orthonormé
plt.axis('equal')
# création du vecteur numpy u
u = np.array([2,3])
# scalaire
s = 2
# multiplication de u par le scalaire s
v = s*u
# Trace le vecteur u d'origine (0,0) et de composantes (v[0], v[1])
plt.quiver(0, 0, u[0], u[1], color='b', angles='xy', scale_units = 'xy', scale = 1)
# Trace le vecteur v d'origine (1,0) et de composantes (v[0], v[1])
plt.quiver(1, 0, v[0], v[1], color='r', angles='xy', scale_units = 'xy', scale = 1)
# ajout du titre
plt.title("Multiplication d'un vecteur par un scalaire")
# ajout de la grille sur le graphique
plt.grid()
# Affiche le graphique
plt.show()
Lors de son exécution, le code affiche :
En bleu le vecteur kitxmlcodeinlinelatexdvp{\overrightarrow{u}}finkitxmlcodeinlinelatexdvp et en rouge le vecteur obtenu après multiplication de kitxmlcodeinlinelatexdvp{\overrightarrow{u}}finkitxmlcodeinlinelatexdvp par 2.
III-D. Produit scalaire▲
Le produit scalaire de deux vecteurs numpy.array([1, 2]) et numpy.array([3, 4]) peut se calculer avec la fonction numpy.dot :
>>> import numpy as np
>>> u = np.array([1, 2])
>>> v = np.array([3, 4])
>>> np.dot(u,v)
11Le produit scalaire kitxmlcodeinlinelatexdvp{\overrightarrow{u}\cdot \overrightarrow{v}=1×3 + 2×4}finkitxmlcodeinlinelatexdvp est égal à 11.
III-E. Norme d'un vecteur▲
La norme d'un vecteur numpy.array([3, 4]) s'obtient à l'aide de la fonction numpy.linalg.norm :
>>> import numpy as np
>>> u = np.array([3, 4])
>>> np.linalg.norm(u)
5.0Ici la norme kitxmlcodeinlinelatexdvp{\left\| \overrightarrow{u} \right\| = \sqrt{3^{2}+4^{2}}}finkitxmlcodeinlinelatexdvp vaut 5.
III-F. Application d'une fonction à un vecteur▲
On peut également appliquer une fonction à un tableau NumPy 1D pour le transformer en un autre tableau 1D sans utiliser de boucle :
>>> u = np.array([4, 9, 16, 25])
>>> np.sqrt(u)
array([2., 3., 4., 5.])
La fonction NumPy np.sqrt() calcule la racine carrée de chaque élément du tableau np.array([4, 9, 16, 25]) et renvoie array([2., 3., 4., 5.]) sans utiliser de boucle grâce au calcul vectorisé.
Traçons maintenant un cercle unité (centre à l’origine, rayon 1) en utilisant cette technique :
import numpy as np
import matplotlib.pyplot as plt
# nom et dimension de la figure contenant le graphique
plt.figure(num="Application d'une fonction à un vecteur numpy", figsize=(7, 6), dpi=80)
# même échelle sur l'axe des x et des y
plt.axis('scaled')
# trace le point centre du cercle en rouge
plt.scatter(0, 0, s=20, color = 'r')
# création du tableau d'angles θ allant de 0 à 2π (tour complet)
θ = np.linspace(0, 2 * np.pi, 400)
# calcul des coordonnées x et y des points du cercle à partir des angles θ
x = np.cos(θ)
y = np.sin(θ)
# Trace le cercle de centre (0,0) et de rayon 1
plt.plot(x, y, color='r', linewidth=2)
# limites inférieures et supérieures sur l'axe des x et des y
plt.xlim(-1.1, 1.1); plt.ylim(-1.1, 1.1)
# ajout du titre
plt.title("Cercle de centre (0,0) et de rayon 1")
# Affiche le graphique
plt.show()Les fonctions NumPy np.cos() et np.sin() appliquées à un tableau d’angles θ renvoient respectivement les coordonnées x et y des points du cercle unité.
Le code affiche :
La vectorisation dans NumPy nous permet donc d’effectuer des opérations directement sur des tableaux, plutôt que de passer en boucle sur des éléments individuels. Cela rend le code plus concis, plus lisible et souvent beaucoup plus rapide.
III-G. Isobarycentre et centre de masse▲
III-G-1. Isobarycentre de 3 points dans le plan▲
On souhaite déterminer l’isobarycentre des points A, B et C, à l’aide de la formule suivante :
kitxmlcodelatexdvp{\overrightarrow{OG}=\frac{1}{3}(\overrightarrow{OA}+\overrightarrow{OB}+\overrightarrow{OC})}finkitxmlcodelatexdvp
Il faut d’abord positionner les trois points dans le plan :
# création des trois points A(2,2), B(4,5) et C(6,2)
A = (2,2)
B = (4,5)
C = (6,2)
# Trace le point A en bleu
plt.scatter(A[0], A[1], s=20, color = 'b')
plt.annotate('A', xy=(A[0], A[1]))
# Trace le point B en vert
plt.scatter(B[0], B[1], s=20, color = 'g')
plt.annotate('B', xy=(B[0], B[1]))
# Trace le point C en orange
plt.scatter(C[0], C[1], s=20, color = 'orange')
plt.annotate('C', xy=(C[0], C[1]))
Puis, construire et tracer les trois vecteurs depuis l'origine du repère vers ces trois points :
# construction des vecteurs associés aux 3 points
OA = np.array(A)
OB = np.array(B)
OC = np.array(C)
# Trace le vecteur OA
plt.quiver(0, 0, OA[0], OA[1], color='b', angles='xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OB
plt.quiver(0, 0, OB[0], OB[1], color='g', angles='xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OC
plt.quiver(0, 0, OC[0], OC[1], color='orange', angles='xy', scale_units = 'xy', scale = 1)
Et enfin, déterminer et tracer l'isobarycentre G de ces trois points :
# détermination du vecteur OG reliant l'origine à l'isobarycentre des 3 points
OG = (1/3)*(OA+OB+OC)
# Trace le point G en rouge
plt.scatter(OG[0], OG[1], s=10, color = 'r')
plt.annotate('G', xy=(OG[0], OG[1]))
Script complet associé à l'exemple traité :
import numpy as np
import matplotlib.pyplot as plt
# Place deux points qu'on n'affiche pas afin de délimiter l'étendue des axes
plt.plot(0, 0, "None")
plt.plot(7, 7, "None")
# même échelle sur l'axe des x et des y
plt.axis('scaled')
# Trace un repère orthonormé
plt.axis('equal')
# création des trois points A(2,2), B(4,5) et C(6,2)
A = (2,2)
B = (4,5)
C = (6,2)
# Trace le point A en bleu
plt.scatter(A[0], A[1], s=20, color = 'b')
plt.annotate('A', xy=(A[0], A[1]))
# Trace le point B en vert
plt.scatter(B[0], B[1], s=20, color = 'g')
plt.annotate('B', xy=(B[0], B[1]))
# Trace le point C en orange
plt.scatter(C[0], C[1], s=20, color = 'orange')
plt.annotate('C', xy=(C[0], C[1]))
print('Point A{0}'.format(A))
print('Point B{0}'.format(B))
print('Point C{0}'.format(C))
# Trace le triangle ABC
x1, y1 = [A[0], B[0]], [A[1], B[1]]
x2, y2 = [B[0], C[0]], [B[1], C[1]]
x3, y3 = [A[0], C[0]], [A[1], C[1]]
plt.plot(x1, y1, x2, y2, x3, y3, color="black")
# construction des vecteurs associés aux trois points
OA = np.array(A)
OB = np.array(B)
OC = np.array(C)
# Trace sur le graphique les trois vecteurs obtenus
# Trace le vecteur OA
plt.quiver(0, 0, OA[0], OA[1], color='b', angles='xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OB
plt.quiver(0, 0, OB[0], OB[1], color='g', angles='xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OC
plt.quiver(0, 0, OC[0], OC[1], color='orange', angles='xy', scale_units = 'xy', scale = 1)
# détermination du vecteur OG reliant l'origine à l'isobarycentre des 3 points
OG = (1/3)*(OA+OB+OC)
# Trace le point G en rouge
plt.scatter(OG[0], OG[1], s=20, color = 'r')
plt.annotate('G', xy=(OG[0], OG[1]))
print()
print("Isobarycentre G{0}".format((OG[0],OG[1])))
print()
print("Génération du graphique ...\n")
# ajout du titre
plt.title("Isobarycentre de 3 points")
# Affiche le graphique
plt.show()
Lors de son exécution, le script affiche :
Point A(2, 2)
Point B(4, 5)
Point C(6, 2)
Isobarycentre G(4.0, 3.0)
Génération du graphique ...
Puis le graphique :
L’isobarycentre des sommets du triangle correspond au point d’intersection des médianes.
III-G-2. Centre de masse d'un disque▲
Soient n points kitxmlcodeinlinelatexdvp{A_{1},\cdots ,A_{n}}finkitxmlcodeinlinelatexdvp de même poids, espacés régulièrement à l'intérieur d'un disque homogène de centre (ox, oy) et de rayon r. Leurs vecteurs de position kitxmlcodeinlinelatexdvp{\overrightarrow{OA}_{1},\cdots ,\overrightarrow{OA}_{n}}finkitxmlcodeinlinelatexdvp relient l'origine du repère aux n points.
Notre objectif est de vérifier, à l'aide de la relation kitxmlcodeinlinelatexdvp{\overrightarrow{OG}=\frac{1}{n}\sum_{i=1}^{n}\overrightarrow{OA_{i}}}finkitxmlcodeinlinelatexdvp, que le point G coïncide avec le centre du disque supposé homogène.
Pour cela, on va d'abord générer les n vecteurs kitxmlcodeinlinelatexdvp{\overrightarrow{OA}_{1},\cdots ,\overrightarrow{OA}_{n}}finkitxmlcodeinlinelatexdvp.
Déroulé de la fonction qui génère les vecteurs :
- 1. Initialisation de la liste des vecteurs
- 2. Parcours des valeurs de ux entre -r et +r
- --- 2.1 Parcours des valeurs de uy entre -r et +r
- ------ 2.1.1. Si le point de coordonnées (ux, uy) est dans le cercle : ajout du vecteur (ux+ox, uy+oy) à la liste
- 3. Renvoi de la liste des vecteurs
On obtient ainsi le code :
def generer_vecteurs(ox=0, oy=0, r=1, k=100):
# ox, oy : coordonnées du centre du disque
# r : rayon du disque
# k : nombre de valeurs en x et en y
# initialisation de la liste des vecteurs
OA=[]
# parcours des valeurs de ux entre -r et +r
for ux in np.linspace(-r,r,k):
# parcours des valeurs de uy entre -r et +r
for uy in np.linspace(-r,r,k):
# test si le point de coordonnées (ux,uy) est dans le cercle
if ux*ux + uy*uy <= r*r:
# si oui, ajout du vecteur (ux+ox,uy+oy) à la liste
OA.append(np.array([ux+ox,uy+oy]))
# renvoie la liste des vecteurs : OA[0], OA[1], ...
return OA
Ce qui peut également s'écrire en une ligne à l'aide d'une compréhension de liste avec double for :
OA = [np.array((ux+ox,uy+oy)) for ux in np.linspace(-r,r,k) for uy in np.linspace(-r,r,k) if ux*ux + uy*uy <= r*r]On utilise ici l'inéquation kitxmlcodeinlinelatexdvp{u_{x}^{2}+u_{y}^{2}\le r^{2}}finkitxmlcodeinlinelatexdvp pour déterminer si un point (ux, uy) se trouve à l'intérieur d'un cercle de rayon r. Les valeurs de ux et uy sont prises entre -r et +r. Ce principe peut être adapté pour générer d’autres figures, comme une ellipse.
On peut encore accélérer la génération des vecteurs à l'aide de numpy.meshgrid et de masques booléens, mais cette méthode peut être moins intuitive pour les débutants.
Ensuite, il faut déterminer le vecteur kitxmlcodeinlinelatexdvp{\overrightarrow{OG}}finkitxmlcodeinlinelatexdvp à partir de la liste obtenue :
# génération des vecteurs correspondant aux points uniformément répartis sur le disque : OA[0], OA[1], ...
OA = generer_vecteurs(ox, oy, r, k)
# nombre de vecteurs
n = len(vecteurs)
# détermination du vecteur OG : somme des vecteurs et multiplication par un scalaire 1/n
OG = (1/n)*sum(OA)
Puis, afficher sur le graphique les points générés et le point G :
# création des tableaux numpy x et y à partir des vecteurs
x = np.array([OAi[0] for OAi in OA])
y = np.array([OAi[1] for OAi in OA])
# Trace les points générés
plt.scatter(x, y, s=0.5)
# Trace le point G (en rouge)
plt.scatter(OG[0], OG[1], s=20, color = 'r')
Enfin, tracer le cercle délimitant le disque :
# création du tableau d'angles θ allant de 0 à 2π (tour complet)
θ = np.linspace(0, 2 * np.pi, 400)
# calcul des coordonnées x et y des points du cercle à partir des angles θ et du centre (ox, oy)
x = r*np.cos(θ)+ox
y = r*np.sin(θ)+oy
# Trace le cercle de centre (ox, oy) et de rayon r
plt.plot(x, y, color='r', linewidth=1)
# limites inférieures et supérieures sur l'axe des x et des y
plt.xlim(-r+ox-0.1, r+ox+0.1); plt.ylim(-r+oy-0.1, r+oy+0.1)
Le code suivant reprend toutes les étapes vues précédemment :
import numpy as np
import matplotlib.pyplot as plt
# nombre de valeurs distinctes de x et de y
k = 500
print("Nombre de valeurs distinctes de x : k =", k)
print()
# longueur du rayon
r = 1
print("Longueur du rayon : r =", r)
# coordonnées du centre du cercle
ox, oy = 1, 1
print("Coordonnées du centre du disque :", (ox, oy))
print()
# génération des vecteurs correspondant aux points uniformément répartis sur le disque : OA[0], OA[1], ...
# OA = generer_vecteurs(ox, oy, r, k)
OA = [np.array((ux+ox,uy+oy)) for ux in np.linspace(-r,r,k) for uy in np.linspace(-r,r,k) if ux*ux + uy*uy <= r*r]
# nombre de vecteurs
n = len(OA)
# détermination du vecteur OG : somme des vecteurs et multiplication par un scalaire 1/n
OG = (1/n)*sum(OA)
print("Coordonnées du point G :", (OG[0], OG[1]))
# création des tableaux numpy x et y à partir des vecteurs
x = np.array([OAi[0] for OAi in OA])
y = np.array([OAi[1] for OAi in OA])
print()
print("Génération du graphique ...\n")
# nom et dimension de la figure contenant le graphique
plt.figure(num="Disque de centre ({0},{1}) et de rayon {2}".format(ox,oy,r), figsize=(7, 6), dpi=80)
# même échelle sur l'axe des x et des y
plt.axis('scaled')
# Trace le point origine du repère en rouge
plt.scatter(0, 0, s=10, color = 'r')
# Trace les points générés
plt.scatter(x, y, s=0.5)
# Trace le point origine du cercle en jaune
plt.scatter(ox, oy, s=40, color = 'yellow')
# Trace le point G (en rouge)
plt.scatter(OG[0], OG[1], s=20, color = 'r')
# création du tableau d'angles θ allant de 0 à 2π (tour complet)
θ = np.linspace(0, 2 * np.pi, 400)
# calcul des coordonnées x et y des points du cercle à partir des angles θ et du centre (ox, oy)
x = r*np.cos(θ)+ox
y = r*np.sin(θ)+oy
# Trace le cercle de centre (ox, oy) et de rayon r
plt.plot(x, y, color='r', linewidth=1)
# limites inférieures et supérieures sur l'axe des x et des y
plt.xlim(-r+ox-0.1, r+ox+0.1); plt.ylim(-r+oy-0.1, r+oy+0.1)
# ajout du titre
plt.title("Position de G sur le disque de centre ({0},{1}) et de rayon {2}".format(ox,oy,r))
# Affiche le graphique
plt.show()Les formules r*np.cos(θ) + ox et r*np.sin(θ) + oy permettent de transformer un tableau d’angles θ en deux tableaux de coordonnées x et y décrivant un cercle de centre (ox,oy) et de rayon r.
Le code affiche :
Nombre de valeurs distinctes de x : k = 500
Longueur du rayon : r = 1
Coordonnées du centre du disque : (1, 1)
Coordonnées du point G : (1.0000000000000835, 1.0)
Génération du graphique ...
Puis le graphique :
On constate sur le graphique que le point G (en rouge), obtenu à l'aide de la formule vectorielle, coïncide avec le centre du cercle (en jaune). Si la répartition des points dans le cercle n'est pas parfaitement uniforme, cela peut entraîner de légers écarts entre G et le centre du disque (centre de masse).
III-G-3. Exercice : trouver le centre de masse d'un demi-disque▲
Pour terminer, nous souhaitons approcher, toujours à l’aide de la relation kitxmlcodeinlinelatexdvp{\overrightarrow{OG}=\frac{1}{n}\sum_{i=1}^{n}\overrightarrow{OA_{i}}}finkitxmlcodeinlinelatexdvp, le centre de masse d'un demi-disque homogène correspondant à la partie supérieure du disque de centre (ox, oy) et de rayon r.
Le lecteur est cette fois invité à trouver lui-même les différentes parties du code. Il peut cliquer sur Afficher le code pour vérifier sa réponse à chaque étape.
On doit d'abord générer les n vecteurs de position kitxmlcodeinlinelatexdvp{\overrightarrow{OA}_{1},\cdots ,\overrightarrow{OA}_{n}}finkitxmlcodeinlinelatexdvp des n points uniformément répartis :
Ensuite, il nous faut déterminer le vecteur kitxmlcodeinlinelatexdvp{\overrightarrow{OG}}finkitxmlcodeinlinelatexdvp à partir de la liste obtenue :
Puis, afficher sur le graphique les points générés et le point G :
Enfin, tracer le demi-cercle délimitant le demi-disque supérieur :
Voici l’ensemble du code correspondant à l'exercice traité :
Le point de coordonnées kitxmlcodeinlinelatexdvp{\left( o_{x},o_{y}+\frac{4r}{3\pi} \right)}finkitxmlcodeinlinelatexdvp est le centre de masse d'un demi-disque de rayon r, dont le disque complet est centré en kitxmlcodeinlinelatexdvp{\left( o_{x},o_{y} \right)}finkitxmlcodeinlinelatexdvp (voir cette page pour plus de détails).
Lors de son exécution, le code affiche :
Nombre de valeurs distinctes de x : k = 1000
Longueur du rayon : r = 1
Coordonnées du centre de masse du demi-disque : (1, 1.4244131815783876)
Coordonnées du point G : (0.99999999999634803, 1.4241421003656138)
Génération du graphique ...
Puis le graphique :
On remarque une nouvelle fois que le point G (en rouge), obtenu à l’aide de la formule du barycentre, coïncide visuellement avec le centre de masse (en jaune).
Le script peut être adapté pour estimer le centre de masse d’une autre figure géométrique.
IV. Conclusion▲
Nous voici donc arrivés au terme de notre article dans lequel nous avons su manipuler et représenter graphiquement ces vecteurs en Python.
Comme cela a été dit, l'utilisation des vecteurs ne se limite bien sûr pas à ces quelques exemples. En mathématiques, ils interviennent notamment dans la résolution de systèmes d'équations à plusieurs inconnues ou de systèmes différentiels. En physique, ils servent aussi à représenter les forces agissant sur un objet, la vitesse d'un mobile à un instant donné, etc.
Dans un prochain article, nous aborderons le calcul matriciel avec NumPy en utilisant cette fois des tableaux à deux dimensions.
V. Téléchargement▲
Le fichier compresséfichier de test contenant le module Python pour effectuer les différents tests.
VI. Remerciements▲
Je tiens à remercier f-leb pour ses différentes suggestions, ainsi que pour sa relecture.
Sources
