ajout de la cle 62

[challenge75]

slt,

Suite a une question posée au paravent,

voici la situation: dans les prorietes d'une entité; je n'ai pas le clé 62 (coueur de l'entité).Donc il met impossible de modifier la couleur par les propriétés de l'entité.

comment puis je effectuer cette modification par le lisp.Merci

[(gile)]

Salut,

 

Par exemple :

 

;; Choix de l'entité
(setq ent (car (entsel)))

;; liste DXF de l'entité
(setq elst (entget ent))

;; si le code 62 est présent ...
(if (assoc 62 elst)
 ;; ... le remplacer un nouveau
 (setq	elst (subst (cons 62 Nouvelle_Couleur)
	    (assoc 62 elst)
	    elst
     )
 )
 ;; sinon, en ajouter un
 (setq elst (append elst (list (cons 62 Nouvelle_Couleur))))
) 

[Patrick_35]

ah ah ;)

Il manque le entmod pour que la démo soit complète :D

 

@+

[(gile)]

C'est vrai, jai oublié :calim:

 

;; modifier l'entité
(entmod elst) 

[usegomme]

Merci , ça tombe à pic , c'est justement ce dont j'ai besoin aujourd'hui.

[Tramber]

C'est vexant.

 

On avait apporté la réponse....

[BTO]

bonjour, pour aller un peu plus loin

 

un append est beaucoup plus lent qu'un cons, or de manière générale c'est toujours à éviter dans la manipulation des listes.

ici je ne vois pas de raison particulière d'utiliser un append, sinon merci de le précisier :yltype:

Il me semble préfèrable d'utiliser une écriture de la forme :

 

(setq elst (cons (cons 62 Nouvelle_Couleur) elst))

 

Bruno Toniutti

 

[(gile)]

Salut Bruno,

 

Merci pour la confirmation, j'avais lu quelque part, probablement dans le Faq Autolisp de Reini Urban, qu'un (cons ...) est préférable à un (append ...).

 

Si j'ai utilisé ici (append ...), c'est par flemme de faire un (reverse (cons (reverse ...). En effet, je voulais mettre le code 62 en fin de liste parcequ'il me semble que le type d'entité (code 0) doit obligatoirement être en première ou deuxième position dans la liste, mais ceci ne vaut peut-être qu'avec (entmake ...) ?

[Patrick_35]

Je viens d'apprendre quelque chose. :)

Mais du coup, un reverse de ma liste me fait logiquement perdre au moins le gain de temps du cons par rapport au append :casstet:

 

@+

[(gile)]

Extrait de la faq AutoLISP de Reini Urban (ici):

 

Préférez CONS à APPEND : trois 'CONS' et un 'REVERSE' c'est mieux qu'un 'APPEND'.

 

Peut-être ne s'agit-il pas que de vitesse ? Mais quoi, alors ?

[(gile)]

Un petit BenchMark pour en avoir le coeur net :

 

 (setq a 10 l '(20 30 40))

 

 

(cons a l) est effectivement plus rapide que (append (list a) l)

 

_$ (benchmark '((cons a l) (append (list a) l)))

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

 

(CONS A L)..............1000 / 1.16

(APPEND (LIST A) L).....1156 / 1.00

 

 

mais (reverse (cons a (reverse l))) l'est moins que (append l (list a))

 

_$ (benchmark '((reverse (cons a (reverse l))) (append l (list a))))

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

 

(APPEND L (LIST A))................1171 / 1.04

(REVERSE (CONS A (REVERSE L))).....1219 / 1.00

[BTO]

bonjour :)

 

Gile,

en fait la manière utilisée dans ton test n'est pas représentative du décalage entre un cons et un append, plus la liste est grande plus l'écart est important. De manière génèrale quand on contruit une liste au cours d'une boucle (ce n'est pas notre cas dans la question initiale, mais autant avoir la solution la plus efficace), au fur et à mesure que la liste grandi, l'écart s'accentue. Un append mal placé peut même rendre un lisp inexploitable.

 

Exemple

 
(defun methode1 ()
 (setq a "a" l nil)
 (repeat 1000
   (setq l (cons a l))
 )
)

(defun methode2 ()
 (setq a "a" l nil)
 (repeat 1000
   (setq l (append (list a) l))
 )
)

 

on obtient :

Benchmarking ..............Elapsed milliseconds / relative speed for 2048 iteration(s):

 

(METHODE1).......1969 / 56.41 - fastest

(METHODE2).....111062 / 1 - slowest

 

ce qui est énorme ;)

 

Bruno Toniutti

 

[Edité le 8/2/2007 par BTO]

[Patrick_35]

Oui, enfin je pense qu'il y a un peu de parti pris ;)

Mais il ne faut pas oublier le reverse afin de comparer ce qui est comparable :exclam:

 

@+

[BTO]

Patrick,

des boucles qui contruisent des listes de plus 1000 élèments et plus, il y en a plein :) et quand bien même l'ordre des éléments serait important (ce qui de plus, souvent n'est pas le cas, dont le notre de modification de la couleur), le reverse est négligeable.

 

par exemple :

(defun methode1 ()
 (setq a "a" l nil)
 (repeat 1000
   (setq l (cons a l))
 )
 (reverse l)
)

(defun methode2 ()
 (setq a "a" l nil)
 (repeat 1000
   (setq l (append l (list a)))
 )
)
donne :
   (METHODE1)......1062 / 59.9 - fastest
   (METHODE2).....63609 / 1 - slowest

 

pour des listes de 10 éléments l'écart est faible :

(METHODE1).....1016 / 1.17 -fastest

(METHODE2).....1187 / 1 slowest

 

mais pour des listes de 100 éléments on a déjà des écarts significatifs :

(METHODE1).....1219 / 5.68

(METHODE2).....6922 / 1

 

une lwpolyligne de seulement 2 sommets, correspond à une liste de 23 éléments.

 

Bref c'est juste histoire de discuter du lisp, les cas pour lesquels ça n'a aucune influence sont nombreux, cependant parfois ça peut être critique.

 

Edit 1 : comme tu le précises avec entmake l'ordre de la liste a son importance, mais entmod semble s'accommoder d'un cons.

 

Bruno Toniutti

 

[Edité le 8/2/2007 par BTO]

[(gile)]

Merci Bruno pour ce complément d'information fort instructif :)

[Patrick_35]

Je vais faire comme dupond et dupont

Merci Bruno pour cette information

 

@+