Faire une routine qui retourne des valeurs dans des...

[Aleck_Ultimate]

Bonjour à tous.

 

Imprévue, quant tu me fait trébucher sur la ligne d'arrivée... trois-quatre fois par jours...

 

J'ais créé une routine qui est sensée me fournir trois atomes différents. Je suis partit sur l'idée que les nom des variables dans lesquelles seront stockés ses atomes seraient entrés comme argument à defun comme ceci : (defun routine (nom_var_1 nom_var_2 nom_var_3 /) sauf que je me retrouve incapable de faire ça.

 

Le reste de mon LISP a l'aire de fonctionner correctement quant je l'exécute morceaux par morceaux, donc ce serait ça qui fait qu'après le lancement de la routine en tant que commande les variables nommées en argument me retournent nil au lieu des valeurs qu'elle sont sensées me retourner.

 

D'une certaine façon c'est logique vue que les argument sont traités comme des variables locales, mais je n'arrive pas à en faire des globales pour la routine qui deviendront des locales dans le LISP dans lequel on l'utilise.

 

J'ais bien pensé à faire trois routines, mais outre le fait que ça les rendrait moins ergonomiques à utiliser ça alourdirait aussi beaucoup le code car la création de mes trois arguments (deux chaines et une liste) sont très imbriqués, d'où redondance d'un certain nombre de calcules. Et au moins une journée de plus (pour moi, débutant) nécessaire à l'opération de séparation des siamois.

 

J'espère ne pas avoir été trop brouillon dans mes explications.

 

Merci de votre aide.

[(gile)]

J'espère ne pas avoir été trop brouillon dans mes explications.

 

Je crains que si...

En tout cas, personnellement, je n'ai rien compris.

 

Je pense que si on n'arrive pas à exprimer clairement un problème dans sa langue maternelle, on aura beaucoup plus de mal à le transcrire dans un langage de programmation.

 

Je te recommande (re)lire attentivement ce sujet (au moins les premières réponses) et d'essayer de poser correctement ton problème avec ce qui permet de "parler" à une machine, à savoir : de la rigueur et de la logique.

[x_all]

je ne connaissait pas ce post...

merci pour la leçon. Reste à mettre en application...

serai il possible de retrouver les liens vers les exemple du message 10?

[Aleck_Ultimate]

J'ais tout relue jusqu'à mapcar et lambda (après j'ais décroché), mais à part me rendre compte qu'il y a peut-être dans mon code une boucle que je pourrait remplacer par mapcar il n'y a pas de réponse à ma question.

 

Si je n'ais pas mis mon code en entier c'est parce que 99% ne sont pas important dans cette question, mais je vais en détailler la structure, ou plutôt la structure de ce que je veut avoir.

 

Structure de la routine :

 

(defun routine (arg_1 arg_2 nom_var_1 nom_var_2 nom_var_3 /)


du code construisant chn_1 chn_2 et liste_1 à partire de arg_1 et arg_2


définir globalement (par rapport à routine) chn_1 dans var_1 (nommée par l'utilisateur en nom_var_1), chn_2 dans var_2 et liste_1 dans var_3

)

Structure du code en entier :

 

(defun c:commande (/ routine var_1 var_2 var_3)
   
du code...

(routine arg_1 arg_2 nom_var_1 nom_var_2 nom_var_3)

Utilisation de chn_1, chn_2 et liste_1 stoqués dans les variables var_1 var_2 et var_3 crées par (routine)

)

Plus concrètement, je voudrait créer trois variables globales à la routine utilisées localement dans la commande.

 

Mais je voudrait que l'utilisateur de la routine puisse donner le nom qu'il vaut aux variables dans lesquelles seront toquées les trois résultats des calcules de la routine (pour qu'il ne soit pas obligé d'utiliser dans son code précisément les nom des variables que j'aurais déclarée globalement dans la routine, question d'ergonomie)

 

Et je voudrais aussi éviter d'avoir à créer trois routines différentes qui seraient utilisées sous cette forme :

 

(setq 
var_1 (routine_1 arg_1 arg_2)
var_2 (routine_2 arg_1 arg_2)
var_3 (routine_3 arg_1 arg_2)
)

pour des raisons d'ergonomie mais surtout pour éviter de refaire trois fois un certain nombre de calcules, qui peuvent potentiellement être très lourds selon la façon dont est utilisée la routine. Un peut comme pour la notion de l'inachevé de Didier, tant que je peut faire mieux je le fait. Du moins j'essais, et je réussit modérément.

 

Merci.

[Patrick_35]

Salut

 

Par exemple

(defun c:test(/ routine_1 routine_2 routine_3 routine_4 var1 var2)

 (defun routine_1(arg1 arg2 / var1)
   (setq var1 (+ arg1 arg2))
 )

 (defun routine_2(arg1 arg2 / var1)
   (setq var1 (- arg1 arg2))
 )

 (defun routine_3(arg1 arg2 / var1)
   (setq var1 (* arg1 arg2))
 )

 (defun routine_4(arg1 arg2 / var1)
   (setq var1 (/ arg1 arg2))
 )

 (setq var1 10)
 (setq var2 10)

 (alert (strcat "Résultat de routine_1 : " (itoa (routine_1 var1 var2))))
 (alert (strcat "Résultat de routine_2 : " (itoa (routine_2 var1 var2))))
 (alert (strcat "Résultat de routine_3 : " (itoa (routine_3 var1 var2))))
 (alert (strcat "Résultat de routine_4 : " (itoa (routine_4 var1 var2))))
 (princ)
)

 

Ou plus simplement

(defun c:test(/ routine_1 routine_2 routine_3 routine_4 var1 var2)

 (defun routine_1(arg1 arg2)
   (+ arg1 arg2)
 )

 (defun routine_2(arg1 arg2)
   (- arg1 arg2)
 )

 (defun routine_3(arg1 arg2)
   (* arg1 arg2)
 )

 (defun routine_4(arg1 arg2)
   (/ arg1 arg2)
 )

 (setq var1 10)
 (setq var2 10)

 (alert (strcat "Résultat de routine_1 : " (itoa (routine_1 var1 var2))))
 (alert (strcat "Résultat de routine_2 : " (itoa (routine_2 var1 var2))))
 (alert (strcat "Résultat de routine_3 : " (itoa (routine_3 var1 var2))))
 (alert (strcat "Résultat de routine_4 : " (itoa (routine_4 var1 var2))))
 (princ)
)

 

@+

[VDH-Bruno]

je ne connaissait pas ce post...

merci pour la leçon. Reste à mettre en application...

serai il possible de retrouver les liens vers les exemple du message 10?

 

Bonjour x_all,

 

Dans le même sujet regarde le message #22

 

Salutations

[Aleck_Ultimate]

Je suis vraiment trop con. C'est aussi simple que pour substr dans ce poste là, vous vous souvenez ? Couper une chaine à partir d'un groupe de caractères

 

Puisque une routine ne peut retourner qu'un seul atome à la fin, il me suffit de faire tout à la fin :

 

(list "chaine 1" "chaine 2" '(liste 1)) 

et il appartient à l'utilisateur de ressortir ce qu'il lui faut avec car, cadr et caddr comme pour des coordonnées 3D, le truc basique.

 

Tellement simple que même les pro n'y ont pas pensés.

A moins que j'ais vraiment été nul pour expliquer mes besoins ce qui est bien plus probable

Soit dit sans aucun sarcasme, merci beaucoup pour votre aide

 

C'est quand même à force de relire vos réponses que j'ais trouvé la mienne.

[Patrick_35]

Tellement simple que même les pro n'y ont pas pensés.

Si, mais la demande est tellement claire que les réponses résultent de ce que l'on a pu déduire.

[Aleck_Ultimate]

Désolé, je ne voulait vraiment pas être blessant.

 

J'ais bien mis A moins que j'ais vraiment été nul pour expliquer mes besoins ce qui est bien plus probable

[(gile)]

Puisque une routine ne peut retourner qu'un seul atome à la fin, il me suffit de faire tout à la fin :

 

(list "chaine 1" "chaine 2" '(liste 1)) 

 

L'essentiel du langage LISP (tous dialectes confondus) est régit par trois règles :

• un programme LISP est une liste d'expressions ;
  
• une expression peut être un atome ou une liste d'expressions (récursion) ;
  
• un atome est soit : un nombre, un nom, une chaîne de caractères, un opérateur.
  

 

Donc, comme dit plus haut, un minimum de rigueur est nécessaire pour se faire comprendre par des humains (ceux à qui tu demandes de l'aide) et a fortiori par une machine.

Le vocabulaire est la base de cette rigueur, et pour moi, l'orthographe importe aussi. À partir d'un certain nombre de fautes, je décroche.

[Aleck_Ultimate]

À partir d'un certain nombre de fautes, je décroche.

Décidément je vais de désillusion en désillusion sur mes propres compétence ses derniers temps... effectivement, après relecture de mes cours je me suis rendu compte que j'utilisais le terme d'atome pour parler d'expression, les atomes étant toute les expressions excepté les listes.

 

Pour ce qui est de l'orthographe, que ce soit en LISP ou en français je fait des efforts, mais j'ais beaucoup de difficultés avec le français écrit et je ne suis pas encore très familier du codage, et beaucoup de fautes m'échappent même après plusieurs relectures malgré tout, désolé pour ça.

[x_all]

sur ce coup, je suis avec toi... :)