VDH-Bruno

Bonsoir, Tramber : Je te remercie d’avance pour l’aide que ton expérience pourra m’apporter, pour répondre simplement aux questions que tu souléves : L’enjeu est justement la compréhension (comme l’a visiblement compris (gile)), si j'en passe par là, c’est pour moi la façon que j’ai d’apprendre (sinon ça rentre pas dans la tête). Non, je ne pense pas à moins que je repasse sur une LT ou qu’à l’avenir mon épanouissement personnel /professionnel me porte vers d’autres horizons.. Présentement je me consacre à l’étude du Lisp du mieux que je peux, et si cela a des retombées bénéfiques pour des membres de ce forum ou pour mon entourage professionnel c'est tant mieux :D . (gile) Merci pour la précision sur les fonctions vl-, et pour tes liens ( EVERY évidemment que ça me parle maintenant :cool: ) surtout le dernier lien. Il tombe bien à propos car je cherche actuellement à retravailler une routine de tri, routine que je pense construire sur les fonctions min et max (histoire de me faire la main..) Pour plus ou moins conclure ce sujet qui à bien dérivé de son intitulé. Avec vl-some, je suis arrivé à l’écriture suivant ((gile) c’est comme cela que tu l’avais vu ?): (not (vl-some 'zerop nlst)) Comparons les deux fonctions suivantes : (Pour le fun histoire de mettre en pratique mes connaissances récemment acquises): (defun vl-some-0 (nlst) (not (vl-some 'zerop nlst)) ) ;_ Fin de defun (defun apply-0 (nlst) (/= (apply '* nlst) 0) ) ;_ Fin de defun Comparaison sur une liste de 20 nombres (repeat 20 (setq nlst (cons 1.0 nlst)) ) ;_ Fin de repeat (benchmark '((apply-0 nlst) (vl-some-0 nlst))) La différence n’est pas vraiment significative, passons donc au niveau supérieur comparaisons sur 200 éléments (setq nlst nil) (repeat 200 (setq nlst (cons 1.0 nlst)) ) ;_ Fin de repeat (benchmark '((apply-0 nlst) (vl-some-0 nlst))) A la ça devient un peu plus significatif, alors poussons encore plus loin là comparaison sur 2000 éléments (setq nlst nil) (repeat 2000 (setq nlst (cons 1.0 nlst)) ) ;_ Fin de repeat (benchmark '((apply-0 nlst) (vl-some-0 nlst))) Et là ça l’écart devient fabuleux, mais attention aux conclusions trop hâtives car nous n’avons comparer que des listes n’ayant pas de zéro et qui ont été aux termes de leurs évaluations. Car maintenant si on compare la même liste avec un 0 en début, on obtient : (setq nlst (cons 0 nlst)) (benchmark '((apply-0 nlst) (vl-some-0 nlst))) Hé oui car vl-some interromps son évaluation dés que la condition d’évaluation retourne T (d’après l’aide) ce qui pour ce cas de figure l’optimise grandement. Pour finir de s’en convaincre il suffit de faire l’opération inverse avec un 0 de fin. (setq nlst (reverse nlst)) (benchmark '((apply-0 nlst) (vl-some-0 nlst))) En conclusions Pour évaluer la pertinence de l’une ou l’autre de ces fonctions, il faut prendre en considération : - La longueur de la liste à traiter. - Estimer la probabilité de la présence de 0 dans la liste, ainsi que ça position. (Qui peut être considéré comme médiane sans indication contraire). Je vous avais prévenu c’étais pour le fun.. ;) si vous souhaitez continuer la comparaison libre à vous, à mon niveau ça me suffit.. Je peux voguer vers d'autres sujets d'étude.. :D Bonne nuit à tous !!!

Bonjour, Patrick_35 : J’ai à la suite de mes recherches sur le forum, eu l’occasion de lire la pertinence de tes messages, sache que des encouragements de ta part sont appréciés à leurs juste valeurs. Hélas non je doute fort.. Je pars de très loin et pour les raisons suivantes : - Je n’ai aucune culture en programmation, il m’a fallu 2 bonnes heures pour comprendre que : (and T T) renvoie T (and T nil) renvoie nil (and nil nil) renvoi nil - Je n’ai pas accès au "support" anglophone (et trop peu de temps pour tout traduire sous google) donc le vl-machinchose, je me le garde pour plus tard, sauf lorsqu’il est distillé à petite dose par (gile) (ou d’autres). Heureusement que j’avais sauvegardé les fichiers d’aide de la version 14 avec le bon vieux AutoLISP. - Pour l’instant je tourne sur une version pleine mais rien n’est sur pour l’avenir (j’ai déjà eu le cas par le passé). Le développement ne fait pas parti de mes attributions professionnels, et c’est pas dans la culture de l’entreprise. - Je n’ai pas non plus de connections internet au travail, je ne me forme que en dehors.. et je ne peux consacrer au lisp que 15 à 20mn le midi et tout au plus 1 à 2 heures le soir ( lorsque les enfants sont au lit). - Je n’ai plus 20 ans (mais quasiment le double), un niveau d’étude moyen et quelques lacunes en mathématiques (notamment sur les matrices, j’ai cru lire que toi aussi en espérant que tu les as comblé depuis..). Pour contrebalancer: j’ai pour moi la chance d’être curieux et le désir de toujours apprendre.. Tu vois pour le dépassement vous n’avez pas à vous soucier et Elpanov Evgeniy non plus ;) (gile) : un grand MERCI, pour ta ligne de code (c’est de l’or pour moi) : A opposer à mon horrible: Ligne qui a été très formatrice à plus d’un titre, j’ai saisi le principe que tu as pointé et qui m’avait échappé jusque là dans l’imbrication de apply et mapcar (conditionné que j’étais par des exemples précédemment étudier). Pour développer : J’avais bien pointé la faiblesse du (mapcar 'zerop ‘(0 0 0 0)) qui retourne (T T T T) Et qui une fois soumis à (apply '= ‘(T T T T)) retournait T J’avais bien tenté avant l’exécution de apply, mapcar d’ajouter nil dans lst (avec append au lieu de cons) pour finalement m’apercevoir que append n’y arrivait pas et que de toute façon zerop ne pouvait évaluer nil. C’est pourquoi j’avais laborieusement introduit la condition du (not (zerop (car lst))) en sortie de boucle, j’avoue n’avoir à aucun moment pensé introduire une expression entre le passage de mapcar à apply, chose que tu as réalisé avec pertinence au moyen de (cons nil ‘(T T T T)) --> (nil T T T T). En résumé de cette leçon, je retiendrai : En 1 - Ne pas négliger cons (constructeur de liste) Que j’avais à tord cantonné au rôle de constructeur de paire pointée au détriment de append (ajouter liste..) car : Ou Fonctionne bien alors que : Ou Pas du tout, et à bien y réfléchir c’est tout à fait normal, (c’est la mise en évidence qu’ils n’ont pas la même vocation). En 2 - Sur l’emploi de apply mapcar Même si on aperçoit souvent la forme : (apply ‘expression2 (mapcar ‘expression1 liste1 …)) (apply ‘expression 2 liste2) résultat Si le besoin d’introduire une troisième expression (ou +) ce fait sentir, on peut toujours tenter : (apply ‘expression2 (expression3 (mapcar ‘expression1 liste1 …))) (apply ‘expression2 (expression3 liste2)) (apply ‘expression2 liste3) résultat Au cas où il n’y avait pas moyen d’exécuter l’ expression3 avant l’appel de apply mapcar. Avant d’aller l’inclure en sortie de boucle comme dans je l’avais fait. En généralisant le raisonnement: Toujours garder à l’esprit qu’une action est possible à chaque niveau d’imbrication de parenthèses. Je trouve tout cela très puissant même si je ne peux faire le parallèle avec d’autres langages.. En 3 – D’une manière générale essayer de garder un regard critique sur les lignes codes écrites par d’autres, au risque de se laisser formater par ces dernières, même si j’avoue que cela reste très instructif. Avec mes remerciements VDH EDIT: J’édite mon message pour préciser une chose pour ceux qui m’aurais suivi dans mes élucubrations entre append & con Bien que nil soit à la fois une liste et un atome. Pour ajouter nil dans une liste autrement qu’avec cons La syntaxe suivante : (append nil lst); retourne (1 2 3 4) S’évalue car nil est une liste mais n’ajoute pas nil à la liste. Littéralement on pourrait traduire par ajouter nil (rien) à la liste ce que fait l’interpréteur La bonne syntaxe est la suivante : (append (list nil) lst); retourne (nil 1 2 3 4) Qui revient à dire ajouter la liste nil à la liste. Même si je démonte un peu mon argumentaire précédent, je persiste dans mon affirmation cons et append n’ont pas la même vocation cons pour ajouté un élément append pour ajouter une liste Même si : (append (list élément) liste) < = > (cons élément liste) ; ajoute un élément en début de liste Et que : (append liste (list élément)) < = > l’inverse de cons ; ajoute un élément en fin de liste Méfiance tout de même avec les paires pointées Exemples: (append (list 5) '(2 3 4)) ;retourne (5 2 3 4) (cons 5 '(2 3 4)) ;retourne (5 2 3 4) (append (list 5) '(2 . 4)) ; erreur: liste incorrecte: 4 (cons 5 '(2 . 4)) ; retourne (5 2 . 4) [Edité le 21/10/2010 par VDH-Bruno]

Bonsoir, Je vois que tu as bien saisi que c'était un exercice sur l'emploi de mapcar & apply "combiné". Effectivement c'est plus conscis (d'ailleur je médite déjà dessus :cool: ) Mais en dehors de l'exercice (et de façon concise), je l'avais plutôt écris comme cela: (/= (apply '* lst) 0) Ignorant tout de l'existance de vl-some (Ps: Merci pour la fenêtre de suivi de l'éditeur, j'étais totalement passé à côté..)

Un grand merci (gile) pour ce complément de réponse, auquel je vais porter la plus grande attention. Très intéressante la voie que tu m’ouvre pour évaluer la performance entre différentes fonctions, j’avoue avoir déjà aperçu dans plusieurs post l’emploi de ce benchmark sans mis être attardé d’avantage. Personnellement si je n’avais pas persévéré et abouti avec foreach, j’aurais tenté quelque chose avec apply mapcar, histoire de ne pas végéter davantage avec mes perpétuelles boucles que sont while & repeat (plus facile d’accès pour un début). Même si pour sortir quelque chose avec l’imbrication de ces fonctions cela me demande encore beaucoup de tâtonnements, je sens que cela commence à venir, pour preuve mon dernier code : (and (apply '= (mapcar 'zerop lst)) (not (zerop (car lst)))) Retourne T si tous les nombres de la liste sont different de 0 Retoune nil si un des nombres vaut 0. La ou je bloque encore dans mon évolution, c’est lorsque j’utilise lambda avec plus d’un argument et les fonctions précitées. J’ai pas encore compris ou situer mon blocage, je n’ai plu l’exemple en tête.. (faudrait que je vois d’avantage de codes de ce type, (gile) au passage si tu me lis..). Il reste aussi la récursivité, thème sur lequel je n’ai pas encore pris la peine de me pencher sérieusement pour bien en comprendre la logique (chaque chose en son temps). J’ai bien essayé une fois d’en tracer une avec la fonction correspondante : (defun fac (Nbr) (if (= 1 Nbr) 1.0 (* Nbr (fac (1- Nbr))) ) ) Teste de tracé de la fonction fac Résultat peu probant, visiblement je n’ai pas encore tout saisie à l’emploi de la fonction trace, il faudra que je teste d’avantage son fonctionnement avant d’espérer allez plus loin. Sinon j’ai bien aimé ta réflexion sur l’élégance au détriment de la performance ( je me la note dans un coin de mon esprit pour plus tard..), car actuellement je n’en suis pas encore aux millisecondes. Disons qu’à mon niveau, j’essais plutôt de traquer les redondances, les variables inutiles ainsi que les parenthèses superflues, en jouant sur l’imbrication de mes fonctions.. Et je m’aperçois avec joie que cela est on ne peut plus formateur.. Voilà aujourd’hui ma définition de l’élégance et quant j’y arrive c’est ma récompense :D . (C'est sans doute cela qui t'auras laissé penser que j'étais "pas mal dégrossi", tu vois pas tant que cela finalement) Amicalement VDH

Bonsoir, Voici, ma première "vrai" routine Lisp, tout d’abord je tiens à remercier les membres de ce forum qui par leurs interventions ici et là ont grandement contribué à sa réalisation. Le principe est simple le programme demande de sélectionner une polylignes (optimisées), et renvoi deux traitement différent suivant le type de polylignes sélectionnées (traitement correspondant à mes besoins et à l’organisation de mes dessins). Après chargement Taper qlwp Si vous sélectionné une polyligne ouverte (c.a.d. code DXF 70 à 0) Il vous sera retourné en résultat l’ensemble de tous les segments des polylignes de même calque, couleur et de même espace que l’entité sélectionné. Les longueurs identiques seront comptabilisées et classées par ordre croissant. Si vous sélectionné une polyligne fermée (c.a.d. code DXF 70 à 1) Il vous sera retourné en résultat la longueur du plus grand segment composant chaque polyligne de même calque, couleur et de même espace que l’entité sélectionné. Les longueurs identiques seront comptabilisées et classées par ordre croissant. Voilà j’ai bien conscience que les résultats, ainsi que le code est perfectible, mais je m’en tiendrai là pour le moment. Car les résultats retournés semblent tenir la route pour mon organisation de dessin et pour l’utilité que j’en ai (Au vu d’un nombre très restreint de teste). En espérant que cela puisse profiter à d’autres. Amicalement VDH Le code ;; ==================================================================== ;; qlwp-v2.lsp by Vandenheede Bruno ;; le 12/10/2010 ;; Réalise un quantitatif sur les lwp sélectionnées ;; -------------------------------------------------------------------- ;; Variables ;; Ent -> Liste (codes dxf de l'entité LWP sélectionné) ;; Sel -> Jeu de sélection (des éléments à traiter) ;; N -> Entier (Compteur) ;; LstLong -> Liste (Liste de toutes les Longueurs) ;; LongEnt -> Liste (Liste de Longueur pour un élément) ;; Routine -> USUBR (Mémorise la routine de traitement à lancer) (defun c:qlwp (/ Ent Sel N LongEnt LstLong Coul Aff Element Descr File listseg longseg tri Tri&Comp ) (vl-load-com) ;; ==============Déclaration des Sous Programmes ==================== ;; ================================================================== ;; Routine Liste la longueur de tous les segments de LWP ;; Argument -> Un Non d'entité ;; Retourne -> Une Liste (tous les segments de la LWP) ;; ------------------------------------------------------------------ ;; Observation: ;; Je ne juge pas nécessaire l'ajout du 1er sommet à la fin de la liste ;; dans le cas d'une LWP close, le faire pour une fonction plus général. ;; De même je n'ai pas exclus du traitement les polylignes avec arc alors ;; que la fonction ne gère pas ce cas (à traiter dans le cas d'une fonction ;; plus général). (defun listseg (NomEnt / LstPt x Long LstLong) ;; Liste les sommets de la LWPOLYLIGNE (code cadxp) (setq LstPt (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget NomEnt) ) ;_ Fin de vl-remove-if-not ) ;_ Fin de mapcar ) ;_ Fin de setq ;; Tant qu'un sommet suit mesurer la distance entre le 1er et 2nd sommet (while (cdr LstPt) (setq Long (distance (car LstPt) (cadr LstPt))) ;; Si la Liste de long existe (if LstLong ;; Alors ajouté la longueur du nième segment (setq LstLong (append LstLong (list Long))) ;; Sinon crée une list avec le 1er élément calculer (setq LstLong (list Long)) ) ;_ Fin de if (setq LstPt (cdr LstPt)) ) ;_ Fin de while LstLong ; Valeur de retour ) ;_ Fin de defun ;; ================================================================== ;; Routine d'extration du segment de lwp le plus long ;; Argument -> Un Non d'entité ;; Retourne -> Une liste (longueur de plus grand segment) ;; ----------------------------------------------------------------- ;; Observation: ;; Je n'ai pas exclus pas du traitement les polylignes avec arc ;; alors que la fonctionne gère pas ce cas (à traiter dans le ;; cadre d'une fonction plus général). ;; Rq (> 10 nil) retourne T alors que (> 10 T) erreur (defun longseg (NomEnt / ListPt x Long) ;; Liste les sommets de la LWPOLYLIGNE (setq ListPt (mapcar 'cdr (vl-remove-if-not '(lambda (x) (= (car x) 10)) (entget NomEnt) ) ;_ Fin de vl-remove-if-not ) ;_ Fin de mapcar ) ;_ Fin de setq ;; Ajout du 1er sommet en fin de liste de point (setq ListPt (append ListPt (list (car ListPt)))) ;; Tant qu'un sommet suit mesurer la distance entre le 1er et 2nd sommet (while (cdr ListPt) (if (> (distance (car ListPt) (cadr ListPt)) Long) (setq Long (distance (car ListPt) (cadr ListPt))) ) ;_ Fin de if (setq ListPt (cdr ListPt)) ) ;_ Fin de while (setq Long (list long)) ; Valeur de retour ) ;_ Fin de defun ;; ================================================================== ;; Trie dans l'ordre croissant et compte les identiques ;; Argument -> Liste de réel ;; Retourne -> Liste croissante de réel ((N1 . L1) (N2 . L2) etc..) ;; ------------------------------------------------------------------ ;; tri (Evgeniy Elpanov) ;; comme vl-sort mais sans supprimer les doublons (defun tri (lst fun) (mapcar (function (lambda (x) (nth x lst))) (vl-sort-i lst fun) ) ;_ Fin de mapcar ) ;_ Fin de defun ;; Tri&Comp modifié by (gile) ;; http://www.cadxp.com//modules.php?op=modload&name=XForum&file=viewthread&fid=100&tid=29749 (defun Tri&Comp (lst / sub) (defun sub (lst n) (if (cadr lst) (if (equal (car lst) (cadr lst)) (sub (cdr lst) (1+ n)) (cons (cons n (car lst)) (sub (cdr lst) 1)) ) ;_ Fin de if (list (cons n (car lst))) ) ;_ Fin de if ) ;_ Fin de defun (sub (tri lst '<) 1) ) ;_ Fin de defun ;;; ==================== Fin Sous Programmes ====================== ;;; =============== Début du Progamme Principal =================== ;; Sélection du type d'élément à métrer (setq Ent (entget (car (entsel "Pointer une des polylignes à métrer: ")) ) ;_ Fin de entget ) ;_ Fin de setq ;; Vérification du type d'entité sélectionné (if (= (cdr (assoc 0 Ent)) "LWPOLYLINE") ;; Si c'est une LWPOLYLINE continuer l'execution du programme (progn (setq Sel (ssget "X" ; Crée le jeu de sélection (list '(0 . "LWPOLYLINE") (assoc 8 Ent) (if (cdr (assoc 62 Ent)) (setq Coul (assoc 62 Ent)) (setq Coul '(62 . 256)) ) ;_ Fin de if (assoc 410 Ent) ) ;_ Fin de list ) ;_ Fin de ssget N 0 ; Initialise un compteur ) ;_ Fin de setq ;; Visualise la sélection par "grip" (sssetfirst nil Sel) ;; Si la lwp (Ent) de référence et fermé (70 . 1) (if (= (cdr (assoc 70 Ent)) 1) ;; Appliquer USUBR: longseg (liste le + grd seg de chaque lwp) (setq Routine longseg) ;; Sinon USUBR: listseg (liste tous les segments de lwp) (setq Routine listseg) ) ;_ Fin de if ;; Parcours la sélection élémt par élémt (tant qu'il y en a) (while (ssname Sel N) (setq LongEnt (Routine (ssname Sel N))) ;; Si la Liste de long existe (if LstLong ;; Alors ajouté la liste du nième élément (setq LstLong (append LstLong LongEnt)) ;; Sinon créé une liste avec la 1ère liste calculer (setq LstLong LongEnt) ) ;_ Fin de if (setq n (1+ n)) ; passe à l'élément suivant ) ;_ Fin de while ;; Affichage provisoire avant traitement des résultats (princ "\n") (princ "\n Liste de toutes les longueurs mesuré :") (princ "\n") (princ LstLong) (princ "\n") ;; Affichage des résultats ;; Code inspiré et adapté du lisp long_line by (gile) (setq Aff "") (setq Descr (strcat "\nCalque.................\t" (cdr (assoc 8 Ent)) "\nCouleur................\t" (itoa (cdr Coul)) "\nNombre de segments.....\t" (itoa (length LstLong)) "\nLongueur total.........\t" (rtos (apply '+ LstLong)) "\nLongueur moyenne.......\t" (rtos (/ (apply '+ LstLong) (length LstLong))) "\n" "\nDétail des résultats...\t" (foreach Element (Tri&Comp LstLong) (setq Aff (strcat Aff "\n\t" (itoa (car Element)) "\t" (rtos (cdr Element)) ) ;_ Fin de strcat ) ;_ Fin de setq ) ;_ Fin de foreach ) ;_ Fin de strcat ) ;_ Fin de setq (textscr) (princ Descr) (initget "Oui Non") (if (= (getkword "\nEnregistrer dans un fichier ? [Oui/Non] < Non >: " ) ;_ Fin de getkword "Oui" ) ;_ Fin de = (progn (setq File (open (getfiled "Créez ou sélectionnez un fichier" "" "xls" 33) "a" ) ;_ Fin de open ) ;_ Fin de setq (princ Descr File) (close File) ) ;_ Fin de progn ) ;_ Fin de if (graphscr) ) ;_ Fin de progn ;; Sinon quitter en affichant un message d'alert (princ "\nL'élément sélectionné n'est pas une polyligne optimisée !" ) ;_ Fin de princ ) ;_ Fin de if (princ) ; Termine silencieusement ) ;_ Fin de defun ;; ================================================================== Précision : Dans le cas de longueurs très sensiblement égal (d’une précision supérieur à celle de l’affichage), les éléments sont comptés séparément même si à l’affichage ils semblent avoir une longueur identique. Je m’en accommode pour le moment, peut être une amélioration futur auquel cas il faudra que je réfléchisse à la précision que je veux atteindre dans l’exploitation des résultats. [Edité le 12/10/2010 par VDH-Bruno]

Re-bonsoir, Enfin!!! J’ai trouvé, comme je ne voulais pas en rester là, j’ai insister un peu plus dans mes testes.. et la formulation donné par Bred m’a indiqué la voie.. Je vous livre mes lignes de codes : (setq lst "") (foreach element '((1 . 9.55) (2 . 9.75) (2 . 10.0) (1 . 11.0) (2 . 11.25) (1 . 11.50) ) (setq lst (strcat lst "\n" (itoa (car element)) "\t" (rtos (cdr element)) ) ) ) Renvoie Niveau performance je sais pas ce que ça vaut, mais esthétiquement y a pas photo ça fait tout de même plus élégant ;) .

Merci, pour vos réponses à tous les deux. Mais dans ma hâte d’aboutir, j’ai pris une autre option un peu plus classique avec une boucle while, même si à titre personnel j’aurais bien aimé faire quelque chose avec foreach (histoire d’enrichir un peu plus mon vocabulaire Lisp). (setq Affich "") (setq LstTri '((1 . 9.55) (2 . 9.75) (2 . 10.0) (1 . 11.0) (2 . 11.25) (1 . 11.50) ) ) (while LstTri (setq Element (car LstTri) LstTri (cdr LstTri) Affich (strcat Affich "\n" (itoa (car element)) "\t" (rtos (cdr element)) ) ) ) Renvoie Ce à quoi je voulais aboutir en employant la fonction foreach

Bonjour, En ce moment je finalise mon premier "programme" (que j’espère pouvoir publier prochainement), j’en suis au stade de l’affichage (exploitation) des résultats. Actuellement je suis arrivé à ce stade : (foreach element '((1 . 9.55) (2 . 9.75) (2 . 10.0) (1 . 11.0) (2 . 11.25) (1 . 11.50) ) (print element) ) Ce qui me retourne En me doublant la dernière valeur qui correspond à la valeur de renvoi de la fonction foreach (Même si je n’en suis pas très heureux, c’est pas le point qui me préoccupe le plus) La séquence de code qui me pose le plus de problème et la suivante : (foreach element '((1 . 9.55) (2 . 9.75) (2 . 10.0) (1 . 11.0) (2 . 11.25) (1 . 11.50) ) (strcat "\n" (itoa (car element)) "…….\t" (rtos (cdr element))) ) Le code ci dessus me renvoie la dernière expression évaluée qui me semble correcte Ma question est la suivante : (Je vous épargne toute les séquences de codes que j’ai testés) Comment formuleriez vous (de façon élégante) l’expression : (strcat "\n" (itoa (car element)) "\t" (rtos (cdr element))) De façon à stocker le déroulement effectué par foreach dans une variable (j’espère être suffisamment explicite). Pour info : par la suite je pense offrir la possibilité d’enregistrer le résultat sous excel comme le fait la routine long_line de (gile). Merci, Ps : Bien sur la liste de valeurs est fourni à titre d’illustration dans ma version final ce sera une variable. [Edité le 12/10/2010 par VDH-Bruno]

Merci, à tous les deux pour votre retour. Cordialement,

Bonsoir, A la lecture de ce sujet, et en faisant un parallèle avec le code donné pour la fonction *error*. Ai je bien tout compris, si j’écris : Etape 1 (defun c:cube (/ n) (if (setq n (getreal "\nSaisissez un nombre: ")) (princ (strcat (rtos (* n (sqr1 n))) " est son cube!") ) ) (princ) ) (defun sqr1 (nbr) (* nbr nbr)) La fonction sqr1 existe en dehors de la commande cube (un peu comme une variable globale), Teste 1 : Au risque d’écraser une fonction de même nom, mais ayant une autre fonction pour un autre programme. Etape 2 Le fait de l’inclure dans le même bloc de parenthèse ne changeant rien à l’affaire, (defun c:cube (/ n) (defun sqr2 (nbr) (* nbr nbr)) (if (setq n (getreal "\nSaisissez un nombre: ")) (princ (strcat (rtos (* n (sqr2 n))) " est son cube!!") ) ) (princ) ) Teste 2 : Etape 3 Pour éviter cela je dois la déclarer dans ma fonction principal (au même titre que mes variables) pour ne lui octroyer qu’une existance local. (defun c:cube (/ n sqr3) (defun sqr3 (nbr) (* nbr nbr)) (if (setq n (getreal "\nSaisissez un nombre: ")) (princ (strcat (rtos (* n (sqr3 n))) " est son cube!!!") ) ) (princ) ) Teste 3 : Etape 4 Et dans l’hypothèse ou je voudrais en faire une fonction réutilisable (à inclure dans une bibliothèque de fonctions) il serait préférable de la préfixer avec mes initiales un peu comme les fonctions vl-xxx (defun bv-sqr (nbr) (* nbr nbr)) Au cas ou d’autre n’aurais pas eu la même délicatesse dans l’écriture de leurs programmes.. Bon, je pense avoir bien saisie le principe, en attente d’une confirmation ou complément.. Cordialement (Ps : Je ne vois pas bien la différence d’intérêt entre l’écriture 1 & 2, que je retrouve dans beaucoup de programme) [Edité le 8/10/2010 par VDH-Bruno]

Bonjour, Je me réponds à moi-même, concernant ma réflexion sur les 2 orthographes possible de nil Pour ce faire, j’ai évalué les expressions suivantes : Les deux écritures, sont reconnues comme appartenant au type nil qui est à la fois une liste (donc évaluable pour cdr et car) et un atome. Pour conclure et résumer: les écritures possibles de nil sont les suivantes : Ps : N’ayant plus de questions sur ce thème, je le considère comme résolu :) (et passe enfin à la suite.. :cool: )

Bonjour et bon apéttit, Juste une chose avant de valider le sujet comme totalement résolu, voilà en méditant le paradoxe du nil évoqué entre Tramber et (gile) : Une dernière réflexion m’est apparue, sur ces 2 différentes orthographes possibles : La première qui me semble juste d’après les définitions qu’en donnent l’aide : C’est la suivante qui me semble un peu plus suspect : Bizarre d’un premier abord j’aurais plus vu une réponse du type : ; erreur: type d'argument incorrect: blabla Sinon pour illustrer le paradoxe évoqué par (gille), je me suis servi des fonctions précédemment cités et je pense m’en être plutôt bien sortie. Illustration : Prenons une liste : ‘(1 2 3 4 5) Extrayons son premier élément : (car ‘(1 2 3 4 5)) retourne 1 Soumettons-le à la fonction length : (length (car ‘(1 2 3 4 5))) retourne ; erreur: type d'argument incorrect: listp 1 Normal car length réclame une liste en argument alors que : (type 1) retourne INT (Un nombre entier) (atom 1) retourne T (Evaluer comme atom par l’interpréteur) Par analogie avec une liste vide ‘() : (cdr ‘()) retournerai nil (un nil de type liste) (car ‘()) retournerai nil (un nil de type atome) Ce qui se vérifierai par : (listp (cdr ‘())) retourne T (atom (car ‘())) retourne T Si comme ne l’avais précisé (gille) (type nil) retourne nil (atom nil) retourne T (listp nil) retourne T Continuons malgré tout l’analogie et soumettons ces expressions à length : (length (cdr ‘())) retourne 0 Normal je soumets une liste vide, alors que : (length (car ‘())) retourne 0 (et non une erreur d’argument) A comparer avec l’expression vu précédemment : (length (car ‘(1 2 3 4 5))) retourne ; erreur: type d'argument incorrect: listp 1 Ceci illustre parfaitement à mon sens le paradoxe du nil à la fois atome et liste, sans différentiation de type entre un 'nil atome' et 'un nil liste'. Merci à ceux qui ont eu le courage de me lire [Edité le 7/10/2010 par VDH-Bruno] [Edité le 7/10/2010 par VDH-Bruno]

Ravi que vous aillez compris mes questions.. Tramber : Merci, et j’ignorais pour le (car nil) qui renvoie nil (bizarrement je n’avais pas encore testé :cool: ) mais cela me pose moins problème de compréhension. (gile) : Ta réponse me semble on ne peut plus clair, bien que je ne me sente plus trop réceptif pour ce soir. Je regarderai plus dans le détail demain avant de passer le sujet en résolu. Pour vl-position merci également. J’en profite au passage pour te remercier ici (car j’ai pas souhaité polluer le post) pour ce sujet que je trouve excellent. Il m’aide beaucoup, je bute encore (mais je m’accroche) sur les chalenges vers lesquels tu m’as orienté.. Bonne soirée à tous

Bonsoir, Voilà à l’occasion d’un petit exercice sur l’étude de quelques fonctions LISP, je m’aperçois que certaines notions ne sont pas encore totalement maitrisé concernant les symboles variable et autres expressions.. et ce malgré la lecture attentive de ce support de (gille). Je vais essayer d’être le plus claire possible, j’espère ne pas vous perdre en route car je ne cerne pas facilement la notion qui me fait défaut (en espérant que cela soit plus évident pour vous). L’exercice auquel je me suis livré : Ecrire une fonction symétrique de la fonction nth Dans mon esprit et pour simplifier elle ne retournerait : que la position de la première occurrence de l'élément spécifié dans la liste, en comptant à partir de zéro. Même si mon propos ne porte que sur l’interprétation des résultats je vous livre le code : (defun s-nth (E Lst) (if (member E Lst) ; si (member E Lst) est T continuer, sinon renvoi nil (- (length Lst) (length (member E Lst))) ) ) Pour que je puisse considérer la fonction comme symétrique, il faudrait qu’elle puisse réagir comme sa "parente", à savoir : Alors testons : Jusque pas de problème poursuivons : Problème les fonctions passe mais pas les symboles, la fonction n’est pas à proprement parlé symétrique, c’est pas un drame j’affinerai plus tard, pour l’instant j’analyse.. (ou du moins je tente) Ce que je constate : Mon code repose sur l’utilisation de member, alors je teste : Je suis content mais il n’y avait pas de raison que ce soit différent, poursuivons : Je maîtrise pas encore bien toute les subtilités de langage, alors j’essaye cette forme: Ca passe je suis heureux, donc re-teste de ma fonction avec cette syntaxe. Super je suis content ma fonction est bien symétrique contrairement à ma première affirmation, par contre je découvre que je maîtrise pas encore bien toute la compréhension du quote ( ‘), Vous allez me dire ou est le problème, j’ai trouvé la bonne syntaxe, oui mais c’est par tâtonnement (ça devrai plus du moins pas sur ces notions) et c’est gênant pour qui veut prétendre allez plus loin.. (apply mapcar etc.…) Alors je continu à expérimenter en attribuant cette fois ci des valeurs à mes symboles (ou variable, si je ne me trompe pas): Et je fini par me mélanger les pinceaux et je n’arrive plus à interpréter clairement mes résultats, peut être qu’une bonne nuit de sommeil et la relecture de mon support me sera profitable ou mieux un avis éclairé pour me recadrer… Merci Ps : Au passage dans mes tâtonnements j’ai tiqué sur (length nil) qui renvoie 0 et pas nil (car pour moi nil c’est rien et zéro quelque chose). En testant ( ) c.a.d. une liste sans élément cela m’a retourné nil, j’ai donc mieux compris l’histoire de (length nil) qui renvoie 0 <=> (length ()) qui renvoie 0 (ce qui est évident écrit sous cette forme), bon satisfait d’avoir au moins appris une chose.

Bonsoir, (gile), merci pour ton message de bienvenue, les liens et ton codes : _$ (Tri&Comp '(4.0 7.5 5.0 9.0 9.0 4.0 7.5 7.5 5.0 8.25 9.0 5.0)) ((2 . 4.0) (3 . 5.0) (3 . 7.5) (1 . 8.25) (3 . 9.0)) Il répond parfaitement à ma demande, j’espère trouver le temps dans la semaine pour le décortiquer et assimiler, ainsi que tes liens. Merci, c’est surtout le forum débuter en Lisp que j’ai pas mal dégrossi.. (J’ai consulté les messages en entête, et je parcours le forum depuis sa création, j’en suis à la fin 2006..). Je m’efforce d’avancer de façon méthodique déformation professionnel sans doute (projeteurs structure béton armé et précontraint à l’origine). Evidemment, maintenant que tu l’écris je vois la coche, pourquoi faire simple quant on peut faire compliqué… Tramber, merci pour tes encouragements, j’ai également testé tes lignes de codes : ‘(4.0 7.5 5.0 9.0 9.0 7.5 7.5 5.0 8.25 9.0 5.0) … … ((1 . 4.0) (3 . 5.0) (3 . 7.5) (1 . 8.25) (3 . 9.0)) _$ Elles me conviennent également, comme pour celles de (gile) j’espère pouvoir les décortiquer un peu plus dans le courant de la semaine. Je pense clôturer ce sujet que je considère comme résolu, en espérant y revenir dessus lorsque j’aurais écris ma propre fonction, pour la suite je pense enchaîner sur les jeux et autres filtres de sélections..

Merci Tramber de l’intérêt que tu porte à mon problème, j’avoue que tes explications sur mapcar ne sont pas encore très évidentes pour moi, mais je suppose que cela doit être un point de passage obligé dans l’apprentissage du Lisp, je l’avais mis à mon "planning" mais après une meilleure maîtrise de l’éditeur visual et des outils de suivie pour mieux comprendre le fonctionnement de cette fonction. A+

Bonsoir, Euréka j'ai trouvé.. pour le Smileys et la parenthèse manquante en fin de ligne Rappel du problème d'affichage : _$ (vl-sort '(4 7 5 9 9 4 7 7 5 8 9 5) '<) (4 5 7 8 9) _$ Après plusieurs essaie, il suffit de rajouter un espace après le < et la parenthèse Ce qui donne : _$ (vl-sort '(4 7 5 9 9 4 7 7 5 8 9 5) '< ) (4 5 7 8 9) _$ On alors en ne se servant pas du formatage.. _$ (vl-sort '(4 7 5 9 9 4 7 7 5 8 9 5) '<) (4 5 7 8 9) _$ Et cela ne gène en rien l'interprétation dans Visual Lisp :D Ca progresse.. ça progresse.. à vitesses grand V, espérons que ça en aille de même en Lisp.. ;) Edit: Zut. Je me suis fait doublé pour l'explication sur BB Codes, j'ai l'air malin avec mes explication qui font doublons maintenant.. :casstet: Merci pour l'explication Tramber [Edité le 1/10/2010 par VDH-Bruno] [Edité le 1/10/2010 par VDH-Bruno]

Merci pour ta réponse Tramber Je vais décortiquer tranquillement (et à tête reposé) tes lignes de codes. Oui visiblement vl-sort supprime les doublons pour les chaînes et les entiers, mais pas pour les réels c'est justement ce qui me trouble dans cette histoire.. Une explication serai le bienvenu si quelqu'un la connait.. Sinon en plus du smiley dans la ligne de code, il fait visiblement sauter une parenthèse une fin de ligne. J'ai essayé en vain de la rajouter (c'est génant pour ceux qui voudraient tester), peut être en la doublant, à suivre.. Merci et au revoir

Bonjour aux membres de ce forum Utilisateur d’AutoCAD depuis la R12, je débute en AutoLISP depuis deux/trois mois, jusqu’ici j’ai réussi à trouver les solutions à mes questions basiques en parcourant les divers messages du forum débutant. Etant actuellement un peu plus familier avec la syntaxe du langage, mes ambitions grandissent ainsi que mes difficultés, je poste donc pour la première fois.. L’objectif que je me suis fixé : C’est de traiter une Liste représentant des longueurs (REAL), du style : '(4.0 7.5 5.0 9.0 9.0 4.0 7.5 7.5 5.0 8.25 9.0 5.0) Pour obtenir en retour une liste du style : '((2 4.0) (3 5.0) (3 7.5) (1 8.25) (3 9.0)) C'est-à-dire une liste ordonnée en fonction des longueurs, et comptabilisant le nombre de longueur identique. J’appréhende la résolution de la manière suivante (au vu de mes maigres connaissances et pérégrinations sur ce forum) 1 – Trier la Liste et en supprimant les doublons. Pour ce faire j’ai employé [surligneur] vl-sort [/surligneur]avec syntaxe suivant : (setq LstOrd (vl-sort LstLong '<)) A la lecture des exemples de l’aide, et une explication de (Gille) dans ce sujet : http:// http://www.cadxp.com//modules.php?op=modload&name=XForum&file=viewthread&fid=100&tid=10385, j'ai pensé (bien que ce soi une fonction VLisp, de toute façon il faudra bien que j'y vienne par la suite) que c'était la plus adapté.. (sic l’anglais n’est pas ma tasse de thé, allemand 1ère langue puis avec les aléas de la vie j’ai acquis quelques mots d’arabe et des notions dans un dialecte berbère du sud Marocain. Mais pas d’anglais à mon vocabulaire !) 2 – Puis effectuer une boucle sur chaque élément de la Liste Ordonnée (LstOrd) pour comptabiliser dans la Liste de Longueur (LstLong) le nombre de longueur identique, Pour le comptage des éléments doubles j’ai adapté (enfin je crois !) une fonction proposé par Elpanov Evgeniy sur ce forum : (setq l '(4.0 7.5 5.0 9.0 9.0 4.0 7.5 7.5 5.0 8.25 9.0 5.0)) (apply '+(mapcar '(lambda(x)(if (= x 9.0)1 0))l)) Parmi les nombreuses fonctions de comptage répertorié dans le forum, j’ai ciblé celle-ci pour sa concision, le style, l’absence de fonctions vl- (qui me sont complètement étrangère) et l’emplois des fonctions apply mapcar lambda que je m’efforce de maitriser (c’est encore loin d’être fait… :casstet: ) Mon code : (qui hélas bug !!) (defun Tri&Comp (LstLong / LstOrd Result Nbr&Long) (vl-load-com) ;; Trie la liste de façon strictement croissante (setq LstOrd (vl-sort LstLong '< )) ;; Boucle tant qu'il y a des Longueurs à comptabiliser (while LstOrd ;; Construction de la liste (Nbr & Long) (setq Nbr&Long (list ;; Compte le nbr élément identique dans la liste (apply '+ (mapcar '(lambda (x) (if (= x (car LstOrd)) 1 0 ) ;_ Fin de if ) ;_ Fin de lambda LstLong ) ;_ Fin de mapcar ) ;_ Fin de apply (car LstOrd) ) ;_ Fin de list ) ;_ Fin de setq ;; Construction de la liste de résultat ((Nbr1 & Long1) (Nbr2 & Long2) etc...) (if Result (setq Result (append Result (list Nbr&Long))) (setq Result (list Nbr&Long)) ) ;_ Fin de if ;; Retire le 1er élément comptabiliser pour la suite du traitement (setq LstOrd (cdr LstOrd)) ) ;_ Fin de while Result ) ;_ Fin de defun Résultat : _$ (Tri&Comp '(4.0 7.5 5.0 9.0 9.0 4.0 7.5 7.5 5.0 8.25 9.0 5.0)) ((2 4.0) (2 4.0) (3 5.0) (3 5.0) (3 5.0) (3 7.5) (3 7.5) (3 7.5) (1 8.25) (3 9.0) (3 9.0) (3 9.0)) Voilà c’est hélas assez loin du résultat escompté.. Interprétation : Donc en triturant mon code et les fonctions Lisp utilisés, j’ai remarqué que la fonction vl-sort Ce comportait différement avec une liste d’entiers et liste de réels Exemples : Liste d'entiers (suppression des doublons) _$ (vl-sort '(4 7 5 9 9 4 7 7 5 8 9 5) '<) (4 5 7 8 9) Liste d'entiers (pas de suppression des doublons) _$ (vl-sort '(4.0 7.5 5.0 9.0 9.0 4.0 7.5 7.5 5.0 8.25 9.0 5.0) '<) (4.0 4.0 5.0 5.0 5.0 7.5 7.5 7.5 8.25 9.0 9.0 9.0) Consolation: mon code fonctionne trés bien avec des nombres entiers (hélas je travaille exclusivement avec des rélles ;) ) _$ (Tri&Comp '(4 7 5 9 9 4 7 7 5 8 9 5)) ((2 4) (3 5) (3 7) (1 8) (3 9)) En conclusions : En 1- Je constate le comportement de [surligneur] vl-sort [/surligneur]mais je ne me l’explique pas, une petite aide sur la question serai le bien venu.. merci pour celui qui voudra bien me renseigner. En 2- D’une manière général j’aimerais bien avoir un retour sur mon code (dans le soucis de progresser) même si j’ai bien conscience de son imperfection. Dans mes recherche sur le forum je ne doute pas de trouver la fonction toute faite (et je ne suis pas contre pour confronter les solutions), mais j’arrive à un stade de mon apprentissage ou j’aspire plus à les écrire par moi-même plutôt que de continuer à assembler les fonctions des autres. Pour la suite, j’essaierai d’être plus concis dans mes messages mais étant donné que c’est le premier dans ce forum considérez que c’était également pour moi une façon de me présenter. Cordialement VDH EDIT 1: Mon exemple ne fonctionne pas même avec des entiers, il faut que je revois cela.. plus tard (pourtant il m'avais semblé.. faut que je revois mes différente version). EDIT 2: Désolé pour les smileys dans les ligne de codes, il n'y a pas que le Lisp que je ne maitrise pas encore.. :cool: EDIT 3: Corrigé mon code (manqué une parenthèse et modifié une variable), un malencontreux copier coller de l'ancienne version.., [Edité le 1/10/2010 par VDH-Bruno][Edité le 1/10/2010 par VDH-Bruno] [Edité le 1/10/2010 par VDH-Bruno]

Test formatage codes pour forum Lisp (setq Lst1 '(4.0 7.5 5.0 9.0 9.0 4.0 7.5 7.5 5.0 8.25 9.0 5.0)) (setq Lst2 '(4 7 5 9 9 4 7 7 5 8 9 5)) ;; Construction de la liste de résultat ((Nbr1 & Long1) (Nbr2 & Long2) etc...) (if Result (setq Result (append Result (list Nbr&Long))) (setq Result (list Nbr&Long)) ) ;_ Fin de if Fin du teste Teste de lien Afficher le lien: http:// http://www.cadxp.com//modules.php?op=modload&name=XForum&file=viewthread&fid=100&tid=20554 Masquer le lien lien Fin du test Test de lien sur n°réponse En réponse n° 7 Fin du test <font class=edite>[Edité le 6/10/2010 par VDH-Bruno]</font><font class=edite>[Edité le 6/10/2010 par VDH-Bruno]</font> <font class=edite>[Edité le 8/10/2010 par VDH-Bruno]</font>