Mathématiques avec Python et Ruby/Droites en Python

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


De façon analogue à la définition par coordonnées des points et vecteurs dans les deux chapitres précédents, on peut définir l'objet droite par une de ses équations. Mais ici, on va définir une droite à partir de deux points. On va donc avoir besoin des classes Point et Vecteur définies dans les deux chapitres précédents. On aura donc aussi besoin d'importer le module math (ou au moins, hypot).

Définition[modifier | modifier le wikicode]

On définit donc une classe Droite où l'initialisation place deux points:

class Droite:
    def __init__(self,a,b):
        self.a=a
        self.b=b

Le premier point de la droite d s'obtient par d.a et le second point par d.b.

Vecteurs[modifier | modifier le wikicode]

Vecteur directeur[modifier | modifier le wikicode]

Le vecteur sera choisi comme vecteur directeur de la droite :

    def directeur(self):
        return self.a.vecteur(self.b)

On peut s'en servir pour

  1. Avoir une représentation paramétrique de la droite;
  2. Faire un test pour savoir si un point est, ou non, sur la droite (par des vecteurs colinéaires).

Ces deux ajouts sont laissés en exercice, le deuxième étant d'ailleurs hors sujet ici puisque c'est une propriété de l'objet Point.

Vecteur normal[modifier | modifier le wikicode]

Le vecteur normal est choisi de telle façon que son produit scalaire avec le vecteur directeur ci-dessus soit nul:


    def normal(self):
        return Vecteur(-self.directeur().y,self.directeur().x)

Ce vecteur directeur peut servir à obtenir une équation cartésienne de la droite (AB):

Équations[modifier | modifier le wikicode]

Équation cartésienne[modifier | modifier le wikicode]

    def cartesienne(self):
        return '('+str(self.normal().x)+')x+('+str(self.normal().y)+')y='+str(self.normal().x*self.a.x+self.normal().y*self.a.y)

On écrit print(d.cartesienne()) pour afficher l'équation cartésienne de d.

Équation réduite[modifier | modifier le wikicode]

L'équation réduite y=mx+p est acquise dès que le coefficient directeur m et l'ordonnée à l'origine p=y-mx sont acquis.

Coefficient directeur[modifier | modifier le wikicode]

Le coefficient directeur est le quotient de l'ordonnée du vecteur directeur par son abscisse:

    def cd(self):
        return self.directeur().y/self.directeur().x

Ordonnée à l'origine[modifier | modifier le wikicode]

    def oalo(self):
        return self.a.y-self.cd()*self.a.x

Équation[modifier | modifier le wikicode]

On l'obtient à partir des deux nombres précédents:

    def reduite(self):
        return 'y='+str(self.cd())+'x+('+str(self.oalo())+')'

On l'affiche par print(d.reduite())

Point d'intersection[modifier | modifier le wikicode]

Pour calculer les coordonnées du point d'intersection de deux droites, on doit résoudre un système. Voir à ce sujet le chapitre qui lui est consacré.

Relations entre droites[modifier | modifier le wikicode]

Parallélisme[modifier | modifier le wikicode]

Pour savoir si deux droites sont parallèles, on peut

  1. Regarder si leurs vecteurs directeurs sont colinéaires (mieux);
  2. ou comparer leurs coefficients directeurs (moins bien, il faut déjà qu'elles en aient un!)

C'est la première méthode qui sera appliquée ici, bien que la deuxième soit plus rapide:

    def parallele(self,d):
        return self.directeur().colin(d.directeur())

Orthogonalité[modifier | modifier le wikicode]

Pour savoir si deux droites sont perpendiculaires, on regarde si leurs vecteurs normaux le sont:

    def perpendiculaire(self,d):
        return self.normal().ortho(d.normal())


Application à l'exercice précédent[modifier | modifier le wikicode]

En résumé, l'objet Droite se résume à ceci:

from math import *

class Droite:
    def __init__(self,a,b):
        self.a=a
        self.b=b

    def directeur(self):
        return self.a.vecteur(self.b)

    def normal(self):
        return Vecteur(-self.directeur().y,self.directeur().x)

    def cartesienne(self):
        return '('+str(self.normal().x)+')x+('+str(self.normal().y)+')y='+str(self.normal().x*self.a.x+self.normal().y*self.a.y)

    def cd(self):
        return self.directeur().y/self.directeur().x

    def oalo(self):
        return self.a.y-self.cd()*self.a.x

    def reduite(self):
        return 'y='+str(self.cd())+'x+('+str(self.oalo())+')'

    def parallele(self,d):
        return self.directeur().colin(d.directeur())

    def perpendiculaire(self,d):
        return self.normal().ortho(d.normal())

Pour l'exercice des chapitres précédents, on peut vérifier que le triangle ABC est rectangle en C, en regardant si les droites (AC) et (BC) sont perpendiculaires:

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


d1=Droite(c,a)
d2=Droite(c,b)

print(d1.perpendiculaire(d2))