L'objet Point est une bonne manière d'aborder la programmation objet. En géométrie repérée, un point est constitué de deux nombres, son abscisse et son ordonnée.

Ruby et géométrie

Vecteurs en Ruby

Voici l'énoncé de l'exercice:

Dans un repère orthonormé, on considère 
  
    
      
        A
        (
        −
        1
        ;
        3
        )
      
    
    {\displaystyle A(-1;3)}
  , 
  
    
      
        B
        (
        5
        ;
        1
        )
      
    
    {\displaystyle B(5;1)}
   et 
  
    
      
        C
        (
        1
        ;
        5
        )
      
    
    {\displaystyle C(1;5)}
  . Calculer les distances AB, AC et BC et en déduire la nature du triangle ABC. Puis en déduire les coordonnées du centre de son cercle circonscrit, et le rayon de celui-ci.

ClasseModifier

Pour que Ruby possède un objet Point, il suffit de le définir, sous la forme d'une classe:

class Point

    def initialize(x,y)
        @x, @y = x, y
    end

end

Dorénavant, chaque fois qu'on crée un point par Point.new(x,y), celui-ci possédera les coordonnées x et y qui sont pour l'instant ses seules propriétés (des variables stockées temporairement dans l'objet).

CoordonnéesModifier

Cependant pour accéder depuis l'extérieur aux coordonnées du point, il faut les redéfinir comme des méthodes Ruby (parce que dans Ruby, tout est méthode).

AbscisseModifier

Il suffit de dire que la méthode x renvoit le nombre x:

    def x
        @x
    end

(à l'intérieur de la classe)

OrdonnéeModifier

Idem pour y:

    def y
        @y
    end

Dorénavant, l'abscisse de P s'appelle P.x et son ordonnée, P.y.

AffichageModifier

Pour afficher un objet, il faut utiliser la conversion to_s que Ruby propose. Dans le cas présent, puisqu'on a inventé un nouvel objet, on doit redéfinir cette conversion en chaîne de caractères en mettant les coordonnées entre parenthèses, séparées par un point-virgule:

    def to_s
        '('+@x.to_s+';'+@y.to_s+')'
    end

Pour afficher un point M, on peut faire

puts(M.to_s)

mais aussi

puts(M)

puisque Ruby se charge automatiquement de la conversion to_s.

Deux pointsModifier

Le plus simple avec deux points, c'est le milieu, parce que c'est un objet de même type (un point):

MilieuModifier

    def milieu(q)
        Point.new((@x+q.x)/2,(@y+q.y)/2)
    end

La syntaxe est typique de Ruby: On parle de "milieu avec q" en invoquant

puts(p.milieu(q))

VecteurModifier

Un peu hors sujet ici (on en reparlera dans le chapitre qui leur est consacré), le vecteur ${\overrightarrow {AB}}$ est bel et bien associé à deux points: son origine A et son extrémité B. Et ses coordonnées se calculent à partir de celles de A et de B:

    def vecteur(q)
        Vecteur.new(q.x-@x,q.y-@y)
    end

Ce qui oblige, soit à placer la classe vecteur dans le même fichier, soit à l'importer avec

require 'vector'

si on a enregistré ladite classe dans un fichier vector.rb.

Là encore, on parle de méthode vecteur jusqu'à q pour un point p.

DistanceModifier

La distance jusqu'à q est un nombre, mais associé à deux points:

    def distance(q)
        (self.vecteur(q)).norme
    end

Pour faire le plus simple possible, on a là encore utilisé le fichier des vecteurs sous la forme de sa méthode norme: La distance AB est la norme du vecteur ${\overrightarrow {AB}}$ , qu'on calcule avec la fonction hypot de Ruby (voir au chapitre suivant comment on l'utilise).

Pour calculer la distance entre p et q, on entre

puts(p.distance(q))

ou, au choix,

puts(q.distance(p))

Application au problèmeModifier

Pour récapituler, la classe Point en entier est décrite ici:

class Point

    def initialize(x,y)
        @x, @y = x, y
    end
    
    def x
        @x
    end

    def y
        @y
    end

    def to_s
        '('+@x.to_s+';'+@y.to_s+')'
    end

    def milieu(q)
        Point.new((@x+q.x)/2,(@y+q.y)/2)
    end

    def vecteur(q)
        Vecteur.new(q.x-@x,q.y-@y)
    end

    def distance(q)
        (self.vecteur(q)).norme
    end

end

C'est tout!

On commence par créer trois points, les sommets du triangle:

a=Point.new(-1,3)
b=Point.new(5,1)
c=Point.new(1,5)

Nature de ABCModifier

Pour voir si ABC est isocèle, on peut afficher les longueurs de ses côtés:

puts(a.distance(b))
puts(a.distance(c))
puts(b.distance(c))

mais on n'apprend pas grand-chose (sinon qu'il n'est pas isocèle). Mais on peut chercher s'il est rectangle avec la réciproque du théorème de Pythagore:

puts(a.distance(b)**2)
puts(a.distance(c)**2+b.distance(c)**2)

C'est clair, le triangle ABC est rectangle en C.

Centre du cercleModifier

Il en résulte alors que le cercle circonscrit a pour diamètre [AB], donc pour centre le milieu M de [AB] et pour rayon la moitié de AB:

m=a.milieu(b)

puts(m)

Rayon du cercleModifier

Le rayon peut se calculer en divisant par 2 la distance AB, ou mieux, en vérifiant que les trois rayons MA, MB et MC ont la même longueur à la précision permise par Ruby:

puts(m.distance(a))
puts(m.distance(b))
puts(m.distance(c))

FigureModifier

On peut résumer le tout en modifiant le script ci-dessus pour qu'il crée des éléments svg, dont le résultat est visible ci-dessous:

Mathématiques avec Python et Ruby/Points en Ruby

Sections