(gile)

Oui, atan renvoie l'arc tangent, autrement dit l'angle dont la tangente est égale à -1 (135° ou 315°) qu'on peut aussi exprimer comme l'angle dont le sinus est -0.707 et le cosinus 0.707 (soit 315°) ou comme l'angle dont le sinus est 0.707 et le cosinus -0.707 (soit 135°). Plus généralement, la surcharge de la fonction atan qui ne prend qu'un argument ne permet renvoie toujours le résultat entre -90° et 90° (zone des cosinus positifs) alors que la surcharge qui prend 2 arguments permet de déterminer précisément le quadrant de l'angle. Concernant la surcharge de méthode, tu peux voir ici.

Ce qu'on appelle "surcharge de fonction" (ou surcharge de méthode) dans d'autres environnements, c'est la possibilité de définir plusieurs fonctions (méthodes) de même nom mais avec des arguments différents en type ou en nombre (ou des types de retour différents). Par exemple, la fonction AutoLISP atan est dite "surchargée" parce qu'elle accepter soit un seul argument ; soit deux argument. Sachant que la tangente d'un angle est égale au sinus de l'angle divisé par le cosinus de l'angle. (atan -1) retourne -0.785398 (tangente de 135° ou de 315°) (atan -1 1) retourne -0.785398 (tangente de 315°) (atan 1 -1) retourne 2.35619 (tangente de 135°)

En LISP je crains que ça n'existe pas. Pour AutoCAD, tu dois pouvoir évaluer si tu es sur Windows ou Mac en testant une fonction qui n'existe que sur Windows. (if (start_dialog) (alert "Windows") (alert "Mac") ) Avec d'autres logiciels, je ne saurais dire.

D'accord, on ne parle pas de la même chose (Microsoft et d'autres ont tendance à tout qualifier de "Visual") Les packages "Microsoft Visual C++ 20XX Redistribuable" sont des bibliothèques de composants C++ nécessaires au fonctionnement des applications développées en C++ (ce qui peut-être le cas de certaines fonctionnalités Visual LISP).

Je vais donner ma réponse. Afin de ne pas alourdir le code, on considère que le nom de dossier passé comme argument à la fonction récursive ne se termine pas par le séparateur de dossier (vl-string-right-trim "\\" "C:\\Temp\\dossier racine\\"). Pour répondre à la question reformulée réponse #10, je dois faire une fonction qui retourne une liste qui décrit l'arborescence. Dans cette liste, un dossier est représenté par une liste contenant le chemin du dossier et les sous-dossiers qu'il contient représentés de la même façon (algorithme récursif). Ma réponse est semblable à celle de Patrick_35 (l'utilisation de vl-remove plutôt que cddr permet de traiter aussi les lecteurs). (defun GetFolderTree (dir) (cons dir (mapcar '(lambda (x) (GetFolderTree (strcat dir "\\" x)) ) (vl-remove "." (vl-remove ".." (vl-directory-files dir nil -1) ) ) ) ) ) (GetFolderTree (vl-string-right-trim "\\" "C:\\Temp\\dossier racine\\")) renvoie : ("C:\\Temp\\dossier racine" ("C:\\Temp\\dossier racine\\Dossier 1" ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1" ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1\\Bidule") ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1\\Truc" ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1\\Truc\\Machin") ) ) ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.2") ) ("C:\\Temp\\dossier racine\\Dossier 2" ("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.1") ("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.2") ) ) Pour répondre à la question originale et obtenir une simple liste de chemins, il faut "aplatir" cette liste de sous-liste. Si on prend un branche simple : ("C:\\Temp\\dossier racine\\Dossier 2" ("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.1") ("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.2") ) elle a été obtenue par l'évaluation de : (cons "C:\\Temp\\dossier racine\\Dossier 2" (list '("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.1") '("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.2") ) )où (list ...) est le résultat du (mapcar ...) Pour "aplatir" cette liste, il suffit d'appliquer append à la liste : (cons "C:\\Temp\\dossier racine\\Dossier 2" (apply 'append (list '("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.1") '("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.2") ) ) ) Il suffit donc d'ajouter (apply 'append ...) dans la fonction GetFolderTree pour aplatir récursivement mon arbre : (defun GetFolders (dir) (cons dir (apply 'append (mapcar '(lambda (x) (GetFolders (strcat dir "\\" x)) ) (vl-remove "." (vl-remove ".." (vl-directory-files dir nil -1) ) ) ) ) ) )

Salut, Pas à ma connaissance Visual C++ est un Environnement de Développement Intégré (IDE) qui est aujourd'hui intégré à Visual Studio.

@bonucad, (très) intéressant, mais ça ne répond pas précisément à la demande. @Patrick_35, il me semble que le test : if (= (substr rep (strlen rep) 1) "\\") ...) n'est indispensable qu'au premier appel. Ceci dit, ta réponse répond parfaitement à la question reformulée réponse #10, il ne reste plus maintenant qu'à "aplatir" la liste pour répondre à la demande originale.

Salut, Tu ne sais pas, mais tu es le seul qui pourrait savoir. Le nom de la propriété pour les paramètres dynamiques est la concaténation de "AcDbDynBlockProperty" et du nom du paramètre dynamique. Par exemple : "AcDbDynBlockPropertyDistance1" si tu n'a pas renommé le paramètre. Ensuite, il faut juste que le type de valeur passé en argument corresponde au type de valeur attendu. De façon générale, pour connaître le nom et/ou la valeur des propriétés, tu fais : (dumpallproperties (car (entsel)))puis F2 pour lire les propriétés de l'objet sélectionné.

Tout à fait, avec le "grand gourou".

Attention ObjectARX Wizard n'est pas la même chose qu'ObjectARX SDK. Sinon je n'ai pas compris quelles version d'ObjectARX SDK tu voulais (je n'utilise pas les Wizards).

Salut, L'installeur n'était pas à jour pour les versions 2018 et 2019. Si tu penses que ton problème vient de là, tu peux télécharger et installer la version à jour ou simplement modifier le fichier : %appdata%\Autodesk\ApplicationPlugins\LispExtension.bundle\PackageContents.xml Tu l'ouvres dans un éditeur de texte et tu remplaces 21.0 par 23.0 dans la balise : <RuntimeRequirements OS="Win32|Win64" Platform="AutoCAD*" SeriesMin="R19.0" SeriesMax="R23.0" /> (tu peux aussi remplacer 2017 par 2019 dans la ligne au dessus). Sinon, bien penser aussi à "Débloquer" tout fichier ZIP téléchargé avant de le décompresser.

Dans sa grande entreprise pour rendre ses pages web lisibles sur un téléphone mais illisibles sur un PC, Autodesk a cassé tous les anciens lien vers les pages de téléchargement... Si tu dis de quelle(s) version(s) d'ObjectARX tu as besoin j'essayerais de te les mettre à disposition. Tu peux d'ores et déjà trouver des versions anciennes ici (merci à Alexander Rivilis).

Salut, +1 avec Steven. Un plus pour AutoCAD c'est qu'il est largement programmable (même en 3D) et qu'on peut lui faire faire des choses très spécifiques. Je travaille actuellement sur un programme de gardes-corps qui permet de construire un modèle 3D de façon quasi "paramétrique" et de l'utiliser pour générer nomenclatures, fiches de montage, fichiers d'usinage etc.

C'est parce que tu faisais : (append (mapcar '(lambda (x) (strcat dir "\\" x)) (vl-directory-files dir nil -1)) ...) avant de filtrer les dossiers ".,..".

Bravo !

@Fraid, Tu n'es vraiment pas loin, regarde comment Patrick_35 utilise (cddr ...) pour écarter les dossiers "." et "..".

Attention, cddr ne marche pas si la racine est un lecteur ("C:" par exemple).

Je m'aperçois que ce challenge n'est pas si facile, alors je propose, dans un premier temps, de chercher à retourner une liste de sous-liste qui reflète l'arborescence. Exemple de résultat avec l'arborescence décrite plus haut : ("C:\\Temp\\dossier racine" ("C:\\Temp\\dossier racine\\Dossier 1" ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1" ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1\\Bidule") ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1\\Truc" ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.1\\Truc\\Machin") ) ) ("C:\\Temp\\dossier racine\\Dossier 1\\Sous dossier 1.2") ) ("C:\\Temp\\dossier racine\\Dossier 2" ("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.1") ("C:\\Temp\\dossier racine\\Dossier 2\\Sous dossier 2.2") ) )

Salut, C'est malin l'utilisation d'une fonction auxiliaire à effet de bord (maitrisé), même si certains peuvent y voir une entorse à la pureté fonctionnelle (personnellement, j'emploie souvent ce procédé en C#). Juste pour souligner ça, le mapcar, n'est pas nécessaire puisque la liste qu'il retourne n'est jamais utilisée et pourrait être remplacé par un foreach. (defun rch_che(rep / che lst) (defun che (rep) (setq lst (cons rep lst)) (foreach x (cddr (vl-directory-files rep "*.*" -1)) (che (strcat rep "\\" x)) ) ) (che rep) (reverse lst) )

Personnellement je ne suis pas trop favorable à ça en LISP, les surcharges de méthode avec des langages fortement et statiquement typés c'est robuste et ça n'a pas de coût, avec un langage faiblement et dynamiquement typé comme le LISP, je trouve l'artifice de la liste en argument un peu lourdingue et moins fiable.

Ta dernière fonction ne marche pas (même si tu renommes str2lst en str2list). Comme tu utilises une fonction récursive les arguments des appels récursifs doivent être identiques aux argument de la fonction, et ça t'oblige à faire le test de l'argument et de le reconstruire en liste à chaque appel récursif. Pour qu'elle fonctionne il faudrait l'écrire comme ça: (defun str2list (arg / pos sep str);ici les 2 sont possible (if (= (type arg) 'LIST) (setq sep (cdr arg) str (car arg) ) (setq sep ";" str arg ) ) (if (setq pos (vl-string-search sep str)) (cons (substr str 1 pos) (str2list (cons (substr str (+ (strlen sep) pos 1)) sep)) ) (list str) ) ) En général, dans ce genre de cas, on utilise une fonction récursive auxiliaire ce qui permet de définir les arguments dans la fonction principale. (defun str2list (arg / aux) (defun aux (str sep / pos) (if (setq pos (vl-string-search sep str)) (cons (substr str 1 pos) (aux (substr str (+ (strlen sep) pos 1)) sep) ) (list str) ) ) (if (listp arg) (aux (car arg) (cadr arg)) (aux arg ";") ) )

Salut, On ne peut pas en LISP écrire de (defun ...) surchargé, mais nombre de fonction LISP natives (probablement implémentée en C) sont surchargées avec des arguments optionnels ou en nombre indéterminé. La solution de contournement est souvent d'avoir une liste comme argument (qui contient les "vrais" arguments). Mais ça demande de tester le contenu de la liste.

Oui, mais on ne parle pas que de fonctions, on peut parler aussi de structure récursive (arborescences, fractales) : - un dossier contient potentiellement des fichiers et des dossiers - une liste de données LISP (liste chaînée) est : soit une liste vide ; soit une donnée (car) et un pointeur vers une liste de données (cdr). Schématiquement : () | (cons x lst). On parle aussi de définition récursive pour le LISP : une expression LISP est : soit un atome ; soit une liste d'expressions LISP.

Dans l'esprit des réponses de GEGEMATIC, x_all et Fraid : (defun doublon (l) (cond ((null l) nil) ((member (car l) (cdr l)) T) (T (doublon (cdr l))) ) ) Ou, plus élégant : (defun doublon (l) (or (member (car l) (cdr l)) (and l (doublon (cdr l))) ) )

Hors challenge, dans l'esprit de ce qu'a donné bonuscad : (defun doublon (l) (or (vl-some '(lambda (x) (member x (cdr (member x l)))) l)) ) L'utilisation de (or ...) sert juste à renvoyer T au lieu de la première occurrence de (member x (cdr (member x l))). C'est uniquement pour respecter une règle du challenge, et ça serait inutile dans un autre cadre : pour les conditionnelles LISP tout ce qui n'est pas nil est considéré comme vrai.