Géométrie et distance

Le
Michael Grünewald
Salut,

j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections.

J'aimerais avoir quelques indications sur la façon de s'en tirer habilement.


La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est ni
très joli, ni très maintenable!

Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe de
figure est capable de se présenter comme une réunion de figures simples
dont on sait calculer les distances mutuelles et les intersections, et
cette présentation est utilisée par «PlanStrategy» pour traiter les cas
qu'il ne connaît pas.

Quelles sont les suggestions des développeurs chevronnés dans ce cas …
de figure?


J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.

J'ai cependant quelques problèmes avec la mise au point des programmes,
je fais partie des gens qui font beaucoup de petites fautes
d'inattention et j'ai l'habitude que le compilateur les détecte toutes
pour moi. Quelles sont les techniques de débogages plus avancées que le
saupoudrage de «print» du code? Saupoudrage qui du reste n'est pas très
recommandé s'il s'agit de traquer une erreur causée par une mauvaise
valeur envoyée vers le code d'une bibliothèque. Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de variables?


Merci pour vos conseils et votre aide!
--
Michael
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses Page 1 / 3
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Nicolas
Le #24226371

J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.



Des introductions à Python, il y en a plein. Des simples, des
compliquées, en français, en anglais...

J'ai cependant quelques problèmes avec la mise au point des programmes,
je fais partie des gens qui font beaucoup de petites fautes
d'inattention et j'ai l'habitude que le compilateur les détecte toutes
pour moi. Quelles sont les techniques de débogages plus avancées que le
saupoudrage de «print» du code? Saupoudrage qui du reste n'est pas très
recommandé s'il s'agit de traquer une erreur causée par une mauvaise
valeur envoyée vers le code d'une bibliothèque. Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?



Il y a des environnements de développements qui permettent de faire de
l'analyse de code. J'utilise Eclipse avec le plugin PyDev. Un peu lourd
mais très efficace. Il existe également d'autres solutions que je
n'utilise pas.

Nicolas
Michel Claveau - MVP
Le #24227471
Salut !

Pour calculer les distances, une simple fonction peut suffire.
Exemple :
# -*- coding: utf-8 -*-

import math

class point(object):

def __init__(self,x=0,y=0):
self.x=float(x)
self.y=float(y)


def distance(pdebut,pfin):
return math.sqrt(math.pow(pfin.y-pdebut.y,2)+math.pow(pfin.x-pdebut.x,2))


a=point(1,2)
b=point(8,3)
print distance(a,b)

print distance(point(5,6),point(2,2))





Pour déboguer, regarde la doc de Python sur le module pdb
C'est simple, mais déjà suffisant.


@-salutations
--
Michel Claveau
Alain Ketterlin
Le #24227951
Michael Grünewald
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calcul er des
distances entre deux objets ou des intersections.

J'aimerais avoir quelques indications sur la façon de s'en tirer hab ilement.

La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!



Oui, mais il n'y a pas vraiment de solution, il n'y a pas de moyen
général de définir la distance. (Voir plus bas.)

En fait, le calcul de la distance va dans chaque cas dépendre du type
des deux figures impliquées. Les langages objets comme Python ne font de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de choisir
une version en fonction de tous les types de paramètres.

Je pensais créer une classe singleton «PlanStrategy» en ch arge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figu res
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «Pla nStrategy»
pour traiter les cas qu'il ne connaît pas.



C'est une très bonne idée. Vraiment. Il reste encore à dà ©finir ce qu'est
la distance (sûrement le min des distances des composants). Mais le
principe est très bien, je trouve.

[...]
J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détec te
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?



Il y a pdb (je n'ai jamais essayé, en général je m'en sors a vec des
print...)

Si tu en arrives à des programmes assez compliqués, tu vas amà ¨rement
regretter le typage statique. Mais c'est un autre débat. La répon se
habituelle pour python est : écrire des tests unitaires, des tas de
tests unitaires, etc.

-- Alain.
Michael Grünewald
Le #24228081
Nicolas wrote:
[…] Je trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.



Des introductions à Python, il y en a plein. Des simples, des
compliquées, en français, en anglais...



En l'occurence il s'agissait du tutoriel canonique appartenant à la doc
officielle.

J'ai cependant quelques problèmes avec la mise au point des programmes, […] Y-a'il des outils pour
«tracer» le code, qui notamment afficheraient les affectations de
variables?



Il y a des environnements de développements qui permettent de faire de
l'analyse de code. J'utilise Eclipse avec le plugin PyDev. Un peu lourd
mais très efficace. Il existe également d'autres solutions que je
n'utilise pas.



Ok merci pour l'info.
--
Michael
Michael Grünewald
Le #24228071
Salut,

Michel Claveau - MVP wrote:
Pour calculer les distances, une simple fonction peut suffire.
Exemple :
[…]



merci pour ta réponse, mais es-tu bien sûr d'avoir lu la question? :-)

Pour déboguer, regarde la doc de Python sur le module pdb
C'est simple, mais déjà suffisant.



Merci, je regarderai le module pdb.
--
Michael
Michael Grünewald
Le #24228141
Bonjour Alain,

merci pour ta réponse,

Alain Ketterlin wrote:
Michael Grünewald
j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections. […]



En fait, le calcul de la distance va dans chaque cas dépendre du type
des deux figures impliquées. Les langages objets comme Python ne font de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de choisir
une version en fonction de tous les types de paramètres.



je ne comprends pas très bien ce que tu veux dire: «Python ne [fait] de
liaison dynamique que sur un paramètre.» La liaison dynamique, c'est
bien ce qu'on appelle aussi la résolution des méthodes? C'est-à dire
l'opération qui étant donné un objet et une méthode trouve la bonne
fonction a appeler?

La paramètre dont tu parles dans le cas de Python, c'est la classe de
l'objet, c'est ça (la valeur de retour de type)? Dans le cas de Lisp ,
je ne vois pas du tout ce que cela peut vouloir dire…

Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.



C'est une très bonne idée. Vraiment.



Merci! :) Manifestement je ne suis pas sur un trop mauvaise voie…

Il reste encore à définir ce qu'est
la distance (sûrement le min des distances des composants).



La distance de A à B (A, B parties du plan) est l'inf des distances
entre a et b, pour a dans A et b dans B. Donc effectivement, dans le
cas des unions finies, la distance est le min des distances des
composantes. Pour des objets à p et q composantes, cela fait p*q
distances à calculer, si on utilise cette approche générale.

J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code?



Il y a pdb (je n'ai jamais essayé, en général je m'en sors avec des
print...)

Si tu en arrives à des programmes assez compliqués, tu vas amèrement
regretter le typage statique.



C'est déjà fait! :) J'ai implémenté un algorithme de triangulation de
Delaunay, cela m'a pris un temps complètement intolérable,
essentiellement à cause de fautes de frappe… j'ai regretté OCaml avec
lequel j'aurais réglé ça en une demi-journée au lieu de deux jours.

Mais c'est un autre débat. La réponse
habituelle pour python est : écrire des tests unitaires, des tas de
tests unitaires, etc.



Très bien, je me plierai à ce nouveau mantra. Est-ce qu'il a des outils
ou des méthodologies spéciaux pour écrire les tests unitaires en Python?
--
Michael
Alain Ketterlin
Le #24228371
Michael Grünewald
j'ai implémenté quelques classes représentant des figure s dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calc uler des
distances entre deux objets ou des intersections. […]



En fait, le calcul de la distance va dans chaque cas dépendre du ty pe
des deux figures impliquées. Les langages objets comme Python ne fo nt de
liaison dynamique que sur un paramètre. Un langage comme... Common Lisp
(oui, Lisp, ou plutôt CLOS, son extension objet) te permet de chois ir
une version en fonction de tous les types de paramètres.



je ne comprends pas très bien ce que tu veux dire: «Python ne [fait]
de liaison dynamique que sur un paramètre.» La liaison dynamiq ue,
c'est bien ce qu'on appelle aussi la résolution des méthodes? C'est-à
dire l'opération qui étant donné un objet et une méth ode trouve la
bonne fonction a appeler?



C'est exactement cela.

La paramètre dont tu parles dans le cas de Python, c'est la classe de
l'objet, c'est ça (la valeur de retour de type)? Dans le cas de Lisp
, je ne vois pas du tout ce que cela peut vouloir dire…



Si tu as o1.distance(o2) :
- c'est le type de o1 qui va déterminer la méthode
- mais le calcul effectif va dépendre des types de o1 et o2
Typiquement, la méthode appelée va tester le type de o2 (il y a d es
astuces pour éviter les tests de type explicites).

En Lisp tu vas écrire (distance o1 o2) -- c'est un détail de synt axe --
mais tu peux définir diverses versions de la fonction distance selon l es
types de o1 et o2 (une première pour Point*Ligne, une pour Point*Point,
etc.) C'est juste une généralisation à plusieurs dimensions de la
"résolution des méthodes".

C'est ton cas : ce qui détermine la méthode à appeler, c'est le couple
des types des paramètres. Tu ne peux pas écrire cela dans un lang age
object à la Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et
Dylan, et peut-être quelques autres).

Bref.

[...]
Si tu en arrives à des programmes assez compliqués, tu vas am èrement
regretter le typage statique.



C'est déjà fait! :) J'ai implémenté un algorithme de triangulation de
Delaunay, cela m'a pris un temps complètement intolérable,
essentiellement à cause de fautes de frappe… j'ai regrettà © OCaml avec
lequel j'aurais réglé ça en une demi-journée au lieu de deux jours.



On est bien d'accord.

Mais c'est un autre débat. La réponse habituelle pour python e st :
écrire des tests unitaires, des tas de tests unitaires, etc.



Très bien, je me plierai à ce nouveau mantra. Est-ce qu'il a d es
outils ou des méthodologies spéciaux pour écrire les tests unitaires
en Python?



Il y a quelques infos dans la page du module unittest, à
http://docs.python.org/library/unittest.html

-- Alain.
Paul Gaborit
Le #24229441
À (at) Tue, 07 Feb 2012 19:17:33 +0100,
Alain Ketterlin
C'est ton cas : ce qui détermine la méthode à appeler, c'est le couple
des types des paramètres.



Effectivement.

Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).



Heu... Le polymorphisme permet pourtant exactement cela. Il est
explicite en Java et en C++ (et beaucoup d'autres langages orientés
objet à typage fort). Il est "simulable" en Python/Perl/Ruby bien que
non explicite.


--
Paul Gaborit -
Alain Reymond
Le #24229701
Le 07/02/2012 07:18, Michael Grünewald a écrit :
Salut,

j'ai implémenté quelques classes représentant des figures dans le plan
(des points, des lignes brisées, …) et j'ai besoin de calculer des
distances entre deux objets ou des intersections.

J'aimerais avoir quelques indications sur la façon de s'en tirer
habilement.


La méthode malhabile que j'utilise jusqu'ici consiste à ajouter une
méthode distance_to_<figure> à chaque classe qui doit calculer sa
distance à une <figure>. Le moins qu'on puisse dire est que ce n'est
ni très joli, ni très maintenable!

Je pensais créer une classe singleton «PlanStrategy» en charge de
calculer les distances (et les intersections) qui apprend des cas
particuliers et qui sait les généraliser. Par exemple, chaque classe
de figure est capable de se présenter comme une réunion de figures
simples dont on sait calculer les distances mutuelles et les
intersections, et cette présentation est utilisée par «PlanStrategy»
pour traiter les cas qu'il ne connaît pas.

Quelles sont les suggestions des développeurs chevronnés dans ce cas …
de figure?


J'ai débuté Python il y a deux semaines, le langage est très facile à
prendre en main quand on a de l'expérience de la programmation. Je
trouve que le tutoriel a quelques graves lacunes (le mot clef «return»
n'y apparaît même pas, il me semble!) mais fournit une introductiuon
efficace.

J'ai cependant quelques problèmes avec la mise au point des
programmes, je fais partie des gens qui font beaucoup de petites
fautes d'inattention et j'ai l'habitude que le compilateur les détecte
toutes pour moi. Quelles sont les techniques de débogages plus
avancées que le saupoudrage de «print» du code? Saupoudrage qui du
reste n'est pas très recommandé s'il s'agit de traquer une erreur
causée par une mauvaise valeur envoyée vers le code d'une
bibliothèque. Y-a'il des outils pour «tracer» le code, qui notamment
afficheraient les affectations de variables?



Bonjour,

Un excellent IDE Python est PyScripter
http://code.google.com/p/pyscripter/ :
- bon IDE, complètement automatique de code
- débogage, points d'arrêts, suivi des variables, analyse rétrospective,
etc...

Facilite la vie du développeur.

Cdlt.


AR
Alain Ketterlin
Le #24230091
Paul Gaborit
À (at) Tue, 07 Feb 2012 19:17:33 +0100,
Alain Ketterlin
C'est ton cas : ce qui détermine la méthode à appeler, c' est le couple
des types des paramètres.



Effectivement.

Tu ne peux pas écrire cela dans un langage object à la
Python/C++/Java/etc. (en fait, dans tous sauf Lisp/CLOS et Dylan, et
peut-être quelques autres).



Heu... Le polymorphisme permet pourtant exactement cela. Il est
explicite en Java et en C++ (et beaucoup d'autres langages orientés
objet à typage fort). Il est "simulable" en Python/Perl/Ruby bien que
non explicite.



Oui, mais pas avec deux arguments. Même pour C++ et Java. Il faut faire
l'équivalent de :

class A:
# dispatch
def distance(self,other):
return other.distance_to_A(self)
# versions spécialisées
def distance_to_A(self,other):
# ici on sait que other est de type A
return ...
def distance_to_B(self,other):
# ici on sait que other est de type B
return ...

class B:
# dispatch
def distance(self,other):
return other.distance_to_B(self)
# versions spécialisées
def distance_to_A(self,other):
# ici on sait que other est de type A
return ...
def distance_to_B(self,other):
# ici on sait que other est de type B
return ...

En CLOS on écrit des fonctions génériques [*] hors de toute classe, donc
aucun des paramètres ne prime sur les autres. On écrirait quelque chose
qui ressemble à :

(defmethod distance ((a A) (a A)) ...)
(defmethod distance ((a A) (b B)) ...)
(defmethod distance ((b B) (a A)) ...)
(defmethod distance ((b B) (b B)) ...)

Le dispatch se fait tout seul.

-- Alain.

[*] Le terme est mal choisi, mais à l'époque c'était cohà ©rent.
Publicité
Poster une réponse
Anonyme