Premiers pas avec foreach

[VDH-Bruno]

Bonjour,

 

En ce moment je finalise mon premier "programme" (que j’espère pouvoir publier prochainement), j’en suis au stade de l’affichage (exploitation) des résultats.

 

Actuellement je suis arrivé à ce stade :

  (foreach element '((1 . 9.55)
	   (2 . 9.75)
	   (2 . 10.0)
	   (1 . 11.0)
	   (2 . 11.25)
	   (1 . 11.50)
	  )
 (print element)
) 

 

Ce qui me retourne

_$

 

(1 . 9.55)

(2 . 9.75)

(2 . 10.0)

(1 . 11.0)

(2 . 11.25)

(1 . 11.5)

(1 . 11.5)

_$

En me doublant la dernière valeur qui correspond à la valeur de renvoi de la fonction foreach (Même si je n’en suis pas très heureux, c’est pas le point qui me préoccupe le plus)

 

La séquence de code qui me pose le plus de problème et la suivante :

  (foreach element '((1 . 9.55)
	   (2 . 9.75)
	   (2 . 10.0)
	   (1 . 11.0)
	   (2 . 11.25)
	   (1 . 11.50)
	  )
 (strcat "\n" (itoa (car element)) "…….\t" (rtos (cdr element)))
)

 

Le code ci dessus me renvoie la dernière expression évaluée qui me semble correcte

"\n1…….\t11.5"

 

Ma question est la suivante : (Je vous épargne toute les séquences de codes que j’ai testés)

Comment formuleriez vous (de façon élégante) l’expression :

 (strcat "\n" (itoa (car element)) "\t" (rtos (cdr element)))

De façon à stocker le déroulement effectué par foreach dans une variable (j’espère être suffisamment explicite).

 

Pour info : par la suite je pense offrir la possibilité d’enregistrer le résultat sous excel comme le fait la routine long_line de (gile).

 

Merci,

 

Ps : Bien sur la liste de valeurs est fourni à titre d’illustration dans ma version final ce sera une variable.

 

 

 

 

[Edité le 12/10/2010 par VDH-Bruno]

[vincentp010]

Je ne suis pas sur d'avoir compris, tu cherche un truc de ce genre:

  (setq a "")
 (foreach element '((1 . 9.55)
	   (2 . 9.75)
	   (2 . 10.0)
	   (1 . 11.0)
	   (2 . 11.25)
	   (1 . 11.50)
	  )
   (strcat a "\n" (itoa (car element)) "…….\t" (rtos (cdr element)))
 )
(print a)

[Bred]

Salut,

stocker le déroulement effectué par foreach dans une variable

 

Tu remplis la liste lst avec append :

 

(setq lst nil)
(foreach element '((1 . 9.55)
	   (2 . 9.75)
	   (2 . 10.0)
	   (1 . 11.0)
	   (2 . 11.25)
	   (1 . 11.50)
	  )
 (setq lst (append lst (list element)))
)

 

Donc, tu te trouves avec une liste de tes éléments passé par foreach dans la variable lst.

 

[Edité le 12/10/2010 par Bred]

[VDH-Bruno]

Merci, pour vos réponses à tous les deux.

 

Mais dans ma hâte d’aboutir, j’ai pris une autre option un peu plus classique avec une boucle while, même si à titre personnel j’aurais bien aimé faire quelque chose avec foreach (histoire d’enrichir un peu plus mon vocabulaire Lisp).

 

 (setq Affich "")
(setq LstTri '((1 . 9.55)
       (2 . 9.75)
       (2 . 10.0)
       (1 . 11.0)
       (2 . 11.25)
       (1 . 11.50)
      )
)
(while LstTri
 (setq	Element	(car LstTri)
LstTri	(cdr LstTri)
Affich	(strcat	Affich
		"\n"
		(itoa (car element))
		"\t"
		(rtos (cdr element))
	)
 )
)

 

Renvoie

"\n1\t9.55\n2\t9.75\n2\t10\n1\t11\n2\t11.25\n1\t11.5"

_$

 

Ce à quoi je voulais aboutir en employant la fonction foreach

 

[VDH-Bruno]

Re-bonsoir,

 

Enfin!!! J’ai trouvé, comme je ne voulais pas en rester là, j’ai insister un peu plus dans mes testes.. et la formulation donné par Bred m’a indiqué la voie..

 

Je vous livre mes lignes de codes :

 (setq lst "")
(foreach element '((1 . 9.55)
	   (2 . 9.75)
	   (2 . 10.0)
	   (1 . 11.0)
	   (2 . 11.25)
	   (1 . 11.50)
	  )
 (setq	lst (strcat lst
	    "\n"
	    (itoa (car element))
	    "\t"
	    (rtos (cdr element))
    )
 )
)

 

Renvoie

_$

"\n1\t9.55\n2\t9.75\n2\t10\n1\t11\n2\t11.25\n1\t11.5"

 

Niveau performance je sais pas ce que ça vaut, mais esthétiquement y a pas photo ça fait tout de même plus élégant ;) .

 

[(gile)]

Salut,

 

Une autre façon plus ''purement LISP" avec apply et mapcar

 

(apply 'strcat
      (mapcar '(lambda	(x)
	  (strcat "\n" (itoa (car x)) "\t" (rtos (cdr x)))
	)
       '((1 . 9.55)
	 (2 . 9.75)
	 (2 . 10.0)
	 (1 . 11.0)
	 (2 . 11.25)
	 (1 . 11.50)
	)
      )
)

 

Attention de ne pas trop tomber dans ce mauvais travers (dans lequel je m'engouffre régulièrement) qui consiste à sacrifier la performance sur l'autel de l'élégance. L'élégance n'est que très rarement perçue par l'utilisateur...

 

Dans le cas qui nous concerne, les performances sont très similaires, si tu veux faire des tests, tu peux comparer des fonctions ou expressions avec ce benchmark (en considérant les résultats avec un peu de recul : il est souvent question de millisecondes pour des milliers d'itérations)

 

Exemple d'utilisation avec 3 fonctions qui implémentent les méthodes ci dessus

(defun alist2str_mapcar (alist)
 (apply 'strcat
 (mapcar '(lambda (x)
	    (strcat "\n" (itoa (car x)) "\t" (rtos (cdr x)))
	  )
	 alist
 )
 )
)

(defun alist2str_foreach (alist / res)
 (setq res "")
 (foreach e alist
   (setq res (strcat res "\n" (itoa (car e)) "\t" (rtos (cdr e))))
 )
)

(defun alist2str_while (alist / res ele)
 (setq res "")
 (while alist
   (setq ele	(car alist)
  alist	(cdr alist)
  res	(strcat res "\n" (itoa (car ele)) "\t" (rtos (cdr ele)))
   )
 )
)

 

Avec la liste que tu donnes :

(setq lst '((1 . 9.55)
       (2 . 9.75)
       (2 . 10.0)
       (1 . 11.0)
       (2 . 11.25)
       (1 . 11.50)
      )
)

(benchmark '((alist2str_while lst) (alist2str_foreach lst) (alist2str_mapcar lst)))

Résultat :

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

 

(ALIST2STR_WHILE LST).......1451 / 1.12

(ALIST2STR_FOREACH LST).....1529 / 1.06

(ALIST2STR_MAPCAR LST)......1623 / 1.00

 

Avec une liste plus longue (96 éléments)

(repeat 4 (setq lst (append lst lst)))

(benchmark '((alist2str_while lst) (alist2str_foreach lst) (alist2str_mapcar lst)))

Résultat :

Benchmarking ...............Elapsed milliseconds / relative speed for 4096 iteration(s):

 

(ALIST2STR_MAPCAR LST)......1982 / 1.07

(ALIST2STR_WHILE LST).......2091 / 1.01

(ALIST2STR_FOREACH LST).....2121 / 1.00

 

Avec une liste encore plus longue (1536 éléments)

(repeat 4 (setq lst (append lst lst)))

(benchmark '((alist2str_while lst) (alist2str_foreach lst) (alist2str_mapcar lst)))

Benchmarking ...........Elapsed milliseconds / relative speed for 256 iteration(s):

 

(ALIST2STR_MAPCAR LST)......1888 / 2.43

(ALIST2STR_WHILE LST).......4586 / 1.00

(ALIST2STR_FOREACH LST).....4586 / 1.00

[VDH-Bruno]

Un grand merci (gile) pour ce complément de réponse, auquel je vais porter la plus grande attention.

 

Très intéressante la voie que tu m’ouvre pour évaluer la performance entre différentes fonctions, j’avoue avoir déjà aperçu dans plusieurs post l’emploi de ce benchmark sans mis être attardé d’avantage.

 

Personnellement si je n’avais pas persévéré et abouti avec foreach, j’aurais tenté quelque chose avec apply mapcar, histoire de ne pas végéter davantage avec mes perpétuelles boucles que sont while & repeat (plus facile d’accès pour un début).

 

Même si pour sortir quelque chose avec l’imbrication de ces fonctions cela me demande encore beaucoup de tâtonnements, je sens que cela commence à venir, pour preuve mon dernier code :

 (and (apply '= (mapcar 'zerop lst)) (not (zerop (car lst)))) 

Retourne T si tous les nombres de la liste sont different de 0

Retoune nil si un des nombres vaut 0.

 

La ou je bloque encore dans mon évolution, c’est lorsque j’utilise lambda avec plus d’un argument et les fonctions précitées. J’ai pas encore compris ou situer mon blocage, je n’ai plu l’exemple en tête.. (faudrait que je vois d’avantage de codes de ce type, (gile) au passage si tu me lis..).

 

Il reste aussi la récursivité, thème sur lequel je n’ai pas encore pris la peine de me pencher sérieusement pour bien en comprendre la logique (chaque chose en son temps). J’ai bien essayé une fois d’en tracer une avec la fonction correspondante :

 

 (defun fac (Nbr) 
(if (= 1 Nbr) 
1.0 
(* Nbr (fac (1- Nbr))) 
) 
) 

 

Teste de tracé de la fonction fac

_$ (trace fac)

FAC

_$ (fac 5)

120.0

_$

 

Résultat peu probant, visiblement je n’ai pas encore tout saisie à l’emploi de la fonction trace, il faudra que je teste d’avantage son fonctionnement avant d’espérer allez plus loin.

 

Sinon j’ai bien aimé ta réflexion sur l’élégance au détriment de la performance ( je me la note dans un coin de mon esprit pour plus tard..), car actuellement je n’en suis pas encore aux millisecondes.

 

Disons qu’à mon niveau, j’essais plutôt de traquer les redondances, les variables inutiles ainsi que les parenthèses superflues, en jouant sur l’imbrication de mes fonctions..

Et je m’aperçois avec joie que cela est on ne peut plus formateur..

 

Voilà aujourd’hui ma définition de l’élégance et quant j’y arrive c’est ma récompense :D .

(C'est sans doute cela qui t'auras laissé penser que j'étais "pas mal dégrossi", tu vois pas tant que cela finalement)

 

Amicalement

VDH

[(gile)]

Salut,

 

(and (apply '= (mapcar 'zerop lst)) (not (zerop (car lst))))

 

peut s'écrire de manière plus concise :

(apply '= (cons nil (mapcar 'zerop lst)))

...si on veut vraiment éviter d'utiliser vl-some

Je te laisse méditer... ;)

 

Pour la fonction trace, tu verras les différentes évaluations dans la fenêtre de Suivi de l'éditeur Visual LISP.

 

http://img.ahst.fr/data/images/facuou.png

[VDH-Bruno]

Bonsoir,

 

Je vois que tu as bien saisi que c'était un exercice sur l'emploi de mapcar & apply "combiné".

Effectivement c'est plus conscis (d'ailleur je médite déjà dessus :cool: )

(apply '= (cons nil (mapcar 'zerop lst)))

 

Mais en dehors de l'exercice (et de façon concise), je l'avais plutôt écris comme cela:

 (/= (apply '* lst) 0)

 

Ignorant tout de l'existance de vl-some

 

(Ps: Merci pour la fenêtre de suivi de l'éditeur, j'étais totalement passé à côté..)

[Patrick_35]

Salut

 

Comme je passe dans le coin, je tenais à te féliciter pour ton esprit d'analyse, de déduction et de ta recherche du pourquoi/comment

Si tu continue comme ça, tu vas aller très loin et même nous dépasser.

 

Un futur Elpanov Evgeniy :D

 

@+

[VDH-Bruno]

Bonjour,

 

Patrick_35 : J’ai à la suite de mes recherches sur le forum, eu l’occasion de lire la pertinence de tes messages, sache que des encouragements de ta part sont appréciés à leurs juste valeurs.

 

Un futur Elpanov Evgeniy

 

Hélas non je doute fort.. Je pars de très loin et pour les raisons suivantes :

 

- Je n’ai aucune culture en programmation, il m’a fallu 2 bonnes heures pour comprendre que :

(and T T) renvoie T

(and T nil) renvoie nil

(and nil nil) renvoi nil

 

- Je n’ai pas accès au "support" anglophone (et trop peu de temps pour tout traduire sous google) donc le vl-machinchose, je me le garde pour plus tard, sauf lorsqu’il est distillé à petite dose par (gile) (ou d’autres). Heureusement que j’avais sauvegardé les fichiers d’aide de la version 14 avec le bon vieux AutoLISP.

 

- Pour l’instant je tourne sur une version pleine mais rien n’est sur pour l’avenir (j’ai déjà eu le cas par le passé). Le développement ne fait pas parti de mes attributions professionnels, et c’est pas dans la culture de l’entreprise.

 

- Je n’ai pas non plus de connections internet au travail, je ne me forme que en dehors.. et je ne peux consacrer au lisp que 15 à 20mn le midi et tout au plus 1 à 2 heures le soir ( lorsque les enfants sont au lit).

 

- Je n’ai plus 20 ans (mais quasiment le double), un niveau d’étude moyen et quelques lacunes en mathématiques (notamment sur les matrices, j’ai cru lire que toi aussi en espérant que tu les as comblé depuis..).

 

Pour contrebalancer: j’ai pour moi la chance d’être curieux et le désir de toujours apprendre.. Tu vois pour le dépassement vous n’avez pas à vous soucier et Elpanov Evgeniy non plus ;)

 

(gile) : un grand MERCI, pour ta ligne de code (c’est de l’or pour moi) :

(apply '= (cons nil (mapcar 'zerop lst)))

A opposer à mon horrible:

(and (apply '= (mapcar 'zerop lst)) (not (zerop (car lst))))

 

Ligne qui a été très formatrice à plus d’un titre, j’ai saisi le principe que tu as pointé et qui m’avait échappé jusque là dans l’imbrication de apply et mapcar (conditionné que j’étais par des exemples précédemment étudier).

 

Pour développer :

 

J’avais bien pointé la faiblesse du (mapcar 'zerop ‘(0 0 0 0)) qui retourne (T T T T)

Et qui une fois soumis à (apply '= ‘(T T T T)) retournait T

 

J’avais bien tenté avant l’exécution de apply, mapcar d’ajouter nil dans lst (avec append au lieu de cons) pour finalement m’apercevoir que append n’y arrivait pas et que de toute façon zerop ne pouvait évaluer nil.

$ (zerop nil)

; erreur: type d'argument incorrect: numberp: nil

 

C’est pourquoi j’avais laborieusement introduit la condition du (not (zerop (car lst))) en sortie de boucle, j’avoue n’avoir à aucun moment pensé introduire une expression entre le passage de mapcar à apply, chose que tu as réalisé avec pertinence au moyen de (cons nil ‘(T T T T)) --> (nil T T T T).

 

En résumé de cette leçon, je retiendrai :

 

En 1 - Ne pas négliger cons (constructeur de liste)

 

Que j’avais à tord cantonné au rôle de constructeur de paire pointée au détriment de append (ajouter liste..) car :

_$ (cons nil '(0 0 0))

(nil 0 0 0)

Ou

_$ (cons nil '(T T T T))

(nil T T T T)

 

Fonctionne bien alors que :

_$ (append '(0 0 0) '())

(0 0 0)

Ou

_$ (append '(T T T) nil)

(T T T)

 

Pas du tout, et à bien y réfléchir c’est tout à fait normal, (c’est la mise en évidence qu’ils n’ont pas la même vocation).

 

En 2 - Sur l’emploi de apply mapcar

 

Même si on aperçoit souvent la forme :

 (apply ‘expression2 (mapcar ‘expression1 liste1 …))
(apply ‘expression 2 liste2)
résultat

 

Si le besoin d’introduire une troisième expression (ou +) ce fait sentir, on peut toujours tenter :

 (apply ‘expression2 (expression3 (mapcar ‘expression1 liste1 …)))
(apply ‘expression2 (expression3 liste2))
(apply ‘expression2 liste3)
résultat

 

Au cas où il n’y avait pas moyen d’exécuter l’ expression3 avant l’appel de apply mapcar. Avant d’aller l’inclure en sortie de boucle comme dans je l’avais fait.

 

En généralisant le raisonnement: Toujours garder à l’esprit qu’une action est possible à chaque niveau d’imbrication de parenthèses. Je trouve tout cela très puissant même si je ne peux faire le parallèle avec d’autres langages..

 

En 3 – D’une manière générale essayer de garder un regard critique sur les lignes codes écrites par d’autres, au risque de se laisser formater par ces dernières, même si j’avoue que cela reste très instructif.

 

Avec mes remerciements

VDH

 

EDIT: J’édite mon message pour préciser une chose pour ceux qui m’aurais suivi dans mes élucubrations entre append & con

 

J’avais bien tenté avant l’exécution de apply, mapcar d’ajouter nil dans lst (avec append au lieu de cons) pour finalement m’apercevoir que append n’y arrivait pas

 

Bien que nil soit à la fois une liste et un atome. Pour ajouter nil dans une liste autrement qu’avec cons

La syntaxe suivante :

 (append nil lst); retourne (1 2 3 4)

S’évalue car nil est une liste mais n’ajoute pas nil à la liste. Littéralement on pourrait traduire par ajouter nil (rien) à la liste ce que fait l’interpréteur

 

La bonne syntaxe est la suivante :

 (append (list nil) lst); retourne (nil 1 2 3 4)

Qui revient à dire ajouter la liste nil à la liste.

 

Même si je démonte un peu mon argumentaire précédent, je persiste dans mon affirmation

cons et append n’ont pas la même vocation

 

cons pour ajouté un élément

append pour ajouter une liste

 

Même si :

(append (list élément) liste) < = > (cons élément liste) ; ajoute un élément en début de liste

Et que :

(append liste (list élément)) < = > l’inverse de cons ; ajoute un élément en fin de liste

 

Méfiance tout de même avec les paires pointées

Exemples:

(append (list 5) '(2 3 4)) ;retourne (5 2 3 4) 
(cons 5 '(2 3 4)) ;retourne (5 2 3 4) 
(append (list 5) '(2 . 4)) ; erreur: liste incorrecte: 4
(cons 5 '(2 . 4)) ; retourne (5 2 . 4)

 

 

 

[Edité le 21/10/2010 par VDH-Bruno]

[Tramber]

- Je n’ai aucune culture en programmation, il m’a fallu 2 bonnes heures pour comprendre que :

(and T T) renvoie T

(and T nil) renvoie nil

(and nil nil) renvoi nil

 

Moi, il a dû me falloir une bonne dizaine de seconde (c'était il y a 8 ou 9 ans).

Comme quoi tu tourne au gasoil (voire à l'huile lourde) et moi à l'essence (voire à l'éther).

 

Je n'ai aucune conscience des enjeux que représente la compréhension des sujets dont tu traites ici. Explication : je n'ai aucun intérêt pour comprendre à ce point les outils. Aucun intérêt personnel mais non plus aucun intérêt stratégique. (lire la fin quand même).

Je suis ravi de progresser en expérience. Je suis déjà moins ravi de constater que je n'arrive plus à suivre tes messages.

 

Mais compte sur moi pour les variables, l'utilisation du logiciel en programmation et des questions pratiques.

Continue ton apprentissage fondamental. Mais ne nous abandonnes pas ensuite !

Plus il y aura de francophones costauds, plus leurs suiveurs seront placés pour donner de bons conseils, meilleurs seront les soutiens aux débutants. C'est un effet cascade.

Tiens, recemment, (gile) m'a appris (enfin disons rappelé une chose oubliée mais fondamentale) sur les entiers dans l'informatique (leur longueur). Maintenant, j'en ai la conscience. Autrement dit ca n'est pas tombé dans l'oreille d'un sourd.

Et voilà ce qui est fondamental : savoir ce qu'on fait. Et y être aidé le cas échéant. Car quand on programme, c'est souvent pour les autres. C'est donc une responsabilité.

 

Tu peux peut-être nous dire davantage sur toi et ton parcours pro (en rapport avec AutoCAD).

 

Hopppla.

[(gile)]

Salut,

 

Je te l'avais déjà dit, je pense comme Patrick_35 que tu vas aller loin et vite parce que tu te poses des questions essentielles et que tu cherches à comprendre avec, à mon avis, la bonne méthode : évaluer et encore évaluer des expressions.

Si aujourd'hui tu passes deux heures à comprendre le fonctionnement de certaines fonctions fondamentales, tu t'en servira demain avec presque autant d'aisance que de ta langue maternelle.

 

En ce qui concerne les fonctions vl-* (qui sont des fonctions AutoLISP qui n'utilisent pas l'interface COM/ActiveX comme les fonctions vla-*, vlax-* ou vlr-*), tu trouveras dans ce sujet des fonctions équivalentes écrites en "vieil AutoLISP". Certaines sont issues de la Std_lib de Reini Urban (écrites par lui ou d'autres pionniers d'AutoLISP avant d'être implémentées par Autodesk avec un préfixe vl-) d'autres sont de mon cru et datent d'une époque où je travaillais sur un clone d'AutoCAD qui ne reconnaissait pas ces fonctions vl-*.

 

PS : il vaut mieux utiliser les fonctions vl-* que leurs (parfois pales) copies définies dans ce sujet, mais certaines peuvent avoir un intérêt "pédagogique" (EVERY devrait te rappeler quelque chose ;) )

 

PPS : Puisque tu sembles aimer les expressions concises, élégantes et puissantes, j'ai tenté d'expliquer ici une de mes préférées.

[VDH-Bruno]

Bonsoir,

 

Tramber : Je te remercie d’avance pour l’aide que ton expérience pourra m’apporter, pour répondre simplement aux questions que tu souléves :

Je n'ai aucune conscience des enjeux que représente la compréhension des sujets dont tu traites ici

L’enjeu est justement la compréhension (comme l’a visiblement compris (gile)), si j'en passe par là, c’est pour moi la façon que j’ai d’apprendre (sinon ça rentre pas dans la tête).

Mais ne nous abandonnes pas ensuite !

Non, je ne pense pas à moins que je repasse sur une LT ou qu’à l’avenir mon épanouissement personnel /professionnel me porte vers d’autres horizons.. Présentement je me consacre à l’étude du Lisp du mieux que je peux, et si cela a des retombées bénéfiques pour des membres de ce forum ou pour mon entourage professionnel c'est tant mieux :D .

 

 

(gile) Merci pour la précision sur les fonctions vl-, et pour tes liens ( EVERY évidemment que ça me parle maintenant :cool: ) surtout le dernier lien. Il tombe bien à propos car je cherche actuellement à retravailler une routine de tri, routine que je pense construire sur les fonctions min et max (histoire de me faire la main..)

 

 

 

Pour plus ou moins conclure ce sujet qui à bien dérivé de son intitulé.

 

Avec vl-some, je suis arrivé à l’écriture suivant ((gile) c’est comme cela que tu l’avais vu ?):

 (not (vl-some 'zerop nlst))

 

Comparons les deux fonctions suivantes :

(Pour le fun histoire de mettre en pratique mes connaissances récemment acquises):

 (defun vl-some-0 (nlst)
 (not (vl-some 'zerop nlst))
) ;_ Fin de defun

(defun apply-0 (nlst)
 (/= (apply '* nlst) 0)
) ;_ Fin de defun

 

Comparaison sur une liste de 20 nombres

 (repeat	20
 (setq nlst (cons 1.0 nlst))
) ;_ Fin de repeat
(benchmark '((apply-0 nlst) (vl-some-0 nlst)))

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

(VL-SOME-0 NLST).....1672 / 1.02

(APPLY-0 NLST).......1703 / 1

 

La différence n’est pas vraiment significative, passons donc au niveau supérieur comparaisons sur 200 éléments

 (setq nlst nil)
(repeat	200
 (setq nlst (cons 1.0 nlst))
) ;_ Fin de repeat
(benchmark '((apply-0 nlst) (vl-some-0 nlst)))

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

(APPLY-0 NLST).......1907 / 1.3

(VL-SOME-0 NLST).....2484 / 1

 

A la ça devient un peu plus significatif, alors poussons encore plus loin là comparaison sur 2000 éléments

 (setq nlst nil)
(repeat	2000
 (setq nlst (cons 1.0 nlst))
) ;_ Fin de repeat
(benchmark '((apply-0 nlst) (vl-some-0 nlst)))

Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s):

(APPLY-0 NLST).......1953 / 2.69

(VL-SOME-0 NLST).....5250 / 1

 

Et là ça l’écart devient fabuleux, mais attention aux conclusions trop hâtives car nous n’avons comparer que des listes n’ayant pas de zéro et qui ont été aux termes de leurs évaluations. Car maintenant si on compare la même liste avec un 0 en début, on obtient :

 (setq nlst (cons 0 nlst))
(benchmark '((apply-0 nlst) (vl-some-0 nlst)))

Benchmarking ..................Elapsed milliseconds / relative speed for 32768 iteration(s):

(VL-SOME-0 NLST).....1594 / 2.46

(APPLY-0 NLST).......3921 / 1

 

Hé oui car vl-some interromps son évaluation dés que la condition d’évaluation retourne T (d’après l’aide) ce qui pour ce cas de figure l’optimise grandement. Pour finir de s’en convaincre il suffit de faire l’opération inverse avec un 0 de fin.

 (setq nlst (reverse nlst))
(benchmark '((apply-0 nlst) (vl-some-0 nlst)))

Benchmarking .................Elapsed milliseconds / relative speed for 16384 iteration(s):

(APPLY-0 NLST).......1953 / 2.72

(VL-SOME-0 NLST).....5313 / 1

 

En conclusions

Pour évaluer la pertinence de l’une ou l’autre de ces fonctions, il faut prendre en considération :

- La longueur de la liste à traiter.

- Estimer la probabilité de la présence de 0 dans la liste, ainsi que ça position. (Qui peut être considéré comme médiane sans indication contraire).

 

Je vous avais prévenu c’étais pour le fun.. ;) si vous souhaitez continuer la comparaison libre à vous, à mon niveau ça me suffit.. Je peux voguer vers d'autres sujets d'étude.. :D

 

Bonne nuit à tous !!!

[Patrick_35]

Salut

 

Je n’ai plus 20 ans (mais quasiment le double)

Pour moi, c'est le double dépassé ;)

 

un niveau d’étude moyen et quelques lacunes en mathématiques

Je n'ai pas passé le bac, alors...

 

(notamment sur les matrices, j’ai cru lire que toi aussi en espérant que tu les as comblé depuis..).

Ben non, il me manque les bases en mathématiques, dû à mon niveau d'études.

Je vois à quoi elles peuvent servir, mais je n'arrive pas à les transposer en formules mathématiques.

(gile) a bien essayé de m'expliquer, mais je bloque encore. Cela viendra peut-être un jour.

 

Comme tu parles du AND, j'aimerai pousser un peu plus loin la réflexion.

Si la valeur du 1er argument du AND est différente de nil, la fonction regarde le deuxième.

S'il est différent de nil, la fonction regarde le troisième etc...

Donc on peut se dire que AND est une condition indiquant tant que ... et aboutir à ma fonction

On peut aussi tenir le même raisonnement avec le OU, qui fonctionne à l'inverse du AND

Un exemple pour déclarer une variable s'il elle n'existe pas

(or doc (setq doc (vla-get-activedocument (vlax-get-acad-object))))

Ce qui revient à écrire

(if (not doc) (setq doc (vla-get-activedocument (vlax-get-acad-object))))

 

un autre exemple pour tester une boite de dialogue et la lancer

(and (setq dcl (findfile "Ma_Boite")) ; Le fichier existe ?
   (setq dcl (load_dialog dcl)) ; la Bd est chargée ?
(fonctions_de_ma_boite) ; Fonctions de la Bd
)

 

@+

[Tramber]

Je ne vais pas continuer sur le sujet. En fait, j'essaie de dire qu'il ne m'a pas été possible de pousser très loin ma compréhension des choses. Et que donc, depuis, je "m'augmente" avec l'expérience plutôt qu'avec la stricte compréhension. Ca va bien pour moi.

 

Mais je regrette juste que tu ne m'ai pas répondu sur ton parcours pro.... :cool:

[VDH-Bruno]

Bonsoir,

 

Patrick_35 : Merci pour l’explication clair du and & or, je n’avais pas encore poussé la comprenette jusque là (tu viens de me faire gagner 2 heures, c’est très appréciable..).Si au fils de mes mails tu en a d’autres comme cela, je suis preneur...

.

Tramber : Pour faire court et pour finir les présentations

 

J’ai tout d’abord débuté AutoCAD sur la R12 (DOS), même si j’ai croisé de façons anecdotiques les versions 10 et 11.

La R14 c’est celle sur laquelle je me suis le plus auto-formé (donc préféré), j’en ai fait le tour le plus complet possible, juste pour le plaisir (avec la doc comme livre de chevet), je me suis initié à la 3D, script, personnalisation : des menus, icônes ect.. (Il restait plus que la programmation), depuis j’avoue me contenté de transposer mes connaissances d’une version à l’autre sans trop m’attarder sur les nouveautés (ça prend déjà beaucoup de temps, une version par an faut pouvoir suivre.. :casstet: ).

 

Professionnellement je sévis actuellement dans une entreprise de préfabrication lourde (béton armé et précontraint), que je résumerai en une petite dizaine d’année en tant que projeteur au sein du BET et plus récemment depuis 3, 4 ans comme technicien d’étude de prix au sein de la cellule commerciale (c’est moins passionnant, mais un peu plus rémunérateur.. :( ).

 

 

 

 

[Edité le 20/10/2010 par VDH-Bruno]