VDH-Bruno

Re, La ligne de code précédente, retranche ou ajoute le code binaire 1 à somme des codes binaires, donc si la variable et réglé à 2 on bascule de 2 à 3 et vice-versa. Donc pour basculer de 6 à 7, il faut que la variable soit préalablement définie sur une de ses 2 valeurs. L'expression lisp équivalente à l'expression diesel précédente: (setvar 'OSOPTIONS (boole 6 (getvar 'OSOPTIONS) 1)) (6 réprésentant l'opérateur xor dans le fonction boole). Maintenant si tu souhaites avoir une bascule spécifique sur les valeurs 6 ou 7, en fonction de la présence ou non du code binaire 1, tu peux tester ce qui suit: L'expression Diesel: ^C^COSOPTIONS;$M=$(if,$(<,$(xor,$(getvar,OSOPTIONS),1),$(getvar,OSOPTIONS)),6,7); L'expression Lisp équivalente: (setvar 'OSOPTIONS (if (< (boole 6 (getvar 'OSOPTIONS) 1) (getvar 'OSOPTIONS)) 6 7)) Expression qui peut être simplifié au moyen de la fonction logand: (setvar 'OSOPTIONS (if (zerop (logand (getvar 'OSOPTIONS) 1)) 7 6)) Sachant que tu t'intéresses au Lisp, je t'invite à jeter un œil à cette discussion challenge-bascule cela devrait aider. A+

Slt, En passant de 6 à 7, il faut faire une opération sur le bit 1 pour que cela fonctionne, ^C^COSOPTIONS;$M=$(xor,$(getvar,OSOPTIONS),1); (Ps: Pour les valeurs 6 et 7 je te fais confiance, ma version s'arrêtant à 3) A+

Salut, AutoLISP ne supportant pas les mémo-fonctions avec l'accès au P-liste (Cf page 54 du lien http://www.ai.univ-paris8.fr/~hw/lisp/letout.pdf pour un exemple appliqué à l'algorithme de FIBONACCI) comme cela peut exister avec LE_LISP. On peut tout de même tenter quelque chose d'approchant sur le principe en utilisant la redéfinition de fonction avec defun-q pour stocker dans le corps de fonction les résultat précédemment calculé, comme cela à déjà été proposé sur ce forum par (gile) sur l'exemple du PGCD. Le code: (defun-q fib (n) (list 1 0) (cond ((nth n (reverse (cdr(cadr fib))))) ((setq fib (vl-list* (car fib) (cons 'list (cons (+ (car (cdadr fib)) (cadr (cdadr fib))) (cdadr fib)) ) (cddr fib) ) ) (fib n) ) ) ) Code qui à un intérêt seulement sur ce type de traitement: A+

Bonjour, Le retour des challenges super!!! Pour saluer cette initiative ma petite contribution… La première qui vient à l'esprit pour sa concision (à condition d'avoir une bibliothèque de fonction prédéfinie bien fournie), avec massoc et remove_doubles(/distinct), perso j'ai utilisé les fonctions de (gile) ici. (defun asso (l m) (setq m (mapcar 'cons l m)) (mapcar '(lambda (x) (append (list x) (gc:massoc x m))) (gc:distinct l)) ) (@Patrick_35: c'est l'écriture de l'algorithme décrit par stendhal666 sur le forum developpez.com, au passage il me semble qu'il faut ajouter un # devant 'cons pour que ton exemple soit compatible en Clisp ;-). Pour la syntaxe en Clisp http://www.lispworks.com/documentation/HyperSpec/Body/f_mapc_.htm) Sinon pour une proposition de code plus personnel, avec une variante mutuellement récursive pour optimiser le parcours sans avoir recours à la bibliothéque de fonction vl- et n'employer principalement que les fonctions primitives du lisp que sont car, cdr, cons.., (defun asso (l m / g f) (defun f (a acc l m) (cond ((null l) (list (cons a acc))) ((member a l) (g acc l m nil nil)) (T (cons (cons a acc) (f (car l) (list (car m)) (cdr l) (cdr m)))) ) ) (defun g (acc l1 m1 l2 m2) (if (eq a (car l1)) (f a (cons (car m1) acc) (append l2 (cdr l1)) (append m2 (cdr m1))) (g acc (cdr l1) (cdr m1) (cons (car l1) l2) (cons (car m1) m2)) ) ) (f (car l) (list (car m)) (cdr l) (cdr m)) ) Pour le jeu et pour ceux qui considèreraient que j'ai pris des libertés avec l'emploi de member et append, ci-dessous des versions "equivalentes" :-) (defun e-member (e l) (cond ((null l) nil) ((equal e (car l)) l) ;ou eq (T (e-member e (cdr l))) ) ) (defun e-append (l m) (if l (cons (car l) (e-append (cdr l) m)) m ) ) (Ps: Désolé de n'avoir pu participer dans les temps, un rapide coup d'œil sur l'autre challenge me fait penser que ça m'étonnerai que je puisse encore inscrire quelques lignes de code donc toutes mes félicitations aux participants) Amicalement Bruno

Bonjour, Un lisp écrit à la volé à tester (juste pour me prouver si je pouvais l'écrire plus vite que le temps de recherche de lecrabe ;) ) (defun c:barbichette (/ ss i e ) (if (setq ss (ssget "_X" '((0 . "ATTDEF")))) (repeat (setq i (sslength ss)) (setq e (entget (ssname ss (setq i (1- i))))) (entmake (list '(0 . "TEXT") '(100 . "AcDbEntity") (assoc 67 e) (assoc 410 e) (assoc 8 e) '(100 . "AcDbText") (assoc 10 e) (assoc 40 e) (cons 1 (cdr (assoc 2 e))) (assoc 50 e) (assoc 41 e) (assoc 51 e) (assoc 7 e) (assoc 71 e) (assoc 72 e) (assoc 11 e) (assoc 210 e) '(100 . "AcDbText") (assoc 73 e) ) ) (entdel (cdr (assoc -1 e))) ) ) (princ) ) Edit: !!!!!!!!!!!!!!!!!! Perdu !!!!!!!!!!!!!!!!!!!! :angry: :angry: :angry: (à 2 mn près grrr..) A+

Bonjour, C'est typiquement le type de tache à traiter en lisp, et qui avec l'habitude ne prend guère plus de 5mn à écrire… Un principe qui s'execute sur l'ensemble de tes présentations (defun c:crashray (/) (defun copieRenommeDecalaVue (presentation) (command "PRESENTATION") (command "COPIER") (command presentation) (command (strcat presentation "__U67")) (setvar 'ctab (strcat presentation "__U67")) (command "_.MSPACE") (command "_.ZOOM") (command "_C") (command (cons (+ (car (getvar 'viewctr)) 8000) (cdr (getvar 'viewctr)))) (command "") (command "_.PSPACE") ) (mapcar 'copieRenommeDecalaVue (LAYOUTLIST)) ) Sinon avec l'expression suivante pour n'appliquer que sur la seul présentation courante A+

Bonjour, Si le suffixe / préfixe sont constant, le plus simple et de faire un style de cote et de renseigner dans les unités principal le suffixe et le préfixe. Puis de mettre à jour les cotes à modifier A+

Bonjour lecrabe, Peut-être en supprimant simplement l'expression "_X" du code.. A+ (Ps: Non testé,n'ayant pas (ne connaissant pas) Map)

Re, La fonction lambda fonctionne comme une fonction utilisateur, pour essayer de démystifier cela en quelques lignes définissons une fonction nommé cube… _$ (defun cube (n) (* n n n)) CUBE En nommant la fonction nous avons associé un symbol CUBE à la définition de la fonction _$ CUBE #<USUBR @18cc5cbc CUBE> On peut appeler ultérieurement la fonction par son nom de la façon suivante (et lui passer à ce moment son argument) _$ (cube 3) 27 Si tu observes la valeur de retour de la fonction defun, et la syntaxe utilisée pour appeler la fonction cube, tu t'aperçois que tu aurais très bien pu appeler la fonction cube au moment de sa définition en évaluant la valeur de retour du defun pour accéder à la définition contenu dans le symbol cube (même si c'est beaucoup moins lisible) $ ((eval (defun cube (n) (* n n n))) 3) 27 Et bien avec lambda c'est exactement pareil pour définir ta fonction, sauf que tu n'as pas de symbol à évaluer (car il n'y pas de nom pour accéder à ta définition de fonction) _$ (lambda (n) (* n n n)) #<USUBR @18cc5dc0 -lambda-> Pour exécuter la fonction, il suffit de définir la fonction anonyme immédiatement suivie de son/ses argument. _$ ((lambda (n) (* n n n)) 3) 27 En espérant que tu sois plus à l'aise, lorsque tu passera à l'étude de mapcar, à ce moment relis en entête du forum l'explication de (gile) sur le sujet, cela devrait passer car je vois à l'écriture de ton code que ça progresse bien. A+

Demixav la macro lisp correspondant à ta proposition: (vl-cmdf "_-hatchedit" PAUSE "G" "D" "" "") A+

Re, Pour info Dans ton code tu faisais une erreur avec ces 2 lignes (mod-val ent 43 (car p1)) (mod-val ent 44 (cadr p1)) La première fois tu modifie le code 43 et la seconde en voulant modifier le code 44, tu rétablis l'ancienne valeur du code 43 mémorisé dans ta variable ent A+

Bonjour x_all, Bon j'ai pris 5mn, pour approfondir un peu le sujet et me créer un fichier teste (ce que je n'avais pas fait :unsure: ), je m'excuse car je me suis aperçu que je n'avais pas bien compris la problématique. La propriété Origine stocke les coordonnées à la création de la hachure, mais le calcul des données du motif se fait bien en fonction des codes 43 & 44 (attention ces codes peuvent être multiple). Donc modifier ultérieurement l'origine de la hachure sans passer par les commandes AutoCAD ne fonctionne pas, il n'y a pas de mise à jour automatique des données. La réponse à ton besoin peut ce faire par le "macrotage" de la commande _-hatchedit, ou en lisp "classique" en intervenant sur toutes les occurrences des codes 43 & 44 Pour le principe: ((lambda (p1 ent / newdxf43 newdxf44) (setq newdxf43 (cons 43 (car p1)) newdxf44 (cons 44 (cadr p1)) ) (entmod (mapcar '(lambda (dxf) (cond ((= 43 (car dxf)) newdxf43) ((= 44 (car dxf)) newdxf44) (dxf) ) ) ent ) ) ) (getpoint "sélectionnez un point pour l'origine") (entget (car (entsel))) ) A+

Le problème vient de la fonction vlax-3d-point qui va te créer un safeArray à 3 éléments, même si tu lui en fournie 2, alors que la propriété Origine est définie en 2D (x,y) dans le plan de la hachure, il te faut créer le safeArray correspondant avec les fonctions vlax-make-safearray et vlax-safearray-fill Pour l'exemple ((lambda (p1 ent / 2Dpt) (setq 2Dpt (vlax-make-safearray vlax-vbdouble '(0 . 1))) (vlax-safearray-fill 2Dpt (list (car p1) (cadr p1))) (vla-put-Origin (vlax-ename->vla-object ent) 2Dpt ) ) (getpoint "sélectionner un point pour l'origine") (car (entsel)) ) Mais en utilisant la syntaxe vlax-put tu peux renseigner la propriété Origine directement avec une liste de 2 éléments. ((lambda (p1 ent) (vlax-put (vlax-ename->vla-object ent) 'Origin (list (car p1) (cadr p1))) ) (getpoint "sélectionner un point pour l'origine") (car (entsel)) ) A+ Ps: La solution d'Olivier semble intéressante (avec 10 versions de retard je n'ai pas mieux..).

Bonjour x_all En Lisp eegarde dans les Xdata (données étendus) de ta hachure, c'est là que se cache les coordonnées de l'origine que tu veux modifier et non dans les codes 43 et 44. A tester sur une hachure _$(assoc -3 (entget (car (entsel))'("acad"))) (-3 ("ACAD" (1010 0.0 0.0 0.0))) Sinon en Vlisp avec un (vlax-dump-object(vlax-ename->vla-object (car (entsel))))- tu verras une propriétés Origin qui est modifiable avec vla-put-Origin Si tu n'arrive pas à te débrouiller avec cela fait le savoir, je te posterai un petit exemple demain A+ et bon courage

Re, Oui, avec ce principe tu vas doubler (triplet, quadruplet ect..) toutes les définitions de blocs dans ton dessin final, même celles qui étaient identiques à l'origine dans chaque dessins… Dans cette éventualité (et en complément de l'aide en ligne), au besoin tu peux raffiner un peu la méthode, dans la BD de la commande renommer en sélectionnant (ou déselectionnant shift+ctrl) tes blocs, dans ancien nom s'affiche *varie*, dans nouveau nom tu fais PREFIXE*varie* A+

Bonjour, Et si tu insérais en Xref tes dessins à fusionner, plutôt qu'en bloc.. Sinon explose tes blocs dans chaque dessin respectif.. (bof) Ou alors renomme correctement tes blocs dans chacun de tes dessins avant insertion. A+

Ce qui exige d'avoir un esprit critique, mais pour cela il faut comprendre le pourquoi du comment de ce que l'on fait. Mais rassurez-vous (ou plutôt attristez-vous) ce que vous vivez, c'est généralisé aux autres corps de métier.. A+

Non pas magique, car le mapcar n'est vraiment pas nécessaire dans ce cas, il oblige à la construction d'une liste au moyen de repeat pour être appliqué, avec while ça fonctionne certainement mieux, donc merci pour ton observation ;) (defun Nompropre (str / lst flag) (while (/= "" (setq lst (cons (strcase (substr str 1 1) flag) lst) flag (not (wcmatch (car lst) "`-, ")) str (substr str 2) ) ) ) (apply 'strcat (reverse lst)) ) A+

Re, Alors rapidement pour l'exemple sans chercher à optimiser le traitement, une formulation possible en Lisp de ton énoncé, si des fois tu retrouvais ta fonction VBA et que tu voulais faire un comparatif (defun Nompropre (str / lst flag) (apply 'strcat (mapcar '(lambda (x) (setq x (strcase (substr str 1 1) flag) str (substr str 2) flag (not (wcmatch x "`-, ")) ) x ) (repeat (strlen str) (setq lst (cons T lst))) ) ) ) Teste _$ (Nompropre "jean-paul sartre") "Jean-Paul Sartre" _$ _$ (Nompropre "JEAN-PAUL SARTRE") "Jean-Paul Sartre" _$ A+

GJulien, DenisH, x_all (et d'autres...), suivant votre envie et disponibilité biensur :) Pour extrapoler et continuer sur les majucules/minuscules, je propose de coder: Une généralisation "simple" de la fonction Nompropre, à savoir enrichir la fonction d'un argument nombre, pour fixer le nombre de caractère à mettre en majuscule: _$ (casse "pUiSaRd" 0) "puisard" _$ (casse "pUiSaRd" 2) "PUisard" _$ (casse "pUiSaRd" 20) "PUISARD" Puis une fonction ChatMot (inspirer du CamelCase) pour mettre en majucule (les autres en minuscules) des lettres en fonction d'une liste de position. _$ (chatmot "chatmot" '(1 5)) "ChatMot" _$ (chatmot "PUISARD" '(2 4 6)) "pUiSaRd" _$ (chatmot "puisard" '(1 3 5 7)) "PuIsArD" Pour simplifier le code, les arguments seront supposé valide. A+

Bonjour, Pour ton code de la réponse n°26, cela ne devrait pas, mais si par inadvertance tu rechargeais ton code de la réponse n°24 (ou qu'il se chargeait à la suite dans ton fichier) c'est tout à fait normal… Je pense que le ménage que tu as fait dans ton fichier Lisp a été bénéfique. A+

Sous forme de fonction ça fait plus lispien ;) _$ (defun casse (str) (strcat (strcase (substr str 1 1)) (strcase (substr str 2) T))) CASSE _$ (casse "pUiSaRd") "Puisard" (ps: tu peux économiser strlen dans substr il y a des arguments optionnel noté entre crochet dans l'aide [...]) A+

;;

L'expression suivante te retournera la valeur numérique de ta chaine sinon nil (if (numberp (setq nbr (read (vl-string-translate "pmPM" " " Prof)))) nbr ) A+ (Ps: Le mapcar était à titre d'exemple pour les combinaisons que tu avais énuméré)

Il y a peu de problèmes qui ne puissent trouver de solution, un exemple qui retourne systématiquement la valeur numérique de la chaîne sinon nil, avec tes qq exemples. _$ (mapcar '(lambda (txt / nbr) (if (numberp (setq nbr (read (vl-string-translate "pmPM" " " txt)))) nbr ) ) '("P1.20" "P1.20M" "p1.20" "p1.20m" "puisard" "pas ouvert" "bloqué") ) (1.2 1.2 1.2 1.2 nil nil nil) _$ A+