comment avoir plusieurs programme dans un lisp?

[philsogood]

Hello,

Je travaille depuis peu avec deux type de ficheirs gabarits

l'un en mètre l'autre en millimètre.

Je suis régulièrement amené à tracer des conduites (PVC, inox, fonte) et pour ce faire j'utilisais lorsque mon fichier était en millimètre un lisp comme celui ci :

(defun c:p8 (/)(command "_mline" "_j" "_z" "_st" "PVC" "_s" "12"))
(defun c:p10 (/)(command "_mline" "_j" "_z" "_st" "PVC" "_s" "16"))
(defun c:p15 (/)(command "_mline" "_j" "_z" "_st" "PVC" "_s" "20"))
(defun c:p20 (/)(command "_mline" "_j" "_z" "_st" "PVC" "_s" "25"))
(defun c:p25 (/)(command "_mline" "_j" "_z" "_st" "PVC" "_s" "32"))
...

ce lisp me créait un tube en filaire (2 traits plein et un trait d'axe central selon la type multiligne PVC que j'avais paramétré)

Malheureusement ce lisp ne focntionne plus lorsque je travaille sur un fichier en mètre car ma conduite au lieu de faire 50mm de large(diamètre) fait 50m...

 

Comment faire pour ne pas avoir à écrire devant chacun des lisps que j'ai créés

(setq unite (getvar "insunits"))
     (cond ((= unite 4) (setq echelle 1000))
           ((= unite 5) (setq echelle 100))
           ((= unite 6) (setq echelle 1))
 ) 

 

L'idéal serait d'écrire cette "phrase" au tout début de mon *.lsp et qu'elle se répète pour chacun des petit programme situés à l'intérieur.

Si je travaillais "salement" je définirais la variable globale unite et echelle à l'ouverture de mon dessin (elle ne serait pas une variable locale de mon lisp) mais nombres d'entre vous n'aiment pas ce genre de méthode (car les variables pourraient se croiser sur d'autres programmes)

 

Suis-je clair?

Phil

[(gile)]

Salut,

 

Si j'ai bien compris, tu peux utiliser une fonction plutôt que des variables locales.

 

Un exemple avec une fonction qui convertit le diamètre en millimètre passé comme argument dans l'unité courantes.

Je suppose que largeur de la multiligne dans le style est de 1 et que le nombre passé à l'option échelle ("_s") correspond au diamètre (même si je ne comprends pas pourquoi p8 -> 12, p10 -> 16, ...)

 

(defun diamScale	(diam / unit)
 (setq unit (getvar "insunits"))
 (cond
   ((= unit 4) diam)
   ((= unit 5) (/ diam 10.))
   ((= unit 6) (/ diam 1000.))
 )
)

(defun c:p8 (/) (command "_mline" "_j" "_z" "_st" "PVC" "_s" (diamScale 12)))
(defun c:p10 (/) (command "_mline" "_j" "_z" "_st" "PVC" "_s" (diamScale 16)))
(defun c:p15 (/) (command "_mline" "_j" "_z" "_st" "PVC" "_s" (diamScale 20)))
(defun c:p20 (/) (command "_mline" "_j" "_z" "_st" "PVC" "_s" (diamScale 25)))
(defun c:p25 (/) (command "_mline" "_j" "_z" "_st" "PVC" "_s" (diamScale 32)))

 

Pour l'élégance et la concision (et pour éviter de recopier quasiment le même code pour chaque commande), tu peux définir les commandes dans une unique expression (mapcar ...) avec une liste pour les noms de fonctions (c:p8 c:p10 ...) et une autre pour les diamètres correspondants (12 16 ...)

 

(mapcar
 '(lambda (cmd diam)
    (eval
      (list
 'defun
 cmd
 nil
 (list 'command "_mline" "_j" "_z" "_st" "PVC" "_s" (list 'diamScale diam))
      )
    )
  )
 '(c:p8 c:p10 c:p15 c:p20 c:p25)
 '(12 16 20 25 32)
)

[philsogood]

wahou!!

je n'avais jamais utilisé d'arguments dans mes lisp mais je commence à en voir l'utilité (après l'application sera peut être laborieuse mais c'est un autre débat)*

donc OK pour le diamScale

par contre le mapcar, je ne te cache pas (gile) que je suis stupéfait par la simplicité que peut prendre mon code avec l'utilisation de cette fonction

j'ai essayé de voir sur le net des exemples d'utilisation de mapcar mais c'est assez basique (genre

(mapcar '1+ '(2 4 6))

)

quand je vois ton code je ne te cache toujours pas (!!) que j'ai rien compris (ou presque)!!

(list
        'defun
        cmd
        nil
        (list 'command "_mline" "_j" "_z" "_st" "PVC" "_s" (list 'diamScale diam))
      )

En fait ce cette aprtie de code qui permet de s'affranchir de la création des nombreux lisp que j'avais fait auparavant!! c'est franchement puissant mais je ne comprends pas comment ça marche. j'ai quand même copris que ça allait me créer des listes de raccourcis pour la création de mes tubes (d'ou le 'defun), que le cmd est lié au deux listes des dimaètres mais je ne sais à quoi sers le nil!

Toujours est-il qu'une fois encore je te dois bcp pour ton aide

Merci (gile)

Phil

[(gile)]

Salut,

 

Il est vrai que cette expression (mapcar ...) pour définir plusieur commendes aurait plus sa place dans le forum "Aller plus loin en LISP".

 

Malgré tout, je vais tenter une explication.

mapcar requiert comme arguments une fonction et une ou plusieurs listes.

Elle retourne la liste qui est le résultat de l'application de la fonction à chacun des éléments de la (ou des)

liste(s).

 

Dans le cas présent, on a une fonction (lambda) et 2 listes.

Comme exemple simple avec deux listes, on peut prendre :

(mapcar '+ '(1 2 3) '(4 5 6))

qui retourne

(5 7 9)

soit la liste qui est le résultat de l'application de la fonction + à chacun des éléments correspondants des deux listes passées en argument :

(list (+ 1 4) (+ 2 5) (+ 3 6))

Ici la fonction est une fonction anonyme (lambda) qui prend deux arguments soit un dans chacune des deux listes passées en argument (les noms de commandes et les diamètres correspondants).

Elle appelle la fonction eval sur une liste pour évaluer cette expression.

Dans la liste certains éléments (les noms de fonction) sont "quotés" (avec l'apostrophe) pour ne ne pas être évalués par le fonction list. D'autres (les arguments cmd et diam) ne le sont pas de façon à ce que list les évaluent, leurs valeurs prendront tour à tour les éléments des listes passée en argument à mapcar soit un symbole (le nom de commande) et un nombre (le diamètre correspondant).

Pour comprendre cette expression, on peut affecter aux arguments cmd et diam les premiers éléments de chacune des listes

(setq cmd 'c:p8 diam 12)

et évaluer l'expression dans la console Visual LISP

(list
 'defun
 cmd
 nil
 (list 'command "_mline" "_j" "_z" "_st" "PVC" "_s" (list 'diamScale diam))
)

ce qui retourne :

(DEFUN C:P8 nil (COMMAND "_mline" "_j" "_z" "_st" "PVC" "_s" (DIAMSCALE 12)))

soit la définition de ta première commande.

Cette expression est évaluée par eval et la commande C:P8 est définie.

mapcar effectue ça tour à tour pour C:P8 et 12, C:P et 16, C:P15 et 20, etc.

Le nil dans la liste est équivalent à (), la liste vide d'arguments et variables des fonctions C:P8, c:P10, etc.

[philsogood]

Re-wahou!!

Encore merci (gile)

je vais passer à la digestion du code mtn

Phil

[VDH-Bruno]

Bonjour philsogood,

 

Même si il n’y a rien à redire sur l’excellente explication de (gile), pour décortiquer ces lignes de codes une petite astuce consiste à substituer le defun par defun-q, cela te permet de définir les fonctions sous forme de liste. Et ainsi comprendre comment construire ta liste de définition en pas à pas.

 

Pour obtenir la définition à construire dans la console Vlisp:

_$ C:P8
(nil (COMMAND "_mline" "_j" "_z" "_st" "PVC" "_s" (DIAMSCALE 12)))

A comparer avec la définition d’origine..

(defun-q c:p8 () (command "_mline" "_j" "_z" "_st" "PVC" "_s" (diamScale 12)))

Ainsi tu visualise mieux que le nil symbolise l’absence d’arguments () dans la fonction définit en C:

 

 

par contre le mapcar, je ne te cache pas (gile) que je suis stupéfait par la simplicité que peut prendre mon code avec l'utilisation de cette fonction

j'ai essayé de voir sur le net des exemples d'utilisation de mapcar mais c'est assez basique (genre

(mapcar '1+ '(2 4 6))

)

Pour des exemples commenté sur l’emploie de mapcar, il y eu un challenge sur son emploie ça peut aider.

http://cadxp.com/topic/14868-challenge-special-debutants/

Sinon il y a toujours le post arguments et variables en entête du forum :

http://cadxp.com/topic/28642-arguments-et-variables/page__view__findpost__p__156096

 

 

(Ps: Personnellement je pense que l’étude de ces lignes de codes apporte beaucoup dans la compréhension du Lisp.)

 

Bon courage

[philsogood]

Merci Bruno,

Je potasse ça dès que j'ai un peu temps libre