Les vecteurs avec numpy et matplotlib

Opérations de base sur les vecteurs, transformation de vecteurs, etc.

Denis Hulo

Objectif : apprendre à manipuler les vecteurs avec la bibliothèque numpy (addition de vecteurs, multiplication par un scalaire, transformation à l'aide d'une fonction, etc.) et à les représenter sur des graphiques avec matplotlib.

Niveau requis : débutant

Commentez

- Titre : Les vecteurs avec numpy et matplotlib

- Auteur : Denis Hulo

- Parution : 19 juillet 2025

- Public visé :

- Licence : Copyright ® 2025 Denis Hulo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Vecteur

- II-A. Représentation algébrique d'un vecteur

- II-B. Addition de vecteurs

- II-C. Multiplication d'un vecteur par un scalaire

- II-D. Produit scalaire

- II-E. Norme d'un vecteur

- II-F. Opérateur vectoriel

- II-G. Barycentre et centroïde

- III. Les vecteurs avec numpy et matplotlib

- III-A. Représentation des vecteurs

- III-B. Addition de vecteurs

- III-C. Multiplication par un scalaire

- III-D. Produit scalaire

- III-E. Norme d'un vecteur

- III-F. Transformation d'un vecteur numpy à l'aide d'une fonction

- III-G. Isobarycentre et centre de masse

- III-G-1. Isobarycentre de 3 points dans le plan

- III-G-2. Centre de masse d'un disque

- III-G-3. Exercice : trouver le centre de masse d'un demi-disque

- IV. Conclusion

- V. Téléchargement

- VI. Remerciements

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 :

Dans l'espace, il aura alors une composante en x, une composante en y, et une composante en 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

Soit les vecteurs définis dans le plan :

et

L'addition de ces deux vecteurs composante par composante nous donne :

II-C - Multiplication d'un vecteur par un scalaire

Prenons maintenant le vecteur :

La multiplication de ce vecteur par un scalaire s (nombre réel) nous donne cette fois :

II-D - Produit scalaire

Soit les vecteurs définis dans le plan :

et

Leur produit scalaire nous donne :

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 :

Sa norme s'écrit alors :

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 :

C'est à dire, plus simplement, pour une fonction de la variable réelle qui à x associe f(x) :

Un vecteur est transformé en un vecteur .

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 :

Plus généralement, le barycentre des n points (A_1, … , An) affectés des coefficients (a_1, … , an) est l'unique point G tel que :

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 (A_1, … , An) affectés du même coefficient a est l'unique point G tel que:

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 :

Equivalent à :

On voit alors que G est aussi le point moyen entre les n points (A_1, … , 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 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 en bleu et du vecteur 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 et en rouge le vecteur obtenu après multiplication de 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)
11

Le produit scalaire 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.0

Ici la norme 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 :

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 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 .

Notre objectif est de vérifier, à l'aide de la relation , 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 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 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.).

Il y a la possibilité d'accélerer encore la génération des vecteurs en utilisant la fonction numpy.meshgrid et les masques booléens, mais le code n'est pas très accessible pour un débutant.

Ensuite, il faut déterminer le vecteur à 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 :

# création à partir des vecteurs des tableaux numpy x et y
x = np.array([v[0] for v in vecteurs])
y = np.array([v[1] for v in vecteurs])

# 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 - Exercice : trouver le centre de masse d'un demi-disque

On souhaite pour finir approcher, toujours à l'aide de la relation , le centre de masse d'un demi-disque supposé homogène (partie supérieure du disque de centre (ox, oy) et de rayon r).

Le lecteur est invité cette fois à trouver par lui-même les différentes parties du code mise en oeuvre dans cet exercice. Il suffit de cliquer à chaque fois sur Afficher le code pour voir la réponse.

On doit donc d'abord générer les n vecteurs 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 à 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 :

# création à partir des vecteurs des tableaux numpy x et y
x = np.array([v[0] for v in vecteurs])
y = np.array([v[1] for v in vecteurs])

# 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 est le centre de masse d'un demi-disque de rayon r et dont le disque complet a pour origine (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.

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é 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

- Page Wikipedia sur les vecteurs

- Page Wikipedia sur les barycentres

- Page sur les opérateurs

- Documentation sur les tableaux numpy

- Page sur la bibliothèque matplotlib

- Documentation sur la fonction pyplot.quiver de la bibliothèque matplotlib

- Page utile pour tracer des vecteurs avec matplotlib