Mathématiques avec Python et Ruby/Vecteurs en Python

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


Géométriquement, un vecteur peut être défini à partir de deux points (son origine et son extrémité) mais aussi par ses coordonnées. C'est le choix qui sera fait ici.

Définition[modifier | modifier le wikicode]

Encore une fois, on va être classe sur ce coup-là :

class Vecteur:
    def __init__(self,x,y):

Lors de son instanciation, un vecteur n'aura donc que deux propriétés : ses coordonnées.

Coordonnées[modifier | modifier le wikicode]

Abscisse[modifier | modifier le wikicode]

        self.x=x

L'abscisse de u s'obtiendra par u.x

Ordonnée[modifier | modifier le wikicode]

        self.y=y

L'ordonnée de u s'obtiendra par u.y

La classe Vecteur se résume donc pour l'instant à ceci :

class Vecteur:
    def __init__(self,x,y):
        self.x=x
        self.y=y

Affichage[modifier | modifier le wikicode]

Pour afficher un vecteur, on fait comme avec les points (on colle ses coordonnées entre parenthèses, séparées par un point-virgule, après les avoir converties en chaînes de caractères avec str) :

    def affichage(self):
        return '('+str(self.x)+';'+str(self.y)+')'

Norme[modifier | modifier le wikicode]

Pour calculer la norme d'un vecteur, on utilise le théorème de Pythagore sous la forme de la fonction hypot. Celle-ci doit être importée du module math:

from math import *

La norme du vecteur se calcule donc par

    def norme(self):
        return hypot(self.x,self.y)

Opérations[modifier | modifier le wikicode]

Python offre un grand confort, en permettant d'utiliser les signes d'opérations pour les vecteurs. Ainsi, en voyant un signe moins devant un vecteur, Python sait qu'il ne doit pas calculer l'opposé d'un nombre puisque c'est un vecteur, et non un nombre, qui suit ce signe moins. Alors on peut définir (c'est laissé en exercice) une méthode __neg__ pour les vecteurs, et c'est elle qui sera utilisée quand Python verra le signe moins. À moins bien entendu que ce soit une soustraction, auquel cas la méthode __sub__ sera utilisée (cette méthode aussi sera laissée en exercice).

Addition[modifier | modifier le wikicode]

Pour additionner deux vecteurs, on redéfinit la méthode __add__ :

    def __add__(self,v):
        return Vecteur(self.x+v.x,self.y+v.y)

Alors pour avoir la somme de deux vecteurs u et v, il suffit d'entrer u+v. C'est exactement comme ça que fonctionnent les modules fractions et cmath.

Multiplications[modifier | modifier le wikicode]

Par un réel[modifier | modifier le wikicode]

En multipliant un vecteur par un réel, on obtient un vecteur. Pour ne pas interférer avec la méthode suivante, on va mettre le réel en deuxième et utiliser la méthode multiplication à l'envers qui est notée __rmul__ (comme reverse multiplication) :

    def __rmul__(self,r):
        return Vecteur(self.x*r,self.y*r)

Pour calculer le triple du vecteur u, on entre 3*u et, pour l'afficher, (3*u).affichage().

Par un autre vecteur[modifier | modifier le wikicode]

En multipliant un vecteur par un vecteur, on obtient un nombre, ou scalaire. Aussi cette multiplication est-elle appelée produit scalaire des deux vecteurs (en fait il y a bien une multiplication vectorielle qui donne un vecteur, mais celle-ci est définie pour les vecteurs de l'espace, et ne sera donc pas abordée ici). On peut donc implémenter le produit scalaire de deux vecteurs self et v par

    def __mul__(self,v):
        return self.x*v.x+self.y*v.y

Pour calculer le produit scalaire de u par v, on entre juste u*v.

Tests[modifier | modifier le wikicode]

Vecteurs colinéaires[modifier | modifier le wikicode]

Pour savoir si deux vecteurs sont colinéaires, on compare deux produits en croix :

    def colin(self,v):
        return self.x*v.y==self.y*v.x

Ce test retourne un booléen, en entrant u.colin(v).

Vecteurs orthogonaux[modifier | modifier le wikicode]

Pour savoir si deux vecteurs sont orthogonaux, on compare leur produit scalaire à 0 :

    def ortho(self,v):
        return self*v==0

Exemple[modifier | modifier le wikicode]

Pour l'exercice du chapitre précédent, on peut calculer un produit scalaire pour vérifier que ABC est rectangle :

from math import *

class Vecteur:
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def affichage(self):
        return '('+str(self.x)+';'+str(self.y)+')'

    def norme(self):
        return hypot(self.x,self.y)

    def __add__(self,v):
        return Vecteur(self.x+v.x,self.y+v.y)

    def __rmul__(self,r):
        return Vecteur(self.x*r,self.y*r)

    def __mul__(self,v):
        return self.x*v.x+self.y*v.y

    def colin(self,v):
        return self.x*v.y==self.y*v.x

    def ortho(self,v):
        return self*v==0




a=Point(-1,3.0)
b=Point(5,1)
c=Point(1,5)

u=c.vecteur(a)
v=c.vecteur(b)

print(u*v)
print(u.ortho(v))