I. Introduction▲
Après avoir donné une rapide présentation des vecteurs et des opérations propres à ces objets mathématiques, nous allons montrer comment les définir avec numpy et comment les afficher sur des graphiques matplotlib.
Enfin, on va 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 en lui appliquant une fonction mathématique.
Vous l'aurez compris, nous allons donc nous initier au calcul vectoriel avec numpy.
II. Vecteur▲
D'après Wikipedia, 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 de la physique (forces, vitesses, accélérations, etc.).
La notion de vecteur est le fondement de la branche des mathématiques appelée algèbre linéaire. En ce sens, un vecteur est un élément d'un espace vectoriel, c'est-à-dire qu'il est possible d'effectuer les opérations d'addition et de multiplication par un scalaire (par un nombre), et que ces opérations ont les propriétés nécessaires à un espace vectoriel.
Un couple, un triplet de nombres réels, peut également être vu comme un vecteur. L'addition et le produit par un nombre réel se font alors composante par composante.
II-A. Représentation algébrique d'un vecteur▲
Un vecteur dans le plan peut ainsi être représenté par une composante en x et une composante en y :
kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp
Dans l'espace, il aura alors une composante en x, une composante en y, et une composante en z :
kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\\u_{z}\end{pmatrix}}finkitxmlcodeinlinelatexdvp
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▲
Soit les vecteurs définis dans le 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 :
kitxmlcodeinlinelatexdvp{\vec {u} + \vec {v} = {\begin{pmatrix}u_{x}+v_{x}\\u_{y}+v_{y}\end{pmatrix}}}finkitxmlcodeinlinelatexdvp
II-C. Multiplication d'un vecteur par un scalaire▲
Prenons maintenant le vecteur :
kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp
La multiplication de ce vecteur par un scalaire s (nombre réel) nous donne cette fois :
kitxmlcodeinlinelatexdvp{s⋅\vec {u} = {\begin{pmatrix}s⋅u_{x}\\s⋅u_{y}\end{pmatrix}}}finkitxmlcodeinlinelatexdvp
II-D. Produit scalaire▲
Soit les vecteurs définis dans le 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
Leur produit scalaire nous donne :
kitxmlcodeinlinelatexdvp{\overrightarrow{u}\cdot\overrightarrow{v} =u_{x}v_{x}+u_{y}v_{y}}finkitxmlcodeinlinelatexdvp
II-E. Norme d'un vecteur▲
La norme d'un vecteur peut se calculer à l'aide du produit scalaire.
Soit le vecteur défini dans le plan :
kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp
Sa norme s'écrit alors :
kitxmlcodeinlinelatexdvp{\left\| \overrightarrow{u} \right\|=\sqrt{\overrightarrow{u}\cdot \overrightarrow{u}}=\sqrt{u_{x}^{2}+u_{y}^{2}}}finkitxmlcodeinlinelatexdvp
II-F. Opérateur vectoriel▲
En mathématiques, un opérateur est une application entre deux espaces vectoriels.
Soient E et F deux espaces vectoriels. Un opérateur O est une application de E dans F :
kitxmlcodeinlinelatexdvp{O : E\to F}finkitxmlcodeinlinelatexdvp
C'est à dire, plus simplement, pour une fonction de la variable réelle qui à x associe f(x) :
kitxmlcodeinlinelatexdvp{\begin{matrix}f:&\mathbb {R} &\longrightarrow &\mathbb {R} \\&x&\longmapsto &f(x)\end{matrix}}finkitxmlcodeinlinelatexdvp
Un vecteur kitxmlcodeinlinelatexdvp{\vec {u}}{\begin{pmatrix}u_{x}\\u_{y}\end{pmatrix}}finkitxmlcodeinlinelatexdvp est transformé en un vecteur kitxmlcodeinlinelatexdvp{\vec {v}}{\begin{pmatrix}f(u_{x})\\f(u_{y})\end{pmatrix}}finkitxmlcodeinlinelatexdvp.
Dans la même idée, on verra par la suite comment transformer un vecteur numpy en un autre vecteur en lui appliquant une fonction mathématique.
II-G. Barycentre et centroïde▲
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 :
kitxmlcodeinlinelatexdvp{a\overrightarrow{GA}+b\overrightarrow{GB}=\overrightarrow{0}}finkitxmlcodeinlinelatexdvp
Plus généralement, le barycentre des n points (A1, … , An) affectés des coefficients (a1, … , an) est l'unique point G tel que :
kitxmlcodeinlinelatexdvp{\sum_{i=1}^{n}a_{i}\overrightarrow{GA_{i}}=\overrightarrow{0}}finkitxmlcodeinlinelatexdvp
En mathématiques, le centre de masse ou centroïde d’un domaine du plan ou de l’espace est un point d’équilibre pour une certaine mesure sur ce domaine. Il correspond au centre pour un cercle ou une sphère, et plus généralement correspond au centre de symétrie lorsque le domaine en possède un. Mais son existence et son unicité sont garanties dès que le domaine est de mesure finie.
En géométrie, cette notion est synonyme de barycentre (pour un ensemble fini de points affectés de masses ponctuelles, le centre de masse est le barycentre des points pondérés).
Par exemple, le centroïde (ou isobarycentre) des n points (A1, … , An) affectés du même coefficient a est l'unique point G tel que:
kitxmlcodeinlinelatexdvp{\sum_{i=1}^{n}a\overrightarrow{GA_{i}}=\overrightarrow{0}}finkitxmlcodeinlinelatexdvp
On en déduit en introduisant dans la relation le point origine O(0, 0) et en divisant des deux côtés par a :
kitxmlcodeinlinelatexdvp\sum_{i=1}^{n}\left( \overrightarrow{GO}+ \overrightarrow{OA_{i}} \right)=\overrightarrow{0}finkitxmlcodeinlinelatexdvp
Equivalent à :
kitxmlcodeinlinelatexdvp\overrightarrow{OG}=\frac{1}{n}\sum_{i=1}^{n}\overrightarrow{OA_{i}}finkitxmlcodeinlinelatexdvp
On voit alors que G est aussi le point moyen entre les n points (A1, … , An).
On va d'ailleurs montrer à la fin de l'article que ce point G correspond bien au centre de masse dans le cas d'un disque homogène.
Cette formule est également 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▲
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]). Ce qui nous donne :
>>> import numpy as np
>>> u = np.array([3, 2])
>>> u
array([3, 2])
Ou en affichant le contenu du vecteur à l'aide de la fonction print() :
>>> import numpy as np
>>> u = np.array([3, 2])
>>> print(u)
[3 2]
Les composantes du vecteur correspondent donc aux éléments du tableau 1D (nombres réels, entiers, etc.).
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 à partir 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)
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()
L'exécution du code affiche :
III-B. Addition de vecteurs▲
Comme pour des vecteurs classiques, on réalise l'addition de deux vecteurs numpy 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 à 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(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 depuis l'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()
L'exécution du 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 numpy.array([1, 2]) et numpy.array([3, 4]) se calcule 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 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. Transformation d'un vecteur numpy à l'aide d'une fonction▲
On peut également appliquer une fonction à un tableau numpy pour le transformer en un autre tableau de même taille :
>>> u = np.array([4, 9, 16])
>>> np.sqrt(u)
array([2., 3., 4.])
Traçons maintenant un cercle à l'aide de cette propriété :
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 veteur 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')
# génération du tableau de 10 000 valeurs comprises entre -1 et +1
x = np.linspace(-1, 1, 10000)
# valeurs correspondantes en y : demi-cercle supérieur : y = sqrt(1-x^2)
y = np.sqrt(1-x*x)
# trace le cercle de centre (0,0) et de rayon 1
plt.plot(x, y, color='r', linewidth=2)
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.5, 1.5); plt.ylim(-1.5, 1.5)
# ajout du titre
plt.title("Cercle de centre (0,0) et de rayon 1")
# Affiche le graphique
plt.show()Les valeurs positives des y sont données par la formule np.sqrt(1-x*x) et les valeurs négatives par -np.sqrt(1-x*x).
L'exécution du code affiche :
III-G. Isobarycentre et centre de masse▲
III-G-1. Isobarycentre de 3 points dans le plan▲
On souhaite déterminer la position de l'isobarycentre de 3 points A, B et C, affectés donc du même coefficient de pondération. On va utiliser pour cela la formule :
kitxmlcodeinlinelatexdvp{\overrightarrow{OG}=\frac{1}{3}(\overrightarrow{OA}+\overrightarrow{OB}+\overrightarrow{OC})}finkitxmlcodeinlinelatexdvp
Il nous faut d'abord positionner les 3 points sur 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=10, color = 'b')
# Trace le point B en vert
plt.scatter(B[0], B[1], s=10, color = 'g')
# Trace le point C en orange
plt.scatter(C[0], C[1], s=10, color = 'orange')
Puis construire et tracer les 3 vecteurs depuis l'origine vers ces 3 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, A[0], A[1], color='b', angles = 'xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OB
plt.quiver(0, 0, B[0], B[1], color='g', angles = 'xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OC
plt.quiver(0, 0, C[0], C[1], color='orange', angles = 'xy', scale_units = 'xy', scale = 1)
Et enfin déterminer et tracer l'isobarycentre G de ces 3 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')
Ce qui donne le code complet :
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')
# Trace le point B en vert
plt.scatter(B[0], B[1], s=20, color = 'g')
# Trace le point C en orange
plt.scatter(C[0], C[1], s=20, color = 'orange')
print('Point A{0}'.format(A))
print('Point B{0}'.format(B))
print('Point C{0}'.format(C))
# Trace le triangle
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 3 points
OA = np.array(A)
OB = np.array(B)
OC = np.array(C)
# Trace sur le graphique les 3 vecteurs obtenus
# Trace le vecteur OA
plt.quiver(0, 0, A[0], A[1], color='b', angles = 'xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OB
plt.quiver(0, 0, B[0], B[1], color='g', angles = 'xy', scale_units = 'xy', scale = 1)
# Trace le vecteur OC
plt.quiver(0, 0, C[0], C[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')
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()
L'exécution du 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 en fait au point d'intersection des médianes.
III-G-2. Centre de masse d'un disque▲
Soient n points kitxmlcodeinlinelatexdvp{\left( A_{1},\cdots ,A_{n} \right)}finkitxmlcodeinlinelatexdvp affectés du même coefficient de pondération et répartis uniformément sur un disque de centre (ox, oy) et de rayon r. Ces n points peuvent être associés à n vecteurs kitxmlcodeinlinelatexdvp{\left( \overrightarrow{OA}_{1},\cdots ,\overrightarrow{OA}_{n} \right)}finkitxmlcodeinlinelatexdvp.
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 moyen G correspond bien au centre du disque supposé homogène. Pour cela, on va d'abord générer les n vecteurs kitxmlcodeinlinelatexdvp{\left( \overrightarrow{OA}_{1},\cdots ,\overrightarrow{OA}_{n} \right)}finkitxmlcodeinlinelatexdvp issus de l'origine et ayant pour extrémités les n points.
Donnons maintenant le déroulé de la fonction génératrice des vecteurs :
- 1. Initialisation de la liste des vecteurs ;
- 2. Parcours des ux entre -r à +r ;
- --- 2.1 Parcours des uy entre -r à +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
vecteurs=[]
# parcours des ux entre -r à +r
for ux in np.linspace(-r,r,k):
# parcours des 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
vecteurs.append(np.array([ux+ox,uy+oy]))
# renvoie la liste des vecteurs
return vecteurs
Ce qui peut également s'écrire en une ligne à l'aide d'une liste en compréhension avec double for :
vecteurs = [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 savoir si le point est situé dans le cercle de rayon r, avec ux et uy compris entre -r et +r. Libre à chacun d'adapter le code à sa figure (ellipse, etc.).
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
vecteurs = generer_vecteurs(ox, oy, r, k)
# nombre de vecteurs
n = len(vecteurs)
# détermination du vecteur OG correspondant au point moyen G : somme des vecteurs et multiplication par un scalaire 1/n
OG = (1/n)*sum(vecteurs)
Enfin, il faut afficher sur le graphique les points générés et le point moyen G :
# trace les points générés
plt.scatter(x, y, s=0.5)
# trace le point moyen G (en rouge)
plt.scatter(OG[0], OG[1], s=20, color = 'r')
On donne maintenant le code complet :
import numpy as np
import matplotlib.pyplot as plt
# nombre de valeurs distincts en x et en y
k = 500
print("Nombre de valeurs distinctes en 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
# vecteurs = generer_vecteurs(ox, oy, r, k)
vecteurs = [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(vecteurs)
# détermination du vecteur OG correspondant au point moyen G : somme des vecteurs et multiplication par un scalaire 1/n
OG = (1/n)*sum(vecteurs)
print("Coordonnées du point moyen G :", (OG[0], OG[1]))
# création à partir des points des tableaux numpy x et y
x = np.array([v[0] for v in vecteurs])
y = np.array([v[1] for v in vecteurs])
print()
print("Génération du graphique ...\n")
# nom et dimension de la figure contenant le graphique
plt.figure(num="Point moyen : estimation de la position du centre de masse du disque", 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 moyen G (en rouge)
plt.scatter(OG[0], OG[1], s=20, color = 'r')
# génération des 10*k valeurs en x entre -r+ox et +r+ox
x = np.linspace(-r,r,10*k)+ox
# valeurs correspondantes en y : demi-cercle supérieur : f(x) = sqrt(r^2-(x-ox)^2)
y = np.sqrt(r*r-(x-ox)*(x-ox))
# trace le cercle de centre ox, oy
plt.plot(x, y+oy, color='r', linewidth=1)
plt.plot(x, -y+oy, 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 valeurs positives des y du cercle sont données par la formule np.sqrt(r*r-(x-ox)*(x-ox))+oy et les valeurs négatives par -np.sqrt(r*r-(x-ox)*(x-ox))+oy.
Le code affiche :
Nombre de valeurs distinctes en x, k = 500
Longueur du rayon, r = 1
Coordonnées du centre du disque : (1, 1)
Coordonnées du point moyen G : (1.0000000000000835, 1.0)
Génération du graphique ...
Puis le graphique :
On constate que le point moyen G (en rouge) obtenu à l'aide de la formule vectorielle se confond avec le centre du cercle (en jaune). Si la répartition des points dans le cercle n'est pas parfaitement uniforme, cela peut entrainer de légères erreurs de positionnement du point moyen par rapport au centre du cercle (centre de symétrie).
III-G-3. Centre de masse d'un demi-disque▲
On souhaite cette fois 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 supposé homogène (partie supérieure du disque de centre (ox, oy) et de rayon r).
On va donc d'abord générer les n vecteurs kitxmlcodeinlinelatexdvp{\left( \overrightarrow{OA}_{1},\cdots ,\overrightarrow{OA}_{n} \right)}finkitxmlcodeinlinelatexdvp correspondant aux n points uniformément répartis :
vecteurs = [np.array((ux+ox,uy+oy)) for ux in np.linspace(-r,r,k) for uy in np.linspace(0,r,k) if ux*ux + uy*uy <= r*r]
Ensuite, il nous faut déterminer le vecteur kitxmlcodeinlinelatexdvp{\overrightarrow{OG}}finkitxmlcodeinlinelatexdvp à partir de la liste obtenue :
# nombre de vecteurs
n = len(vecteurs)
# détermination du vecteur OG correspondant au point moyen G : somme des vecteurs et multiplication par un scalaire 1/n
OG = (1/n)*sum(vecteurs)
Enfin, on affiche sur le graphique les points générés et le point moyen G :
# trace les points générés
plt.scatter(x, y, s=0.5)
# trace le point moyen G (en rouge)
plt.scatter(OG[0], OG[1], s=20, color = 'r')
On donne maintenant le code complet :
import numpy as np
import matplotlib.pyplot as plt
# nombre de valeurs distincts en x et en y
k = 1000
print("Nombre de valeurs distinctes en x, k =", k)
print()
# longueur du rayon
r = 1
print("Longueur du rayon, r =", r)
# coordonnées du centre du disque
ox, oy = 1, 1
# coordonnées du centre de masse du demi-disque (ox, oy + 4r/3Pi)
cx, cy = ox, oy + (4*r)/(3*np.pi)
print("Coordonnées du centre de masse du demi-disque :", (cx, cy))
print()
# génération des vecteurs correspondant aux points uniformément répartis sur le demi-disque
vecteurs = [np.array((ux+ox,uy+oy)) for ux in np.linspace(-r,r,k) for uy in np.linspace(0,r,k) if ux*ux + uy*uy <= r*r]
# nombre de vecteurs
n = len(vecteurs)
# détermination du vecteur OG correspondant au point moyen G : somme des vecteurs et multiplication par un scalaire 1/n
OG = (1/n)*sum(vecteurs)
print("Coordonnées du point moyen G :", (OG[0], OG[1]))
# création à partir des points des tableaux numpy x et y
x = np.array([v[0] for v in vecteurs])
y = np.array([v[1] for v in vecteurs])
print()
print("Génération du graphique ...")
# nom et dimension de la figure contenant le graphique
plt.figure(num="Point moyen : estimation de la position du centre de masse du demi-disque", figsize=(7, 6), dpi=80)
# même échelle sur l'axe des x et des y
plt.axis('scaled')
# trace les points générés
plt.scatter(x, y, s=0.5)
# trace le point centre de masse en jaune
plt.scatter(cx, cy, s=40, color = 'yellow')
# trace le point moyen G (en rouge)
plt.scatter(OG[0], OG[1], s=20, color = 'r')
# génération des 10*k valeurs en x entre -r+ox et +r+ox
x = np.linspace(-r,r,10*k)+ox
# valeurs correspondantes en y : demi-cercle supérieur : f(x) = sqrt(r^2-(x-ox)^2)
y = np.sqrt(r*r-(x-ox)*(x-ox))
# trace le cercle de centre ox, oy
plt.plot(x, y+oy, 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(-0.1+oy, r+oy+0.1)
# ajout du titre
plt.title("Position de G sur le demi-disque de centre ({0},{1}) et de rayon {2}".format(ox,oy,r))
# Affiche le graphique
plt.show()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 et dont le disque complet a pour origine kitxmlcodeinlinelatexdvp{\left( o_{x},o_{y} \right)}finkitxmlcodeinlinelatexdvp (voir cette page pour plus de détails).
Le code affiche :
Nombre de valeurs distinctes en x, k = 1000
Longueur du rayon, r = 1
Coordonnées du centre de masse du demi-disque : (1, 1.4244131815783876)
Coordonnées du point moyen G : (0.99999999999634803, 1.4241421003656138)
Génération du graphique ...
Puis le graphique :
On remarque une nouvelle fois que le point moyen G (en rouge) obtenu à l'aide de la formule vectorielle est très proche du centre de masse (en jaune).
Libre à chacun d'adapter le script pour approcher le centre de masse d'une autre figure géométrique.
IV. Conclusion▲
Nous voici donc arrivé 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 aussi dans la résolution de systèmes d'équations à plusieurs inconnus, ou de systèmes différentiels. En physique, ils permettent également de représenter les forces agissant sur un objet, la vitesse d'un mobile en un point, etc.
V. Téléchargement▲
Le fichier compresséfichier de test contenant le module Python pour effectuer les différents tests.