Challenge 16

[Matt666]

Salut !

 

Bon Patrick_35 a proposé un nouveau challenge à la fin du challenge 14, et je permets d'en faire un nouveau post.

 

C'est encore un challenge de niveau assez facile....

Il s"agit de retrouver toutes les cordonnées d'une polyligne dans une liste

Exemple :

Liste de base :

(setq lst '((-1 . ) (0 . "LWPOLYLINE") (5 . "33EC") (67 . 0) (8 . "0") (62 . 256) (6 . "ByLayer") (370 . -1) (48 . 1.00000) (60 . 0) (90 . 8) (70 . 1) (38 . 0.000000) (39 . 0.000000) (210 0.000000 0.000000 1.00000) (10 0.000000 0.000000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000) (10 20.0000 0.000000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000) (10 20.0000 16.0000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000) (10 -8.88178E-016 16.0000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000) (10 -1.46953E-015 12.0000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000) (10 8.00000 12.0000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000) (10 8.00000 7.00000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000) (10 -1.77568E-015 7.00000 0.000000) (40 . 0.000000) (41 . 0.000000) (42 . 0.000000)))

Fonction :

(coor lst)

Retourne :

((0.000000 0.000000 0.000000) (20.0000 0.000000 0.000000) (20.0000 16.0000 0.000000) (-8.88178E-016 16.0000 0.000000) (-1.46953E-015 12.0000 0.000000) (8.00000 12.0000 0.000000) (8.00000 7.00000 0.000000) (-1.77568E-015 7.00000 0.000000))

 

Voilà...

 

Alors, s'il vous plait, faites un peu plaisir à Patrick_35 !!!

Pour les pros, on essaie de faire la même en autolisp pur ? (bon je sais c pas très dur...)

Allez lili, lovecraft, on ne regarde les codes existants, et on essaie !

 

Bonne chance.

Matt.

 

[Edité le 12/12/2007 par Matt666]

[bseb67]

Salut Matt666!

 

Et bien ca lance en challenge :D !

 

Pour le 14 et 15, je n'ai pas eu trop de temps, mais pour celui-là, j'ai déjà une solution.

JE vais tenter une version différente et voir la meilleure.

 

a+.

[zebulon_]

Bonjour,

 

pour corser un peu, on pourrait faire une fonction qui récupère aussi le "bulge" de chaque élément de polyligne, pour pouvoir ensuite faire une fonction qui donne, lorsque le segment est une courbe, le centre du cercle, la valeur du rayon, l'angle de départ et d'arrivée et la longueur de la corde etc...

Pour mes besoins personnels en la matière, je me suis largement inspiré de ceci et, depuis, je suis moins ignorant question "bulge"

 

Amicalement

Zebulon_

 

[bonuscad]

Pour les pros, on essaie de faire la même en autolisp pur ? (bon je sais c pas très dur...)

 

Non c'est sûr, mais en même temps une solution en vl- ne sera pas forcément mieux à mon avis pour ce besoin.

 

Je ferais simplement un truc comme ça

 

((lambda ( / ent lst_dxf lst_pt)

(while (null (setq ent (entsel))))

(setq lst_dxf (entget (car ent)))

(foreach n lst_dxf

(if (listp (cdr n))

(setq lst_pt (cons n lst_pt)); ou au choix (cons (cdr n) lst_pt)

)

)

(reverse lst_pt)

))

[lovecraft]

Bonjour,

 

Voici ma p'tit contrubution.

 

J'espere qu'elle réponds à la demande du challenge.

 

Merci d'avance de vos commentaires.

 

 (defun c:test ()
(setq ent (entget(car(entsel))))
(setq i 0)

(repeat (length ent)

(setq entit (nth i ent))
(setq codeentit (car entit))

(if (= codeentit 10)
(setq lst_pt (cons (cdr entit) lst_pt))
)
(setq i (+ i 1))
)
(reverse lst_pt)

)

 

@plus

[(gile)]

Salut Lovecraft,

 

mêmes remarques que d'habitude :

- déclare les variables

- Matt666 proposait de donner une sous-routine avec un argument, genre : (defun coord (lst) ..)

Rien n'empêche de faire ensuite une fonction d'appel pour les tests :

(defun c:test (/ ent)
 (if (setq ent (car (entsel)))
   (coord (entget ent))
 )
) 

ou plus simplement :

(coord (entget (car (entsel)))) 

Tu peux aussi éviter les variables inutiles, come cdeentit :

(setq codeentit (car entit))

(if (= codeentit 10)
(setq lst_pt (cons (cdr entit) lst_pt))
)

peut s'écrire plus simplement :

(if (= (car entit) 10)
(setq lst_pt (cons (cdr entit) lst_pt))
)

 

Sinon, on avait vu auchallenge 14 que, au niveau performances, ce qui compte dans une routine qui bloucle, c'est ce qui se passe à chaque itération (ou appel récursif).

 

À ce propos, il est possible (et assez facile) d'écrire une fonction récursive qui réponde à la demande (Bred, Matt666, Bseb67 à vos claviers...)

 

[Edité le 11/12/2007 par (gile)]

[Matt666]

Pas testé... Mais je doute que ça fonctionne !

 

(defun coord (lst)
 (if (eq (caar lst) 10)
   (cons
     (cdar lst)
     (coord (cdr lst))
   )
 )
)

 

J'arrive pas à comprendre pk le code ne fonctionne pas sur BricsCAD... Ptet que sur Autocad, ça marche ?

 

[Edité le 11/12/2007 par Matt666]

[(gile)]

Pas mal Matt666, c'est un début, mais ça doit retourner nil.

Que se passe t'il avec ta fonction si (caar lst) est différent de 10 ?

[Matt666]

Ok...

(defun coord (lst)
 (if (eq (caar lst) 10)
   (cons 
     (cdar lst)
     (coord (cdr lst))
   )
   (coord (cdr lst))
 )
)

 

J'ai essayé sur Autocad... Avec ton amélioration, et il me retourne ça :

Choix de l'objet: Une erreur matérielle s'est produite ***

limite de la pile interne atteinte (simulation)

 

Chu désolé, mais je comprends vraiment pas le problème !! Je dois pas bien comprendre la récursivité !

 

Merci pour cette précieuse aide, gile !

[(gile)]

Je me doutais bien que tu allais faire ça, et j'ai laissé faire, c'est comme ça qu'on apprend.

 

Comme avec while, avec une forme récursive il est impératif de mettre une condition d'arrêt.

 

Sans condition d'arrêt, une expression while entre dans une boucle sans fin, une fonction récursive atteind "la limite de la pile".

 

Une fonction récursive marche en 2 phase : une phase "d'empilement" et une de "dépilement" (voir ici et là)

 

S'il n'y a pas de condition d'arrêt, l'empilement se poursuit jusquà une certaine limite, il n'y a pas de phase de dépilement (ce qui correspond aux retours des évaluation des expressions "empilées").

 

[Edité le 10/12/2007 par (gile)]

[lili2006]

Bonsoir à toutes et tous,

 

 

Allez lili, lovecraft, on ne regarde les codes existants, et on essaie !

 

Merci encore Matt666 de penser à moi, mais je craint fort de te "décevoir "une fois de plus,...

 

Je trouve tes challenges fort intéressant et même en restant dans l'ombre, j'apprend des choses (comme toujours sur ce forum).

 

Par contre, je sais maintenant une chose,. Je n'ai décidémment pas assez de temps pour me pencher avec sérieux sur ce language actuellement et j'ai du mal à faire les choses à moitié (c'est mon défaut principal mais peut-être aussi ma principale qualité,...??!!).

 

Le travail scolaire monopolise encore beaucoup trop de temps pour le momment, mais je reconnais que mes dernières requêtes (que tu connais) font essentiellement appel au Lisp. Je sais qu'il faut que je m'y mette; mais comme je trouve ici l'appui nécessaire pour parer au "plus urgent", je l'accepte sans difficultité particulière. Bien sur, moi aussi j'espère pouvoir un jour apporter de l'eau au moulin, mais je suis trés patient et tétu (et, c'est qu'en plus j'suis Breton).

 

Pour réumer, ma priorité, l'apprentissage de mes étudiants, ensuite le mien pour être encore plus performant dans l'apprentissage de mes étudiants,...

 

Mais un jour,... (bien sûr qu'il me tarde, mais je garde en mémoire tous ces posts permettant de progresser et encore merci à toi Matt666 de permettre cela ici !)

 

et bien sur, bravo encore aux personnes qui répondent,...(En particulier, lovecraft qui semble bien évoluer et les piliers pédagogiques et techniques,... je vous laisse deviner,...!)

 

Au plaisr de participer,..

 

Alors, s'il vous plait, faites un peu plaisir à Patrick_35 !!!

 

Et dieu sait que c'est pas l'envie qui me manque,...(mais avec mes petits moyens et une fois de plus, du temps, je vais essayer de participer à la rédaction d'une aide pour le maintenant très fameux Lisp LXL !)

 

Et pour reprendre le trés fameux sloggan de qui vous savez :

 

De chacun selon ses moyens,

À chacun selon ses besoins.

 

[Bred]

RaaaaaaaaaaAAAAAAAA !!!!

(gile).... je te hais !!!!.... ;)

moi qui voulais passer une soirée agréable à m'occuper des problèmes de xdata de lili2006...

 

J'en ai bavé... et je suis arrivé enfin à quelque-chose... mais par tatonnement avec des

(trace Bred3)

(Bred3 lst)

Après une bonne centaine de test :

 

(defun Bred3 (lst)
 (if (assoc 10 lst)
   (progn
     (princ (cdr (assoc 10 lst)))
     (Bred3 (setq lst (vl-remove (assoc 10 lst) lst)))
     )
   )
 )

 

... et soit gentil, stp !!!

(je n'arrive vraiment pas comprendre comment créer ça "logiquement", autrement que par tatonnement....)

 

... alors que pour moi, ces deux là sont si compréhensibles :

(defun Bred1 (lst)
 (mapcar 'cdr
  (vl-remove-if '(lambda (x) (not (equal (car x) 10))) lst))
 )

 

(defun Bred2 (lst / l)  
 (While lst
   (if (equal (car (car lst)) 10)
     (setq l (append l (list (cdr (car lst))))))
   (setq lst (cdr lst))
     )
 l
)

 

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

[(gile)]

Tu y est presque Bred :)

 

Ta routine récursive ne fait pas une liste mais une solution récursive pour faire une liste fonctinnerait plus comme Bred2.

 

Mais si tu trouves plus agréable les XDatas... :exclam:

 

PS : un (cdr lst) est plus performant que (vl-remove (car lst) lst) à moins de chercher les doublons.

 

[Edité le 10/12/2007 par (gile)]

[Bred]

Mais si tu trouves plus agréable les XDatas... :exclam:

C'est vrais que les xdata ce n'est pas trés amusant, mais au moins c'est clair pour moi !

(ça fait 50 fois que je lis ton post explicatif, mais ça m'echappe toujours....)

 

PS :

PS : un (cdr lst) est plus performant que (vl-remove (car lst) lst) à moins de chercher les doublons.

Bien sûr ! merci ! je modifie Bred2 en concéquence !

 

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

[(gile)]

vois aussi ici et là

il y est question de liste et l'explication y est un peu différente de la fenêtre de suivi.

[Matt666]

Salut !

Je crois que j'ai trouvé, pompant ta fonction remove_doubles !!

(defun coord (lst)
   (cond 
       ((null lst) nil) 
       (T 
           (if (eq (caar lst) 10)
               (cons (cdar lst) (coord (cdr lst)))
               (coord (cdr lst))
           )
       )
   )
)

 

Merci encore Matt666 de penser à moi, mais je craint fort de te "décevoir "une fois de plus,

Salut lili ! Mais t'inquiète, tu ne me déçois pas ! Tu vois les choses comme tu le veux ! Après si j'insiste, c'est parce que je reste persuadé que rien ne vaut la pratique du code pour un apprentissage plus rapide et logique.

 

Mais un jour,...

Bah j'espère bien qu'on verra ça !!

 

Et puis comme qui dirait, Il faut donner du temps au temps.

 

A bientot !

Matt.

[(gile)]

Ben voila, Matt666 :D Une fonction récursive.

 

On a donc, pour le même résultat, plusieurs méthodes : Bonuscad avec foreach, Lovecraft avec repeat, Bred avec while ou vl-remove-if-not, Matt666 nous donne une forme récursive.

Je propose l'utilisation de mapcar et un astuce avec append :

 

(defun coord (elst)
 (apply 'append
 (mapcar '(lambda (x)
	    (if	(= (car x) 10)
	      (list (cdr x))
	    )
	  )
	 elst
 )
 )
) 

[bseb67]

Salut!

 

Bon, ben voilà mes trois versions faites hier à midi. J'ai voulu cherché une avec un apply, mais

là (comme le mapcar) c'est moins point faible :( .

 

(defun lst-bseb67-v1( lst)
 	(if lst
  	(progn
		(if (= (Type lst) 'LIST)
			(progn
			  	(if (= (caar lst) 10)
				  	(append (list (cdar lst)) (lst-bseb67-v1 (cdr lst)))
				  	(lst-bseb67-v1 (cdr lst))
				) ; if
			) ; progn
		  	(alert "lst n'est pas une liste")
		) ; if
	) ; progn
) ; if
 
) ; lst-bseb67-v1

(defun lst-bseb67-v2( lst / res)
 	(setq res '())
(foreach elem lst
  	(if (= (car elem) 10)
	  	(setq res (append res (list (cdr elem))))
	) ; if
) ; foreach

 	res
 
) ; lst-bseb67-v2

(defun lst-bseb67-v3( lst / res)
 	(setq res '() cpt 0 lg (length lst))
(while (< cpt lg)
  	(if (= (car (nth cpt lst)) 10)
	  	(setq res (append res (list (cdr (nth cpt lst)))))
	) ; if
  	(setq cpt (1+ cpt))
) ; foreach

 	res
 
) ; lst-bseb67-v3

 

Je sais que l'append est plus lent que le cons, mais je ne suis pas trop con(s) :cool: :D

 

a+!

[(gile)]

Je sais que l'append est plus lent que le cons

 

Et ce d'autant plus que la liste est longue puisque append est utilisé dans la boucle.

Un petit benchmark qui utilises les listes entget (lst5 lst20 et lst100) de polylignes de 5, 20 et 100 sommets, pour évaluer la difference entre append et cons+reverse

 

(defun coord-foreach (elst / ret)
 (foreach p elst
   (if	(= (car p) 10)
     (setq ret (cons (cdr p) ret))
   )
 )
 (reverse ret)
) 

 

_$ (benchmark '((coord-foreach lst5) (lst-bseb67-v2 lst5)))

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

 

(COORD-FOREACH LST5).....1125 / 1.06

(LST-BSEB67-V2 LST5).....1188 / 1.00

 

_$ (benchmark '((coord-foreach lst20) (lst-bseb67-v2 lst20)))

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

 

(COORD-FOREACH LST20).....1093 / 1.20

(LST-BSEB67-V2 LST20).....1313 / 1.00

 

_$ (benchmark '((coord-foreach lst100) (lst-bseb67-v2 lst100)))

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

 

(COORD-FOREACH LST100).....1000 / 1.78

(LST-BSEB67-V2 LST100).....1781 / 1.00

[(gile)]

Toujours pour évaluer les performances des différentes méthodes, toujours avec les mêmeslistes (lst5 lst20 et lst100) et avec les fonctions que j'avais écrites hier soir en essayant qu'elles ne diffèrent que par la méthode utilisée.

 

(defun coord-recurs (elst)
 (if elst
   (if	(= (caar elst) 10)
     (cons (cdar elst) (coord-recurs (cdr elst)))
     (coord-recurs (cdr elst))
   )
 )
)

(defun coord-while (elst / ret)
 (while elst
   (if	(= (caar elst) 10)
     (setq ret (cons (cdar elst) ret))
   )
   (setq elst (cdr elst))
 )
 (reverse ret)
)

(defun coord-vrin (elst)
 (mapcar 'cdr
  (vl-remove-if-not
    '(lambda (x)
       (= (car x) 10)
     )
    elst
  )
 )
)

(defun coord-mapcar (elst)
 (apply 'append
 (mapcar '(lambda (x)
	    (if	(= (car x) 10)
	      (list (cdr x))
	    )
	  )
	 elst
 )
 )
)

(defun coord-repeat (elst / ret)
 (repeat (length elst)
   (if	(= (caar elst) 10)
     (setq ret (cons (cdar elst) ret))
   )
   (setq elst (cdr elst))
 )
 (reverse ret)
)

(defun coord-foreach (elst / ret)
 (foreach p elst
   (if	(= (car p) 10)
     (setq ret (cons (cdr p) ret))
   )
 )
 (reverse ret)
) 

 

_$ (benchmark '((coord-recurs lst5)

(coord-while lst5)

(coord-vrin lst5)

(coord-mapcar lst5)

(coord-repeat lst5)

(coord-foreach lst5)

)

)

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

 

(COORD-WHILE LST5).......1016 / 1.65

(COORD-MAPCAR LST5)......1078 / 1.55

(COORD-FOREACH LST5).....1093 / 1.53

(COORD-RECURS LST5)......1141 / 1.47

(COORD-REPEAT LST5)......1391 / 1.20

(COORD-VRIN LST5)........1672 / 1.00

 

_$ (benchmark '((coord-recurs lst20)

(coord-while lst20)

(coord-vrin lst20)

(coord-mapcar lst20)

(coord-repeat lst20)

(coord-foreach lst20)

)

)

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

 

(COORD-MAPCAR LST20)......1969 / 1.49

(COORD-WHILE LST20).......2062 / 1.42

(COORD-FOREACH LST20).....2156 / 1.36

(COORD-VRIN LST20)........2250 / 1.31

(COORD-RECURS LST20)......2391 / 1.23

(COORD-REPEAT LST20)......2937 / 1.00

 

_$ (benchmark '((coord-recurs lst100)

(coord-while lst100)

(coord-vrin lst100)

(coord-mapcar lst100)

(coord-repeat lst100)

(coord-foreach lst100)

)

)

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

 

(COORD-VRIN LST100)........1344 / 2.10

(COORD-MAPCAR LST100)......1703 / 1.66

(COORD-WHILE LST100).......1922 / 1.47

(COORD-FOREACH LST100).....1969 / 1.44

(COORD-RECURS LST100)......2250 / 1.26

(COORD-REPEAT LST100)......2828 / 1.00

 

Si les différences ne sont pas énormes, on peut tout de même noter l'efficacité constante de while et des fonctions de traitement des liste (mapcar et foreach), les performance de la fonction récursive qui baissent quand la longueur de la liste augmente, l'inverse pour vl-remove-if-not, et surtout l'étonnante relative lenteur de repeat par rapport aux autres méthodes.

[(gile)]

Il me semble qu'on peut maintenant passer au niveau supérieur en reprenant ce que proposait _Zebulon.

 

Pour ne pas trop s'éparpiller, je propose de cadrer le challenge à un exercice pour l'instant, quitte à en faire d'autre ensuite.

 

Toujours à partir d'une liste telle que celle retournée par entget sur une lwpolyline, écrire une fonction qui retourne une liste contenant les longueurs de chaque segment de la polyligne (ces segments pouvant être courbes bien sur).

 

 

PS : les fonctions trouvées plus haut peuvent être rendues plus polyvalentes.

En ajoutant un argument (le code de groupe DXF), elles peuvent servir à retourner les listes de tous les groupes DXF à entrées multiples (10 40 41 42 pour les polylignes par exemple).

 

(defun dxf-grpe (elst code / ret)
 (foreach p elst
   (if	(= (car p) code)
     (setq ret (cons (cdr p) ret))
   )
 )
 (reverse ret)
) 

 

(dxf-grpe (entget (car (enstel))) 42) retournera la liste des bulges de la polyligne.

 

[Edité le 11/12/2007 par (gile)]

[Matt666]

Houlà...

Va falloir revoir ça au calme !! Je vois pas trop encore ce qu'est un bulge.. On dirait un chiffre magique !!

 

Ok, ça a l'air intéressant...

 

Adtal, comme on dit par chez nous !

[Bred]

Salut,

moi, j'suis à la bourre, j'en suis toujours à rechercher à créer une fonction récursive pour la première demande (avec dans l'espoir de comprendre la logique).... et je pense que j'aperçois une LED au fond du tunnel...

(defun Bred4 (lst / l)
 (if (assoc 10 lst)
   (cons (cdr (assoc 10 lst))
  (Bred4 (vl-remove (assoc 10 lst) lst)))
   )
 )

 

... En fait, si j'ai bien compris le principe de fonctionnement d'une fonction récursive, c'est que "la fonction appelé dans la fonction" retroune le résultat demandé (ici "(vl-remove (assoc 10 lst) lst)"), mais le garde en mémoire (si je peux dire), et donc, si l'on "repasse une fois", cela en faite pourrais dire que je fais "(vl-remove (assoc 10 (vl-remove (assoc 10 lst) lst))(vl-remove (assoc 10 lst) lst))")... etc.... jusqu'à ce que je réponde à la condition d'arrêt....

D'où le terme "d'empilement"

... et le résultat étant "d'ésempilé" au moment où la condition d'arrêt est remplie, pour réaliser le code "(vl-remove (assoc 10 (vl-remove (assoc 10 lst) lst))(vl-remove (assoc 10 lst) lst))")... etc...... d'où le résultat s'empilant "à l'envers"....

 

C'est ça, chef ? :casstet:

[Matt666]

Désolé c'sest moi qui te répond...

 

mais le garde en mémoire

En fait je crois que ça dépend du résultat...

 

Pour moi la récursivité (pour cette fonction, eb tout cas), c'est comme un train :P :

il commence par un wagon, si ça l'intéresse, il continue en gradant le wagon. S'il c'est le cas contraire, il supprime le wagon.

Et c'est pour ça que ta routine doit dire qu'il faut garder ou non l'élément de la liste testé.

(cons (cdr (assoc 10 lst))
(Bred4 (vl-remove (assoc 10 lst) lst)))

En fin de compte il ne garde pas en mémoire, puisque c'est une sous-fonction bred4 de ta routine bred4. Tu ajoutes l'élément à ta liste à chaque validation de ton test.

 

Comme dis gile :

Que se passe t'il avec ta fonction si (caar lst) est différent de 10 ?

 

J'espère que tu ne trouveras mon explication trop désobligeante (des wagons...), en tout cas ce n'est pas le cas... J'ai beacoup de mal aussi pour les fonctions récursives...

 

A bientot !

Matt.

[(gile)]

Le principe de l'empilement/dépilement, c'est ça, l'evaluation d'une expression de la fonction est une nouvelle évaluation de la fonction (l'argument étant différent). Et ce, jusquà ce que la dernière évaluation, en remplissant la condition d'arrêt retourne un résultat, qui est passé à l'expression précédente et ainsi de suite.

 

Avec les listes le fonctionnement est assez proche de l'utilisation de while quand on "transvase" les éléments la liste argument dans la la liste résultat

 

(while arg ; condition d'arrêt : arg = nil

(if test

(setq retour (cons (car arg) retour) arg (cdr arg)) ; on transvase

(setq arg (cdr arg)) ; ou on vide

)

)

(reverse retour)

 

Un fonction récursive équivalente n'a pas besoin d'une autre variable (retour) ni de reverse

 

(defun fonction (arg)

(if arg ; condition d'arrêt : arg = nil

(if test

(cons (car arg) (fonction (cdr arg))) ; on empile

(fonction (cdr arg)) ; on poursuit

)

)

 

les (cons (car arg) (cons (car arg) ...) s'empilent (arg étant à chaque fois différent) jusqu'à ce que l'évaluation soit (fonction nil) = nil, le dépilement est alors l'évaluation d'une expression du style :

(cons ele_1 (cons ele_2 ... (cons ele_n nil) -> (ele_1 ele_2 ... ele_n)