fonction de calcul

[Maximilien]

comment créer une fonction de calcul ?

 

je souhaite créer la fonction CALCUL_ECH_TP du type :

 

(setq VAR_ECH_LTYPE (CALCUL_ECH_ECHTP (getvar 'LTSCALE) (getvar 'CELTSCALE) VAR_DP_TXT ConstanteReseau))

 

dois-je faire un (defun CALCUL_ECH_ECHTP ( echelleTPplan , EchelleObj , EchellePlan) ....) ou un (defun c: .....) ou (defun gp ....)

 

cette fonction me permet de calculer mon échelle d'objet courant selon le type de réseau unifilaire que je choisis. pour l'échelle 1/50 VAR_DP_TXT =1, 1/100 VAR_DP_TXT = 3/2 (plan de vérif et/ou de réunion) 1/150 = 2 (VAR_DP_TXT défini par la fonction mathématique y= 0.5+ x/100 )

 

Mon échelle d'objet est donc caractérisée par :

(CELTSCALE (* ( / ( - VAR_DP_TXT 0.5) (* LTSCALE 2) CONSTANTE_RESEAU)

 

où bien sûr, CELTSCALE et LTSCALE ont été choisis pour la compréhension, CONSTANTE_RESEAU représente une constante à appliquer suivant le réseau (exemple pour l'eau froide CONSTANTE_RESEAU =1 et pour l'évacuation CONSTANTE_RESEAU =2)

 

cette fonction me permettra d'économiser en mémoire de la pile ( j'ai 28 type de réseau unifilaire ) * 3 (plafond, plinthe, encastré). (un .LIN a été créé)

 

j'ai créé un fichier .MNU (toujours pour faciliter l'utilisation des différents type de réseau pour les dessinateurs) et .MNL dont ce dernier appellent un LISP (recherche de dossier relatif .\\LSP.AUTOCAD\\FONCTIONS.LSP).

Cette fonction de calcul je vais l'intégrer à ce fichier lisp qui regroupe toutes les fonctions (defun et defun c:) pour la réalistion de nos plans.

 

Pourrait-on m'aider pour ceci,

[didier]

bonjour,

en un mot comme en cent :

pas compris !

désolé de ne pouvoir t'aider

[Maximilien]

je voudrais créer une fonction qui s'utilise comme la fonction cos ou ascii avec plusieurs arguments. de façon à ce qu'elle me retourne une valeur numérique de type réelle.

 

je me réexplique :

 

 

(setq Valeur (

(CALCUL_ECH_ECHTP (getvar 'LTSCALE) (getvar 'CELTSCALE) VAR_DP_TXT ConstanteReseau))

 

comme on fait pour la fonction cos

(setq valeur (cos angleACALCULER))

 

je veux créer la fonction CALCUL_ECH_ECHTP qui retourhe un réel et nom une fonction qui changent les arguments.

Comment dois-je définre cette fonction? un defun, defun c:, defun machin ????

[bonuscad]

je souhaite créer la fonction CALCUL_ECH_TP du type :

 

(setq VAR_ECH_LTYPE (CALCUL_ECH_ECHTP (getvar 'LTSCALE) (getvar 'CELTSCALE) VAR_DP_TXT ConstanteReseau))

 

dois-je faire un (defun CALCUL_ECH_ECHTP ( echelleTPplan , EchelleObj , EchellePlan) ....) ou un (defun c: .....) ou (defun gp ....)

 

Dans ton exemple tu appelle CALCUL_ECH_ECHTP avec 4 arguments , tu dois donc définir ta fonction sous la forme:

(defun CALCUL_ECH_ECHTP (arg1 arg2 arg3 arg4 / var1 var2 varN...)

 

Dans ce cas (getvar "LTSCALE") sera affecté à var1 etc.. (dans l'ordre de soumission)

var1 var2 seront tes variables locales (si il y en a) à ta fonction (calcul_ech_echtp)

 

Voilà pour le début, on verrra la suite si tu cerne déjà cette syntaxe.

[Maximilien]

c'est bien mais comment je fais pour le réaffecter à la fonction ?

 

(setq CALCUL_ECH_ECHTP (resultat)) ? cela ne risque pas de planter?

[bonuscad]

Désolé mais je ne te suis plus :(

 

Tu écris :

(setq VAR_ECH_LTYPE (CALCUL_ECH_ECHTP (getvar 'LTSCALE) (getvar 'CELTSCALE) VAR_DP_TXT ConstanteReseau))

 

J'avais compris, mais maintenant j'ai un doute, que tu voulais affecter à ta variable

VAR_ECH_LTYPE le résultat de ta fonction (CALCUL_ECH_ECHTP) avec arguments à passer à ta fonction.

 

et maintenant tu me parle de :

(setq CALCUL_ECH_ECHTP (resultat))

 

Tu as l'air un peu perdu ;)

 

[Maximilien]

phase déclarative :

(defun CALCUL_ECH_ECHTP

(ARG_LTSCALE ARG_ECH_PLAN CONSTANTE / VAR_RESULTAT)

(setq VAR_RESULTAT

(* (/ (- ARG_ECH_PLAN 0.5) (* ARG_LTSCALE 2))

CONSTANTE_RESEAU

)

)

(setq CALCUL_ECH_ECHTP VAR_RESULTAT)

(princ)

)

 

 

phase d'utilisation :

;; RESEAU Evacuation

(setvar "CELTSCALE" (CALCUL_ECH_ECHTP ((getvar 'LTSCALE) VAR_ECH_TXT 2)))

 

suis-je correct?

[didier]

bonjour,

pour ce faire :

faire un defun classique,

le mettre dans l'Acad.lsp et il sera chargé à chaque lancement,

et reconnu comme une commande.

ciao

[Maximilien]

:(

 

Voilà ce que j'ai eu droit

 

Commande: (setvar "CELTSCALE" (CALCUL_ECH_ECHTP ((getvar 'LTSCALE) VAR_ECH_TXT

2))) ; erreur: fonction incorrecte: 1.0

 

nb de parenthèse c'est ok pourtant

et même avec un rtos

 

Commande: (setvar "CELTSCALE" (rtos (CALCUL_ECH_ECHTP ((getvar 'LTSCALE)

VAR_ECH_TXT 2) 2 5))) ; erreur: fonction incorrecte: 1.0

 

alors ca a pas l'ai de fonctionner ......

[Tramber]

((getvar 'LTSCALE) VAR_ECH_TXT 2)

 

 

 

(getvar 'LTSCALE) est juste après une parenthèse ouvrante, donc évalué comme une fonction, donc, ca plante puisque ca n'est pas une fonction LSP car ca renvoie 1.0 chez moi.

 

[Edité le 19/10/2004 par Tramber]

[Maximilien]

Ouais ben vos eplication ca lmarche pas

 

:Commande: (setq test (calcul_ech_echtp (1 1 2)))

; erreur: fonction incorrecte: 1

 

Commande: (setq test (calcul_ech_echtp 1 1 2))

; erreur: fonction incorrecte: 0.5

 

Commande: (setq test calcul_ech_echtp 1 1 2)

; erreur: erreur de syntaxe

 

Commande: (setq test calcul_ech_echtp(1 1 2))

; erreur: erreur de syntaxe

 

alors comment je réaffecte à la fonctionle résultat?

[Tramber]

:Commande: (setq test (calcul_ech_echtp (1 1 2)))

; erreur: fonction incorrecte: 1

 

1 n'est pas un fonction

 

 

Commande: (setq test (calcul_ech_echtp 1 1 2))

; erreur: fonction incorrecte: 0.5

 

L'erreur doit être dans calcul_ech_echtp (par exemple, (setq CALCUL_ECH_ECHTP ne me semble pas malin.

Fais plutot

(defun CALCUL_ECH_ECHTP
(ARG_LTSCALE ARG_ECH_PLAN CONSTANTE / VAR_RESULTAT)
(setq VAR_RESULTAT
(* (/ (- ARG_ECH_PLAN 0.5) (* ARG_LTSCALE 2))
CONSTANTE_RESEAU
)
)
VAR_RESULTAT
(princ)
)

 

 

 

Commande: (setq test calcul_ech_echtp 1 1 2)

; erreur: erreur de syntaxe

 

calcul_ech_echtp est une fonction, donc on met une parenthèse devant

 

Commande: (setq test calcul_ech_echtp(1 1 2))

; erreur: erreur de syntaxe

 

même remarque, en + il manque un espace

[Tramber]

(defun CALCUL_ECH_ECHTP
(ARG_LTSCALE ARG_ECH_PLAN CONSTANTE / VAR_RESULTAT)

(* (/ (- ARG_ECH_PLAN 0.5) (* ARG_LTSCALE 2))
CONSTANTE_RESEAU
)
)

 

 

+ court encore :P

[Maximilien]

merci Tramber.

[Serge]

Maximilien,

 

Tu semblais hésiter sur la forme à donner à ton code.

 

La forme (defun c:func () ...)

Sert à créer une commande, d'où le c:

 

La forme qui te convient le mieux est:

(defun func () ....)

 

Comme il me semble que tu sois nouveau avec le lisp, je peux imaginer qu'un jour, tu voudras passer plus de paramètres, ou tantôt moins. Sache qu'AutoLISP n'aime pas varier le nombre de paramètres. Tes vieilles routines qui acceptaient 4 paramètres seront désuètes.

 

Voici une proposition:

 

;; La fonction de calcul

(defun le_calcul (

;; Recvoir une liste de paramètres dans une seule variable de type LIST

liste

/ variables_locales param1 param2 param3 param4 param5 return

)

(setq param1 (nth 0 liste))

(setq param2 (nth 1 liste))

(setq param3 (nth 2 liste))

(setq param4 (nth 3 liste))

(setq param5 (nth 4 liste))

 

;; Valeurs par défaut pour compatibilité avec anciennes routines

(if (not param3) (setq param3 1))

(if (not param4) (setq param4 1))

(if (not param5) (setq param5 1))

 

;;; Faire le calcul ici. Ceci est un exemple

(setq return (* param1 param2 (/ (+ param3 param4) param5)))

 

;; Valeur de retour

return

)

 

;; La commande appelante

(defun c:test (

/ arg1 arg2 arg3 arg4 arg5 liste resultat

)

(setq arg1 (getvar "celtscale"))

(setq arg2 (getvar "ltscale"))

(setq arg3 (getvar "psltscale"))

(setq arg4 (getvar "dimscale"))

(setq arg5 (getvar "hpscale"))

(setq liste (list (arg1 arg2 arg3 arg4 arg5)))

 

;; le_calcul reçoit toujours un seul paramètre, mais c'est une liste

(setq resultat (le_calcul liste))

 

(princ "\nLe calcul donne: ") (princ resultat)

(princ)

)

 

 

Serge