Quelques fonctions de liste..

[VDH-Bruno]

Bonjour,

 

Quelques fonctions de traitement de liste écritent récemment, c'est pas du grand art, mais bon si des fois ça peut servir..

 

 
;; ---------------------------------------------------------------
;; (bv:lst-type lst ltype flag)                                   
;; Sélectionne ou supprime d'une liste des éléments par type.     
;; ---------------------------------------------------------------
;; Arguments:                                                     
;;   lst  => Une liste d'élément.                                 
;;   ltype=> Une liste des types d'éléments à sélectionner.       
;;   flag => Si flag=nil les éléments sont supprimés de la liste  
;;           Si flag= T  seul les éléments spécifiés sont gardés  
;;                                                                
;; Retourne: Une liste en fonction des conditions spécifiés.      
;;                                                                
;; Exemples :                                                     
;;   (bv:lst-type '(1.0 "Un" 2 toto) '(SYM REAL) T)               
;;              => (1.0 TOTO)                                     
;;   (bv:lst-type '(1.0 "Un" 2 toto) '(SYM REAL) nil)             
;;              => ("Un" 2)                                       

(defun bv:lst-type (lst ltype flag)
 (apply
   'append
   (mapcar
     '(lambda (x)
            (cond
              (flag (if (apply 'or (mapcar '(lambda (y) (= (type x) y)) ltype)) (list x)))
              (T (if (not (apply 'or (mapcar '(lambda (y) (= (type x) y)) ltype))) (list x)))
            )
      )
     lst
   )
 )
)

 

 
;; ---------------------------------------------------------------
;; ar-1:n => Arrangement à Répétition de 1 à n (Version itérative)
;; ---------------------------------------------------------------
;; Argument: Une liste de symboles (d'éléments)                   
;; Retourne: Tous les arrangements de 1 à n                       
;; Exemple :                                                      
;;   (ar-1:n '(A B C) 2)                                          
;;    => ((A) (B) (C) (A A) (A B) (A C) (B A) (B B) (B C) (C A) (C B) (C C))

(defun ar-1:n (l n / lst res)
 (setq lst '(nil))
 (repeat n
   (setq res (append res
       (setq lst
       (apply 'append
       (mapcar '(lambda (x)
           (mapcar '(lambda (y) (cons x y)) lst)
         )
        l
       )
       )
       )
      )
   )
 )
)

 

 
;; ---------------------------------------------------------------
;; (bv:str-num lst)                                               
;; Retourne une liste de chaînes non numérique.                   
;; ---------------------------------------------------------------
;; Argument: Une liste composé de chaînes de caractères.          
;; Retourne: Une liste de chaînes exclusivement non-numérique.    
;; Exemple :  (bv:str-num (list "1.0" "Un" "-2E11" "Deux" ""))    
;; Retourne ("Un" "Deux" "")                                      

(defun bv:str-num (lst)
 (apply 'append (mapcar 
                              '(lambda (x) 
                                  (if 
                                     (not (or 
                                          (= (type (read x)) 'INT)  
                                          (= (type (read x)) 'REAL))
                                        ) 
                                      (list x))) 
                                  lst)
 )
)

 

Cette dernière me permet lorsque je me sert de ma routine d'arrangement pour combiner des chaînes, à exclure de ces dernières les chaînes représentants des valeurs numérique aux yeux d'AutoCAD comme "-1E11" ou "123" par exemples.

 
_$ (bv:str-num (mapcar '(lambda (x) (apply 'strcat x)) (ar-1:n '("A" "E" "F" "1" "3" "-") 2)))
("A" "E" "F" "-" "AA" "AE" "AF" "A1" "A3" "A-" "EA" "EE" "EF" "E1" "E3" "E-" "FA" "FE" "FF" "F1"
"F3" "F-" "1A" "1E" "1F" "1-" "3A" "3E" "3F" "3-" "-A" "-E" "-F" "--")
_$ 

[Tramber]

C'est vraiment du pur Autolisp !

Mais est-ce que, par exemple, bv:lst-type est plus rapide ou plus puissant qu'un VL-REMOVE-IF (ou -IF-NOT) appliqué pour chaque élément de ltype ?

[Patrick_35]

Salut

 

Mais est-ce que, par exemple, bv:lst-type est plus rapide ou plus puissant qu'un VL-REMOVE-IF (ou -IF-NOT) appliqué pour chaque élément de ltype ?

 

Un petit coup de benchmark

(defun pa:lst-type (lst ltype flag)
 (if flag
   (vl-remove-if-not '(lambda(x)(member (type x) ltype)) lst)
   (vl-remove-if '(lambda(x)(member (type x) ltype)) lst)
 )
)

 

(benchmark '((bv:lst-type '(1.0 "Un" 2 toto) '(SYM REAL) T)(pa:lst-type '(1.0 "Un" 2 toto) '(SYM REAL) T)))

Elapsed milliseconds / relative speed for 16384 iteration(s):

 

(PA:LST-TYPE (QUOTE (1.0 "Un" 2 TOTO...).....1609 / 2.48

(BV:LST-TYPE (QUOTE (1.0 "Un" 2 TOTO...).....3984 / 1.00

(benchmark '((bv:lst-type '(1.0 "Un" 2 toto) '(SYM REAL) nil)(pa:lst-type '(1.0 "Un" 2 toto) '(SYM REAL) nil)))

Elapsed milliseconds / relative speed for 16384 iteration(s):

 

(PA:LST-TYPE (QUOTE (1.0 "Un" 2 TOTO...).....1579 / 2.45

(BV:LST-TYPE (QUOTE (1.0 "Un" 2 TOTO...).....3875 / 1.00

 

@+

[(gile)]

Salut,

 

Je suis mal placé pour critiquer, j'ai, de mon côté, largement ré-inventé la roue (ici).

Je pense néanmoins que ça reste un très bon exercice.

[Tramber]

De mon côté, je n'ai rien à dire :

J'ai mis 10 ans [véridique] avant d'enfin utiliser la forme

(apply
   'append
   (mapcar

... dans les cas adaptés.

 

J'admire ar-1:n cependant.

 

Tiens,

Je vais chercher (benchmark l), jamais essayé. dites-moi s'il n'y a pas une version reconnue et usitée par tous....

[Patrick_35]

Je vais chercher (benchmark l), jamais essayé. dites-moi s'il n'y a pas une version reconnue et usitée par tous....

Je l'ai mis à disposition

 

@+

[Tramber]

Yo ! Merci.

Je l'avais déjà trouvée, l'auteur est Michael Puckett et elle constitue bien une référence connue de tous !

[VDH-Bruno]

Bonsoir,

 

C'est vraiment du pur Autolisp !

 

Oui, je me doutais bien en postant qu’il y aurait plus performant avec du VL-REMOVE-IF (ou -IF-NOT) ou autres, et je ne prend pas du tout cela comme une critique bien au contraire.. :D (c’est la confrontation à d’autres codes qui font progresser). Les fonctions VL je m’en sers très peu, car je les ai juste parcourus et pas encore vraiment trituré (sauf deux ou trois), elles ne sont donc pas encore bien toutes acquises.

 

De plus je suis dans une phase d’écriture de codes et dans ces moments j’aime bien aller au plus rapide pour aboutir et vérifier mes hypothèses et raisonnements (je prends pas le temps de chercher dans les fonctions que je ne me suis pas encore approprié), il n’y a qu’après avoir maîtrisé mon sujet (ou que je n’ai pas abouti) que je regarde si il n’y avait d’autres façons de faire en me documentant pour m’améliorer.

 

Pour bv:lst-type (en plus d’être un bon exercice) c’était l’occasion pour moi de mettre en pratique une petite explication donné ici par Patrick_35 sur le or et le and.

 

Sinon ces quelques fonctions notamment ar-1:n ( dont on devrait prochainement trouver la version fonctionnel) me rendent de grands services dans un fichier dans lequel je me livre à quelques élucubrations (ou jeux) sur les possibilités des fonctions command, vl-cmdf, getcname et de la variable LASTPROMPT.

 

De tous ce fatras (ou fonctions gadgets) il devrait malgré tout sortir une fonction getcoption qui (comme sa parente getcname pour les commande AutoCAD) renvoi les options de commande internationalisé, et ce lorsque j’aurais un peu de disponibilité (et/ou fini de jouer :mad: ) pour qu’elle puisse avoir complètement le comportement voulu..

 

A+

 

 

 

 

[Edité le 20/4/2011 par VDH-Bruno]

[Tramber]

vvvouuuu.

Joli objectif !

Impatient de voir.

 

Concernant le début de ta réponse, je m'en doutais un peu :cool:

 

Hoppla gueiss

[VDH-Bruno]

Bonsoir Tramber

 

Joli objectif !

Impatient de voir.

 

Soit pas trop impatient (humour), bien que la fonction getcoption tourne à quelques exceptions près (sur lesquelles je dois réfléchir pour les contourner de façon à la rendre publiable), je me suis déjà dispersé sur d’autres notamment une qui retourne toute les options de commandes possibles pour le niveau en cours (c’est gadget mais ça m’amuse), on y voit toute les incohérences dans les invites de commande et l’absence de rigueur dans les options de commande possibles..

 

A titre d’exemple (un parmi d’autres) en réponse à ma fonction :

(op:toutes '("_pline" "0,0" "LA" "3" "" "100,0" "") "LA")

On explore toute les options de commande possible après l’instruction :

(vl-cmdf "_pline" "0,0")

Et ma fonction retourne

("TT" "REPERAGE" "LONGUEUR" "LIGNE" "LARGEUR" "DEMI-LARG" "ARC")

 

Pour les valeurs de retour :

TT (c’est l’instruction d’activation du repérage temporaire) et REPERAGE on comprend.

LONGUEUR, LARGEUR, DEMI-LARG, ARC rien à dire, c’est les options classique.

LIGNE tiens, je ne savais pas que c’était une option possible et pour cause l’instruction n’est reliée à aucune action !!!

 

Pour AutoCAD à ce stade l’invite propose :

Spécifiez le point suivant ou [Arc/Demi-larg/LOngueur/annUler/LArgeur]:

L’absence de l’option de command ANNULER en retour de la fonction montre le peu de rigueur de l’invite, car comment annuler un segment qui n’existe pas à ce stade (c’est comique), surtout qu’ils y avaient bien pensé chez Autodesk pour l’instruction CLORE.

 

Et des fonctions aussi gadget, j’en ai plein la tête et hélas trop peu de temps à y consacrer..

Cordialement,

 

[Tramber]

"TT" n'en est pas à sa première nuisance. Je n'ai plus le souvenir exact mais.....

 

LIGNE est une option du mode ARC. Je ne m'étonne donc pas à 100%.

(bien que j'ignore tout du fonctionnement de la tambouille en cours).

ANNULER est peut-être implémenté d'une façon très spéciale qui les oblige à le présenter...

... et peut-être que ca nous dépasse !?

 

Je vois que tu ne retournes pas les valeurs Majuscules....