VDH-Bruno

Merci pour ton lien (gile) je ne le connaissais pas :D Il est trés bien, beau travail, le meilleur post que j'ai vu sur ce sujet clap clap clap (Ps: je l'archive)

Oui (gile) très juste, merci d’avoir complété, j’avais bien vu pour la différence entre defun et defun-q mais j’ai pas eu le courage d’aller jusque là, car pas certain que j’étais d’intéresser grand monde avec cette subtilité.. Il est vrai que l’illustration avec defun-q aurait été plus judicieuse, car –q rappel l’expression quoté qui est affecté au symbole quoté srec. A+ Bruno

Salut, En faisant une recherché rapide sur le forum tu trouvera facilement beaucoup de sujet similaire, pour toi et rapidement je t’ai trouvé celui-ci Sinon pour les problèmes linguistiquesgoogle ça dépanne bien. Sinon extrait de l’aide R14 quant les fonctions étaient encore traduite..

Bonsoir et bienvenu à toi sur ce forum A+

Bonjour et bienvenu, La consultation des 4 sujets mis en entête et un bon début puis parcourir le forum débutant est pas mal non plus. Il y a des petits codes simples qui peuvent t’inspirer (à copier modifier ect..) puis si certaines lignes posent problèmes, tu peux toujours nous en faire part… Pour mon cas personnel, je n’ai jamais eu de message qui ne soit rester sans réponse.. Cordialement Bruno,

Bonsoir, Voilà quelques lignes de codes prétexte à démontrer la souplesse du lisp, et peut être à aider certains à mieux appréhender ce qu’est un symbole (arguments, variables, expressions, fonctions.. suivant le type de donné référencé), ainsi que les fonctions set quote (ou ‘) et setq. Pour mémoire (setq sym '(expr..)) <=> (set 'sym '(expr..)) Un code classique avec defun (Calcul de la surface d’un rectangle) (defun srec () (alert (strcat (rtos (* (getreal "\nLargeur? ") (getreal "Longueur? "))) " est sa surface!!!" ) ) (princ) ) Qui une fois chargé s’exécute de la manière suivante : Ligne de commande Commande: (srec) Ou console Visual LISP _$ (srec) La fonction srec peut elle même être affectée à un symbole quoté (setq arec '(srec)) que l’on pourrait lancé avec la fonction eval _$ (eval arec) Sur le même principe on pourrait très bien envisager de se passer de la définition de fonction defun (setq srec '(progn (alert (strcat (rtos (* (getreal "\nLargeur? ") (getreal "Longueur? "))) " est sa surface!!!" ) ) (princ) ) ) Qui une fois chargé s’exécute de la manière suivante : Ligne de commande Commande: (eval srec) Ou console Visual LISP _$ (eval srec) (Dans des fichiers de chargement automatique et des boutons de macro c'est transparent et fonctionne comme la fonction defun ;) ). L’intérêt de ces dernières lignes de codes… Aucun, sauf peut être d’apporter un éclairage différent sur la compréhension des symboles et des fonctions associés que sont: set quote setq. - Edit du 01/01/2020 - En complémément vous trouverez Ici un lien plus explicite et détaillé. Cordialement,

Merci (gile) J’avais pas vu ta réponse (seulement le MP), avec toi et Fraid me voilà bien outillé reste plus qu’à potasser :cool: A+ Bruno (Ps hors sujet: Quelqu’un sait me dire pourquoi sur le site à chaque fois que je fais : Menu principal -> Divers -> Donation Je tombe sur une page blanche..)

Grand merci à toi Fraid :D :D :D A+ Bruno

Bonsoir, Si tôt rentré, si tôt téléchargé, merci Fraid :D Je suis déjà entrain de le regarder, bon je suppose qu’il n’y a pas d’évolution notable entre les versions 2004 et 2010, sinon au risque de passer pour un pinailleur, le fichier existe t’il sur un autre support qu’en PDF (genre HTML ou word). Je m’explique, comme je ne suis pas anglophone lorsque je détecte une info qui me semble essentielle habituellement je fais un copier coller dans google pour la traduction ou je demande directement la traduction de la page (dans le cas de page html)… Le problème c’est qu’avec Acrobat reader je ne sais pas faire un copier collé, la seule astuce que j’ai trouvé c’est d’enregistrer en txt, et j’avoue que sans la mise en forme je rame un peu pour traduire les passages qui m’intéressent.. Si quelqu'un sait me dépaner j'en serai heureux, sinon tant pis je ferai sans. Merci,

Bonjour, Oui je serai également intérressé par tes fichiers (gile), mes versions antérieur tournant sous LT.. Car je compte bien m'interresser à l'interface COM/ActiveX des mon retour.. Pour l'instant je me consacre à un autre dialecte tout en fesant une cure de soleil ;-) Au cas ou il ne serai pas possible d'héberger ces fichiers, voici mon mail: bruno.lsp@hotmail.fr Merci,

Salut, Ravis que cela te convienne, toute fois on peut encore parfaire un petit peu mieux son fonctionnement en lui introduisant une gestion d’erreur. Je m’explique dans ta routine 2 chemins sont possibles : Soit elle s’exécute jusqu’à son terme et la pas de problème (toutes tes variables sont réinitialisées) ou alors tu quittes (touche échap) avant terme et là tes variables AutoCAD ne sont pas réinitialisées (plus d’accroche objet, calque trame devient le calque courant ect..). En ce sens la fonction prédéfinie *error* peut t’aider (voir ici), car rien ne t’empêche de la redéfinir localement, elle a la particularité d’être systématiquement évalué en cas d’interruption de ta routine. Pincipe de construction d’une gestion des erreurs Etape 1 : Pour plus de clarté, on pourrait regrouper dans des fonctions spécialisés la sauvegarde et la restitution des valeurs par défaut des variables AutoCAD, un peu sur ce principe : ;; Sauvegarder les variables AutoCAD (defun svgvar () (setq cc (getvar "clayer") cmd (getvar "cmdecho") osm (getvar "osmode") cec (getvar "cecolor") ) ) ;; Restaurer les variables AutoCAD (defun resvar () (setvar "clayer" cc) (setvar "cmdecho" cmd) (setvar "osmode" osm) (setvar "cecolor" cec) ) Note : La fonction svgvar ne se justifie pas vraiment contrairement à resvar (c’est juste pour le principe) Etape 2 : Puis écrire ta routine d’erreur qui s’exécutera automatique en cas de besoin. Tu peux en gros la construire sur ce modèle : ;; Redéfinition de la fonction *error* (defun *error* (msg) (princ (strcat "\nErreur : " msg)); renvoie un msg d'erreur (resvar) ; Restore les variables AutoCAD (princ) ; Quitte silencieusement ) En fait la fonction *error* ne fait que reprendre les actions que ton programme n’a pu mener à terme. Etape 3 : Et enfin intégrer tout cela dans ta routine principal de la façon suivante : Déclarer les fonctions dans ta fonction principal, très important surtout pour t’assurer que la redéfinition de la fonction *error* reste localisé à ta routine. (defun C:TM (/ cc cmd osm cec pt svgvar resvar *error*) Puis en début de programme ajouter cette ligne pour sauvegarder la valeur des variables (svgvar) Et celle-ci en sortie pour restituer tes variables AutoCAD (resvar) Code finalisé: Maintenant ton code finalisé pourrait ressembler à ça : (defun C:TM (/ cc cmd osm cec pt svgvar resvar *error*) ;; Sauvegarder les variables AutoCAD (defun svgvar () (setq cc (getvar "clayer") cmd (getvar "cmdecho") osm (getvar "osmode") cec (getvar "cecolor") ) ) ;; Restaurer les variables AutoCAD (defun resvar () (setvar "clayer" cc) (setvar "cmdecho" cmd) (setvar "osmode" osm) (setvar "cecolor" cec) ) ;; Redéfinition de la fonction *error* (defun *error* (msg) (princ (strcat "\nErreur: " msg)) ; renvoie un msg d'erreur (resvar) ; Restore les variables AutoCAD (princ) ; Quitte silencieusement ) ;; Début du programme principal (svgvar) (setvar "cmdecho" 0) (setvar "osmode" 0) (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "") (setvar "cecolor" (itoa (acad_colordlg 256))) (while (setq pt (getpoint "\nCliquez dans la zone à Hachurer (Entrez pour quitter):" ) ) (command "_.bhatch" "_properties" "solid" "_draw" "_back" pt "") ) ;; Sortie du programme principal (resvar) (princ) ) Voilà on peut faire plus sophistiqué ( ce à quoi je m’exerce en ce moment) mais dans ce cas cela ne se justifie pas vraiment. Je pense que c’est déjà une bonne base pour commencer, qui sait après mon retour de congés, j’essaierai peut être de faire un topic «mécanique de la gestion d’erreur». Il y a déjà beaucoup de post sur le sujet pas sur qu’il soit judicieux d’en faire un de plus, à voir... En espérant avoir été suffisamment explicite. Cordialement, (Ps: Toutes remarques ou complément est le bienvenu) Edit du 18/11/2011 : Rétablie le lien référençant l’article de (gile) sur la fonction *error* dans le post Arguments et Variables.

Salut, Rassure toi je n’en n’ai pas tant que cela en Lisp disons seulement que ça m’intéresse, et c’est ton jour (ou nuit) de chance j’ai un peu de disponibilité.. Je pense que la fonction acad_colordlg devrait répondre à ton besoin de souplesse (évitant la multiplication de macro) dans le choix de la couleur de ta trame. Elle permet d’afficher la boîte de sélection de couleur et renvoie un nombre compris entre 0 et 256 (ou nil) correspondant à la couleur sélectionnée. De plus la variable CECOLOR devrait également t’intéresser, elle va permettre de t’affranchir de la syntaxe suivante : (Command "CHPROP" "D" "" "CO" "91" "") Qui ne fait que forcer la couleur de la dernière entitée créé ( si tu code avec command je t’invite grandement à t’intéresser aux variables système, tu y trouvera très souvent ton bonheur de plus cela t’apportera beaucoup dans la maîtrise d’AutoCAD) Version du code avec pochage multiple et choix de la couleur (pour le principe): (defun C:TM (/ cc cmd osm cec pt) (setq cc (getvar "clayer") cmd (getvar "cmdecho") osm (getvar "osmode") cec (getvar "cecolor") ) (setvar "cmdecho" 0) (setvar "osmode" 0) (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "") (setvar "cecolor" (itoa (acad_colordlg 256))) (while (setq pt (getpoint "\nCliquer dans la zone à Hachurer (Entrée pour quitter):" ) ) (command "_.bhatch" "_properties" "solid" "_draw" "_back" pt "") ) (setvar "clayer" cc) (setvar "cmdecho" cmd) (setvar "osmode" osm) (setvar "cecolor" cec) (princ) ) A+ Bruno

Bonsoir, Si tu permets, il y a encore 2 ou 3 petites améliorations possible pour ta macro. Pour rester dans la logique de ta routine (sans écrire une routine d’erreur), pour cmdecho, tu peux reprendre la syntaxe utilisé pour sauvegarder clayer du type : ;;svg des variables (setq cc (getvar "clayer") cmd (getvar "cmdecho") ) ;; configuration des variables (Setvar "cmdecho" 0) …. ;; mon programme …. …. ;; restitution des valeurs (setvar "clayer" cc) (setvar "cmdecho" cmd) Rappel : dans la fonction command (comme sur la ligne de commande) il est tout à fait possible de répondre aux invites par une instruction Lisp, dans ce cas la fonction getpoint pourrait t’interesser (et à l’usage tu te rendras compte que les fonctions getxxx avec initget sont plus confortable que l’utilisation de princ / pause). Pour résumer ton programme pourrait également s’écrire comme cela : (defun C:TM (/ cc cmd) (setq cc (getvar "clayer") cmd (getvar "cmdecho") ) (Setvar "cmdecho" 0) (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "") (command "_.bhatch" "_properties" "solid" "_draw" "_back" (getpoint "\nCliquer dans la zone a Hachurer : ") "" ) (setvar "clayer" cc) (setvar "cmdecho" cmd) (princ) ) ;_ Fin de defun Et comme je suppose que tu n’a pas qu’une zone à pocher soit tu lance la commande multiple avant d’appeler ta fonction tm ou alors tu peux simplement créer une boucle dans ton programme avec sur la valeur de retour de la fonction getpoint . Voici une autre version possible de ta routine pour des pochages multiples. (defun C:TM (/ cc cmd osm pt) (setq cc (getvar "clayer") cmd (getvar "cmdecho") osm (getvar "osmode") ) (setvar "cmdecho" 0) (setvar "osmode" 0) (command "_.layer" "_make" "Trames" "_color" 253 "Trames" "") (while (setq pt (getpoint "\nCliquer dans la zone à Hachurer (Entrée pour quitter):" ) ) (command "_.bhatch" "_properties" "solid" "_draw" "_back" pt "") ) (setvar "clayer" cc) (setvar "cmdecho" cmd) (setvar "osmode" osm) (princ) ) Cordialement,

Bonsoir, A la relecture, je me suis aperçu que je n'avais pas pris le soin de publier mes codes: Version du triangle de pascal de mon premier message modifié pour mémoriser tous les appels de 0 à n, sur le principe d'un accumulateur (notion entrevu sur la récursion terminal) stockant tous les retours d'appel de la fonction f1. (defun triPascal (n / f1 f2) (defun f1 (l n) (if (< 0 n) ((lambda (x) (cons x (f1 x (1- n))) ) (f2 l) ) ) ) (defun f2 (lst) (append '(1) (mapcar '(lambda (x y) (+ x y)) lst (cdr lst)) '(1) ) ) (cons '(1) (f1 nil n)) ) Ou de façon plus concise (en supprimant la factorisation de f2): (defun triPascal (n / f1) (defun f1 (l n) (if (< 0 n) ((lambda (x) (cons x (f1 x (1- n))) ) (append '(1) (mapcar '(lambda (x y) (+ x y)) l (cdr l)) '(1) ) ) ) ) (cons '(1) (f1 nil n)) ) Console Visual LISP _$ (trace triPascal f1) F1 _$ (triPascal 4) ((1) (1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1)) _$ Fenêtre de Suivi Saisie (TRIPASCAL 4) Saisie (F1 nil 4) Saisie (F1 (1 1) 3) Saisie (F1 (1 2 1) 2) Saisie (F1 (1 3 3 1) 1) Saisie (F1 (1 4 6 4 1) 0) Résultat: nil Résultat: ((1 4 6 4 1)) Résultat: ((1 3 3 1) (1 4 6 4 1)) Résultat: ((1 2 1) (1 3 3 1) (1 4 6 4 1)) Résultat: ((1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1)) Résultat: ((1) (1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1)) C'est vrai que la programmation qualifiée de fonctionnel à un côté ludique et fascinant.. En tout cas cela aura été une discussion trés enrichissante, merci A+ (Ps: Si j'ai bien suivie la prochaine étape sont les fonctions dites d'ordre supérieur). <font class=edite>[Edité le 17/2/2011 par VDH-Bruno]</font>

Bonsoir, (gile) merci encore pour ce complément et de tous ce que tu donne en général sur ce forum. Je vais décortiquer tout cela avec grand intérêt. ;)

Bonsoir, J’ai enfin réussi à sortir la tête du trou sur un plan professionnel, ce qui m’a permis de retravailler les codes de (gile) et ceux proposés sur the swamp. Et je viens enfin de comprendre la ligne suivante, (que j’avais à tord survolé et copié par mimétisme) ( (lambda (x) (cons x (f1 x (1- n))) ) (f2 l) ) Pour résumer une subtilité (que j’ignorai) sur l’emploi de lambda seul, et qui n’apparaît pas clairement dans les exemples de l’aide (exemples illustrés avec mapcar et apply). 1- Pour exécuter lambda seul, il faut l’envelopper de parenthèses (lambda () (alert "Bonjour !!!")) ; retourne #<USUBR @186838c0 -lambda-> [b] ([/b] (lambda () (alert "Bonjour !!!")) [b] ) [/b]; fonctionne A bien y regarder c'est normal suffit de comparer l'expression avec la syntaxe utilisé pour évaluer une fonction définie avec defun: (defun bonjour () (alert "Bonjour !!!") ) $ (bonjour) nil _$ 2- Pour passer un paramètre sans apply ou mapcar (c’est tout bête une fois qu’on le sais) ( (lambda (x) (* x x)) 3 ); retourne 9 3- L’exemple suivant fournie dans l’aide (apply '(lambda (x y z) (* x (- y z)) ) '(5 20 14) ) ; renvoie 30 Peut donc également s’écrire de la façon suivante ((lambda (x y z) (* x (- y z)) ) 5 20 14 ) ; renvoie 30 A la lueur de cette récente découverte (qui très certainement n’avait pas échappé à la plupart d’entre vous), je vais pouvoir traquer les vilaines variables des quelques codes que n’avais pas réussie à programmer de façon fonctionnelle. Cordialement Bruno,

Salut, (gile), En ce qui me concerne, tu ne le déterre pas vraiment, ce sujet fait toujours partie de mon actualité. Mais une grosse activité professionnel de début d’année ne me permet pas en ce moment de me dégager le temps nécessaire.. que je souhaiterais pour approfondir ce type de thème. Mais dés que je pourrai, j’y reviendrai en attendant je te remercie d’avoir eu une pensé pour nous à l’occasion de ton rangement :) .

Oui ! Jolie coup ton algorithme.. :D Je vais suivre cela avec interet, Sinon pour faire suite à ta remarque En ce qui me concerne c’est quelque chose de très visuelle (et pas abstraite comme j’ai pu le lire), en gros pour imager, ça me fait penser aux poupées russe. D’ailleurs le lisp avec ses parenthèses imbriqués enveloppant une fonction, qui enveloppe une fonction (ou liste) etc.. C’est tout à fait le jeu des poupées russe et je comprends mieux cette notion de langage définit récursivement. Et ce concept de « cellule cons » pour représenter une liste de symbole, qui peuvent être une fonction ou une donnée. Facilement représentable en « arbre binaire » c’est également une bonne représentation visuelle de la chose. Autre avantage du Lisp, avec les fonctions cdr, car, cons, et quelques autres, additionner à quelques opérateurs mathématiques cela suffit pour venir à bout de problèmes relativement ardus (sans avoir besoin de mémoriser une quantité astronomique de fonctions) . Tout cela me parle (donc m’intéresse), faut dire que j’ai une structure mental très visuel et mes années passer en tant que projeteur n’ont pas arrangé les choses.., pour solutionner un problème il faut que je puisse le visualiser, quant j’y arrive il m’arrive de frôler le génie (hélas dans le cas contraire je peux également passer pour le dernier des crétins..) Pour l’anecdote je peux assez facilement visualiser l’ensemble d’un projet commercial sans pour autant parvenir à mémoriser le numéro de l’affaire en cour, de même pour l’histoire de France et tout un tas d'autre chose.. En ce qui concerne la programmation qualifié d’impérative (si j’ai bien compris cette notion), bizarrement j’avoue avoir plus de difficulté, mais le problème vient certainement de moi car quant je tente ce type d’approche, j’ai la fâcheuse tendance à coder avant même d’avoir posé clairement le problème que je cherche à solutionner.. Et donc j’ai tendance à bidouiller à chaques nouvelles difficultés, pour finalement tous réécrire une fois le code achevé (lorsque j’y arrive et que j’en ai encore le courage..). En ce qui concerne Calm (dont F# en est une adaptation), j’y songe (rien ne presse) cherchant à m’initier à l’algorithmie, j’ai découvert ce site http:// http://www.france-ioi.org/, et visiblement les solutions proposé sont souvent implémenté dans ce dialecte très proche du Lisp (même si l’absence de parenthèses me perturbe quelque peu..) De plus connaissant la politique de mon entreprise je ne serai pas étonné de repasser sur une version LT dans un futur proche, le fait de travailler sur une version pleine relevant plus d’un concours de circonstance qu’autre chose.. Comme toi j’ai également eu une initiation à la programmation à l’IUT, il y a plus d’une quinzaine d’année. Il ne m’en ait strictement rien resté (je n’étais pas spécialement brillant), du pascal ou un dialecte basic je crois ? Un dinosaure trainant parfois sur ce forum pourrai le confirmer.. (si je ne fait pas une erreur sur la personne). A+ <font class=edite>[Edité le 14/1/2011 par VDH-Bruno]</font>

Super, :D :D :D Merci (gile), une fois de plus tu as parfaitement compris ou je voulais en venir avec mon code en parlant de programmation fonctionnelle que je m’efforce de maîtriser. Avant de lire tes réponses, j’avais continué à chercher pour sub2, je m’en suis aperçu que ce je voulais écrire n’étais qu’une imbrication de boucles codé récursivement. J’étais arrivé a ça (quasiment pareil que toi, mais en moins): (defun sub2 (lst) (if (cdr lst) (cons (+ (car lst) (cadr lst)) (sub2 (cdr lst))) ) ) Je vois que tu as également précédé ma question de l’étape suivante, mémoriser tous les appels de 0 à n. Je ne peux hélas pas en dire autant, je ne suis pas arrivé à franchir l’obstacle sans faire un bidouillage en introduisant des variables dans mon code (donc plus en fonctionnelle). J’avais bien essayé une fonction à 2 arguments comme ta fonction f1 sans grand succès, merci pour ton code je vais étudier tout cela de prés. En prime un code en F#, que je vais archiver car j’ai posté la question Qu’elle version me conseilleriez-vous ? sur un autre forum, vu l’absence des réponses, je me suis demandé si il ne vaudrait pas mieux pour moi que je m’essaie à Calm ou OCalm (je ne sais pas ce qui est le mieux) pour ce que je souhaite faire. Il y a visiblement de la doc et des tut en français, mais dans ce cas ce sera un peu plus tard car les math, l’algoritmie et le Lisp m’occupent suffisamment, et je ne me vois pas apprendre une nouvelle syntaxe pour le moment :casstet: .

Bonsoir, Je développe un peu, pour que vous puissiez comprendre un peu mieux, ce à quoi je m’exerce : L’intérêt éventuelle d’une telle fonction (triangle de pascal) outre le développement des identités remarquables, c’est de renvoyer le nombre de combinaison simple en utilisant la méthode graphique des coefficients binomiaux (et vice versa). Application Calcule du nombre de combinaison (nCp) simple de p élément choisis parmi n. (rappel : p et n sont les coefficients binomiaux). Pour une liste ‘(A B C D E F G H) on veut connaître le nombre de combinaison simple de 4 éléments distincts. Par la formule mathématique : nCp = n! / (p! (n-p)!) (note on peut certainement faire mieux en triturant le code de façon à fusionner les fonctions fact & nCp, pour ne pas calculer 3 fois la factorielle, mais seulement les opérations complémentaires). Code : (defun fact (n) (if (zerop n) 1 (* n (fact (1- n))) ) ) (defun nCp (n p) (if (< n p) nil (/ (fact n) (* (fact (- n p)) (fact p))) ) ) (nCp (length '(A B C D E F G H)) 4); retourne 70 (nCp (length '(A B C D E F G H)) 20); retourne nil Par la méthode graphique des coefficients binomiaux. (Notez que dans ce cas il n’est même pas judicieux d’écrire une fonction nth suffi) Code (defun nCp (n p) (nth p (TPascal n)) ) (nCp (length '(A B C D E F G H)) 4); retourne 70 (nCp (length '(A B C D E F G H)) 20); retourne nil Explication de mon intérêt à maîtriser les appels de fonctions récursives imbriqués Actuellement je travaille pour mes besoins à combler mes lacunes en mathématique (essentiellement dans le domaine du dénombrement, pour le moment..) et par la même j’essaye de m’initier à l’algorithmie (autre point faible) Pour crever l’abcès une bonne fois pour toutes, j’ai entrepris depuis quelques jours d’écrire une petite bibliothèque de routines (que je publierais surement) portant sur les problèmes de permutations, d’arrangement et de combinaisons de listes (version simples et à répétitions). Cerise sur le gâteaux, j’ai entrepris de tout programmer de façon fonctionnel.. histoire de consolider mes connaissances et d’acquérir de l’aisance. D’où l’intérêt pour moi de maîtriser ce type de structure.. , que je retrouve systématiquement (suffit de voir les fonctions combi de (gile) pour s’en convaincre). (Ps : Depuis mon immersion dans le dénombre et la combinatoire, je ne pense plus avoir de problème pour ranger mes chaussettes dans un tiroir, ni pour répartir des grenouilles dans des étangs.. :casstet: merci aux matheux et à leurs exemples.. :exclam: )

Bonjour, Voilà je bute toujours sur le même problème pour résumer : Faire des fonctions récursive simple du type (fonc (-1 nbr)) ou (fonc (cdr lst)), c’est Ok Faire des fonctions récursive multiple du type (append (fonc (car lst)) (fonc (cdr lst))), c’est Ok Par contre si c’est pour des fonctions récursives imbriqué (type fonction combi3 de (gile)), c’est laborieux bien souvent je contourne le problème avec l’introduction d’une variable (Cf chalenge 33) ou l’utilisation de mapcar si c'est possible. Je n'arrive pas à formuler clairement un raisonnement impliquant l’imbrication de fonction récursif (problème d’algoritmie et de méthode sans doute). Pour illustrer mon problème je me propose de vous montrer mon code pour renvoyer le développement de la ligne du triangle de pascal suivant un indice n. Triangle de Pascal (rappel) n=0 (1) n=1 (1 1) n=2 (1 2 1) n=3 (1 3 3 1) n=4 (1 4 6 4 1) ect.. Tentative d’écriture de l’agorithme (certainement maldroite, je débute également en la matière..) L’exécution prend fin pour n=0 et renvoi la liste 1 (condition d’arret) Passage de n à n+1 (sub 1) Ajouter élément 1 en début et fin de liste Si la liste à un second terme (n>0) Calcule les coefficients intérieur (sub 2) Prendre le premier terme de la liste n puis lui ajouter le second etc jusqu'à la ce qu’il n’y est plus de second terme. (condition d’arret) Mon code factorisé pour plus de lisibilité (defun TPascal (n / sub1 sub2) (defun sub2 (lst) (mapcar '(lambda (x y) (+ x y)) lst (cdr lst)) ) (defun sub1 (n) (cond ((= 1 n) '(1 1)) ; n = 1 (T (append '(1) (sub2 (sub1 (1- n))) '(1))) ; n+1 ) ) (if (zerop n) '(1) ; n = 0 (sub1 n) ) ) (TPascal 3) ; retourne (1 3 3 1) Ok Le code fonctionne bien, il est même bien écrit (je pense) mais encore une fois j’ai contourné mes difficultés dans l’écriture de sub2 (que je voulais coder récursivement). Ce qui m’a obligé à adapter mon algorithme en posant la condition d’arrêt dans sub1 à n=1, pour avoir une valeur de retour acceptable pour sub2. Mes questions : Comment formuler sub2 de façon récursive.. (de façon fonctionnel) ? Y a-t-il un défaut dans mon raisonnement, si oui lequel (je serai heureux de le comprendre). En espérant ne pas être trop confus, merci. (Ps : Par la suite je pense m’intéresser à la symétrie axiale du triangle pour éventuellement optimiser sa construction, et également mémoriser tous les appels de 0 à n)

Bonsoir, Comme toi Fraid, je songe de plus en plus à m’intéresser à l’environnement COM/ActiveX Automation, au regard de certains codes que je vois circuler et qui me sont encore inaccessible (au passage j’en profite pour te remercier pour ton aide sur setenv & getenv). Mais quant je lis la réponse de (gile), je me dis que je vais consolider un peu encore mes connaissance en Lisp, et en attendant collectionner les sujets comme celui-ci concernant ce thème car le palier ne me semble pas évident à franchir.. Cela va demander un gros investissement personnel et des heures de sommeil en moins.. (surtout que l’aide fr de la R14 ne contient pas ces chapitres), pour assimiler une philosophie qui me semble complètement différente de celle déjà entrevu.. Bon courage à toi

(gile), J’ai creusé un peu l’histoire du fichier chm, et j’ai observé un comportement «rigolo» sur mon poste avec le zip windows standard, si je décompresse le zip : Bouton droit -> Extraire tout –> Assistant Extraction –> Création du répertoire Test_Standard La dll fonctionne mais pas le chm :mad: (ouverture directement et appelles depuis la boite de dialogue, chm copier dans le répertoire de recherche évidemment ;) ) Double clic- Fenêtre d’exploration puis glissé-déposer vers le répertoire de destination Le chm s’ouvre :D (boite de dialogue et ouverture directe). Voilà pour le retour d’info [Edité le 4/1/2011 par VDH-Bruno]

Oui (gile), je bataillais avec pour répondre (première utilisation). Sinon très sympa ce petit utilitaire, j’ai pas testé en profondeur mais tout semble Ok, au passage c’est la première fois que je chargeais une dll, ça m’a rappelé avec nostalgie le jour ou j’ai chargé un lisp pour la première fois (Sur V11), alors merci ;-) (Ps : Le fichier d’aide chm ne fonctionne pas chez moi)

(gile) pour compléter ma réponse si cela peut aider... Entre temps j'ai testé les zip de ta page perso effectivement j’ai bien un soucis de décompression sur mon micro que je n’avais pas remarqué auparavant pour les avoir jusqu’ici décompressé avec Winrar à mon boulot. Autre remarque pour me rassurer je viens de décompresser avec succès les cours de Lisp proposé par usegomme sur le forum débutant. Voilà, à ta disposition si tu souhaites d’autre précision..