« Mathématiques avec Python et Ruby/Points en Ruby » : différence entre les versions
Annulation des modifications 446730 de CommonsDelinker (discussion) |
m <source> -> <syntaxhighlight> (phab:T237267) |
||
Ligne 11 : | Ligne 11 : | ||
Pour que ''Ruby'' possède un objet ''Point'', il suffit de le définir, sous la forme d'une ''classe'': |
Pour que ''Ruby'' possède un objet ''Point'', il suffit de le définir, sous la forme d'une ''classe'': |
||
< |
<syntaxhighlight lang="ruby"> |
||
class Point |
class Point |
||
Ligne 19 : | Ligne 19 : | ||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
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). |
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). |
||
Ligne 31 : | Ligne 31 : | ||
Il suffit de dire que la méthode ''x'' renvoit le nombre ''x'': |
Il suffit de dire que la méthode ''x'' renvoit le nombre ''x'': |
||
< |
<syntaxhighlight lang="ruby"> |
||
def x |
def x |
||
@x |
@x |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
(à l'intérieur de la classe) |
(à l'intérieur de la classe) |
||
Ligne 43 : | Ligne 43 : | ||
Idem pour ''y'': |
Idem pour ''y'': |
||
< |
<syntaxhighlight lang="ruby"> |
||
def y |
def y |
||
@y |
@y |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
Dorénavant, l'abscisse de ''P'' s'appelle ''P.x'' et son ordonnée, ''P.y''. |
Dorénavant, l'abscisse de ''P'' s'appelle ''P.x'' et son ordonnée, ''P.y''. |
||
Ligne 55 : | Ligne 55 : | ||
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: |
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: |
||
< |
<syntaxhighlight lang="ruby"> |
||
def to_s |
def to_s |
||
'('+@x.to_s+';'+@y.to_s+')' |
'('+@x.to_s+';'+@y.to_s+')' |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
Pour afficher un point ''M'', on peut faire |
Pour afficher un point ''M'', on peut faire |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(M.to_s) |
puts(M.to_s) |
||
</syntaxhighlight> |
|||
</source> |
|||
mais aussi |
mais aussi |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(M) |
puts(M) |
||
</syntaxhighlight> |
|||
</source> |
|||
puisque ''Ruby'' se charge automatiquement de la conversion ''to_s''. |
puisque ''Ruby'' se charge automatiquement de la conversion ''to_s''. |
||
Ligne 81 : | Ligne 81 : | ||
==Milieu== |
==Milieu== |
||
< |
<syntaxhighlight lang="ruby"> |
||
def milieu(q) |
def milieu(q) |
||
Point.new((@x+q.x)/2,(@y+q.y)/2) |
Point.new((@x+q.x)/2,(@y+q.y)/2) |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
La syntaxe est typique de ''Ruby'': On parle de "milieu avec q" en invoquant |
La syntaxe est typique de ''Ruby'': On parle de "milieu avec q" en invoquant |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(p.milieu(q)) |
puts(p.milieu(q)) |
||
</syntaxhighlight> |
|||
</source> |
|||
==Vecteur== |
==Vecteur== |
||
Ligne 97 : | Ligne 97 : | ||
Un peu hors sujet ici (on en reparlera dans [[Mathématiques_avec_Python_et_Ruby/Vecteurs_en_Ruby|le chapitre qui leur est consacré]]), le vecteur <math>\overrightarrow{AB}</math> 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'': |
Un peu hors sujet ici (on en reparlera dans [[Mathématiques_avec_Python_et_Ruby/Vecteurs_en_Ruby|le chapitre qui leur est consacré]]), le vecteur <math>\overrightarrow{AB}</math> 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'': |
||
< |
<syntaxhighlight lang="ruby"> |
||
def vecteur(q) |
def vecteur(q) |
||
Vecteur.new(q.x-@x,q.y-@y) |
Vecteur.new(q.x-@x,q.y-@y) |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
Ce qui oblige, soit à placer la classe [[Mathématiques_avec_Python_et_Ruby/Vecteurs_en_Ruby|vecteur]] dans le même fichier, soit à l'importer avec |
Ce qui oblige, soit à placer la classe [[Mathématiques_avec_Python_et_Ruby/Vecteurs_en_Ruby|vecteur]] dans le même fichier, soit à l'importer avec |
||
< |
<syntaxhighlight lang="ruby"> |
||
require 'vector' |
require 'vector' |
||
</ |
</syntaxhighlight> |
||
si on a enregistré ladite classe dans un fichier ''vector.rb''. |
si on a enregistré ladite classe dans un fichier ''vector.rb''. |
||
Ligne 117 : | Ligne 117 : | ||
La distance jusqu'à ''q'' est un nombre, mais associé à deux points: |
La distance jusqu'à ''q'' est un nombre, mais associé à deux points: |
||
< |
<syntaxhighlight lang="ruby"> |
||
def distance(q) |
def distance(q) |
||
(self.vecteur(q)).norme |
(self.vecteur(q)).norme |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
Pour faire le plus simple possible, on a là encore utilisé le fichier des [[Mathématiques_avec_Python_et_Ruby/Vecteurs_en_Ruby|vecteurs]] sous la forme de sa méthode ''norme'': La distance AB est la norme du vecteur <math>\overrightarrow{AB}</math>, qu'on calcule avec la fonction ''hypot'' de ''Ruby'' (voir au chapitre suivant comment on l'utilise). |
Pour faire le plus simple possible, on a là encore utilisé le fichier des [[Mathématiques_avec_Python_et_Ruby/Vecteurs_en_Ruby|vecteurs]] sous la forme de sa méthode ''norme'': La distance AB est la norme du vecteur <math>\overrightarrow{AB}</math>, qu'on calcule avec la fonction ''hypot'' de ''Ruby'' (voir au chapitre suivant comment on l'utilise). |
||
Ligne 127 : | Ligne 127 : | ||
Pour calculer la distance entre ''p'' et ''q'', on entre |
Pour calculer la distance entre ''p'' et ''q'', on entre |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(p.distance(q)) |
puts(p.distance(q)) |
||
</syntaxhighlight> |
|||
</source> |
|||
ou, au choix, |
ou, au choix, |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(q.distance(p)) |
puts(q.distance(p)) |
||
</syntaxhighlight> |
|||
</source> |
|||
=Application au problème= |
=Application au problème= |
||
Ligne 141 : | Ligne 141 : | ||
Pour récapituler, la classe ''Point'' en entier est décrite ici: |
Pour récapituler, la classe ''Point'' en entier est décrite ici: |
||
< |
<syntaxhighlight lang="ruby"> |
||
class Point |
class Point |
||
Ligne 173 : | Ligne 173 : | ||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
C'est tout! |
C'est tout! |
||
Ligne 179 : | Ligne 179 : | ||
On commence par créer trois points, les sommets du triangle: |
On commence par créer trois points, les sommets du triangle: |
||
< |
<syntaxhighlight lang="ruby"> |
||
a=Point.new(-1,3) |
a=Point.new(-1,3) |
||
b=Point.new(5,1) |
b=Point.new(5,1) |
||
c=Point.new(1,5) |
c=Point.new(1,5) |
||
</syntaxhighlight> |
|||
</source> |
|||
==Nature de ABC== |
==Nature de ABC== |
||
Ligne 189 : | Ligne 189 : | ||
Pour voir si ABC est isocèle, on peut afficher les longueurs de ses côtés: |
Pour voir si ABC est isocèle, on peut afficher les longueurs de ses côtés: |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(a.distance(b)) |
puts(a.distance(b)) |
||
puts(a.distance(c)) |
puts(a.distance(c)) |
||
puts(b.distance(c)) |
puts(b.distance(c)) |
||
</syntaxhighlight> |
|||
</source> |
|||
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 [[w:Théorème de Pythagore|théorème de Pythagore]]: |
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 [[w:Théorème de Pythagore|théorème de Pythagore]]: |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(a.distance(b)**2) |
puts(a.distance(b)**2) |
||
puts(a.distance(c)**2+b.distance(c)**2) |
puts(a.distance(c)**2+b.distance(c)**2) |
||
</syntaxhighlight> |
|||
</source> |
|||
C'est clair, le triangle ABC est rectangle en C. |
C'est clair, le triangle ABC est rectangle en C. |
||
Ligne 208 : | Ligne 208 : | ||
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: |
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: |
||
< |
<syntaxhighlight lang="ruby"> |
||
m=a.milieu(b) |
m=a.milieu(b) |
||
puts(m) |
puts(m) |
||
</syntaxhighlight> |
|||
</source> |
|||
==Rayon du cercle== |
==Rayon du cercle== |
||
Ligne 218 : | Ligne 218 : | ||
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'': |
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'': |
||
< |
<syntaxhighlight lang="ruby"> |
||
puts(m.distance(a)) |
puts(m.distance(a)) |
||
puts(m.distance(b)) |
puts(m.distance(b)) |
||
puts(m.distance(c)) |
puts(m.distance(c)) |
||
</syntaxhighlight> |
|||
</source> |
|||
==Figure== |
==Figure== |
Version actuelle du 16 avril 2020 à 09:27
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.
Classe[modifier | modifier le wikicode]
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ées[modifier | modifier le wikicode]
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).
Abscisse[modifier | modifier le wikicode]
Il suffit de dire que la méthode x renvoit le nombre x:
def x
@x
end
(à l'intérieur de la classe)
Ordonnée[modifier | modifier le wikicode]
Idem pour y:
def y
@y
end
Dorénavant, l'abscisse de P s'appelle P.x et son ordonnée, P.y.
Affichage[modifier | modifier le wikicode]
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 points[modifier | modifier le wikicode]
Le plus simple avec deux points, c'est le milieu, parce que c'est un objet de même type (un point):
Milieu[modifier | modifier le wikicode]
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))
Vecteur[modifier | modifier le wikicode]
Un peu hors sujet ici (on en reparlera dans le chapitre qui leur est consacré), le vecteur 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.
Distance[modifier | modifier le wikicode]
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 , 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ème[modifier | modifier le wikicode]
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 ABC[modifier | modifier le wikicode]
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 cercle[modifier | modifier le wikicode]
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 cercle[modifier | modifier le wikicode]
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))
Figure[modifier | modifier le wikicode]
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: