La droite peut être définie à partir d'une de ses équations, mais aussi à partir de deux points. Et comme on a vu précédemment comment on peut créer en "Ruby" un objet "point", on va voir comment on peut s'en servir pour gérer des droites sous "Ruby".
Définition.
Là encore, on va définir une classe "Droite" possédant, lors de son instanciation, deux points:
class Droite
 def initialize(a,b)
 @a,@b=a,b
 end
Vecteurs.
Vecteur directeur.
 def directeur
 @a.vecteur(@b)
 end
On obtient le vecteur directeur de "d" par "d.directeur"
Alignement.
Pour savoir si le point "m" est sur la droite d, on peut rajouter ce test:
 def IsOnLine(d)
 vecteur(d.a).colin(d.directeur)
 end
mais on le rajoute dans l'objet "Point", puisque c'est une propriété du point...
Vecteur normal.
Le vecteur normal s'obtient en choisissant ses coordonnées pour que le produit scalaire avec le vecteur directeur soit nul:
 def normal
 Vecteur.new(-self.directeur.y,self.directeur.x)
 end
Le vecteur normal s'obtient avec "d.normal" et permet facilement d'avoir l'équation cartésienne ci-dessous.
Équations.
Équation cartésienne.
 def cartesienne
 '('+self.normal.x.to_s+')x+('+self.normal.y.to_s+')y='+(self.normal.x*@a.x+self.normal.y*@a.y).to_s
 end
Pour afficher l'équation cartésienne de "d", on entre
puts(d.cartesienne)
Équation réduite.
Comme il y a des divisions à effectuer, on a intérêt à faire appel à "mathn':
require 'mathn'
Coefficient directeur.
 def cd
 self.directeur.y/self.directeur.x
 end
Ordonnée à l'origine.
 def oalo
 @a.y-self.cd*@a.x
 end
Équation.
L'équation réduite se définit par
 def reduite
 'y='+self.cd.to_s+'x+('+self.oalo.to_s+')'
 end
et s'obtient par "d.reduite".
Comparaison de deux droites.
Parallélisme.
Deux droites sont parallèles lorsque leurs vecteurs directeurs sont colinéaires. Mais aussi (sous réserve qu'elles en aient) lorsqu'elles ont le même coefficient directeur:
 def parallele(d)
 self.cd==d.cd
 end
Pour savoir si deux droites "d1" et "d2" sont parallèles, on fait
puts(d1.parallele(d2))
Perpendicularité.
Deux droites sont perpendiculaires si et seulement si leurs vecteurs normaux sont orthogonaux:
 def perpendiculaire(d)
 self.normal.ortho(d.normal)
 end
On aurait aussi pu chercher si le produit de leurs coefficients directeurs est égal à -1.
Intersection.
Pour calculer les coordonnées du point d'intersection de deux droites, on résout un système.
Exemple.
Dans l'exemple des chapitres précédents, on peut regarder si les deux droites (CA) et (CB) sont perpendiculaires:
a=Point.new(-1,3)
b=Point.new(5,1)
c=Point.new(1,5)
d1=Droite.new(c,a)
d2=Droite.new(c,b)
puts(d1.perpendiculaire(d2))

Mathématiques avec Python et Ruby/Vecteurs en Python

Géométriquement, un 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.
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.
Abscisse.
 self.x=x
L'abscisse de "u" s'obtiendra par "u.x"
Ordonnée.
 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=
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.
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.
"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.
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.
Par un réel.
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.
En multipliant un vecteur par un vecteur, on obtient un nombre, ou . Aussi cette multiplication est-elle appelée 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.
Vecteurs colinéaires.
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.
Pour savoir si deux vecteurs sont orthogonaux, on compare leur produit scalaire à 0 :
 def ortho(self,v):
 return self*v==0
Exemple.
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))

Mathématiques avec Python et Ruby/Droites en Python