synthétiser un ensemble de données

[azop]

Bonsoir,

tout d'abort merci beaucoup pour l'aide que vous m'avez apporté jusqu'à présent.

 

j'ai plusieurs listes qui regroupe 3 atomes,

 

et je souhaiterai avoir une synthèse de ses liste comme un tableau croisé dynamique de excel

 

auriez vous une solution ?

[(gile)]

Je ne comprends pas bien la demande : "synthèse de ses liste comme un tableau croisé dynamique", mais LISP ne connais que les listes et les imbrications de listes.

[GEGEMATIC]

Salut, je crois avoir compris, mais si tu me donne ta combine pour faire pareil sous excel, je te paye l'apéro !

tu as 3 listes, avec un index commun :

'((id1 val1 val10)(id2 val2 val20) ... (n))

'((id0 "ch1" "ch10")(id2 "ch2" "ch20") ... (n))

'((id1 1.0 10.0)(id2 2.0 20.0) ... (n))

 

tu veux obtenir les listes consolidées, dans le cas du dessus, seulment le id2 est touhjours présent:

'((id2 val2 val20 "ch2" "ch20" 2.0 20.0) ... (n))

est-ce que c'est ça ?

parceque sous excel, j'y suis arrivé une fois, et puis je ne suis jamais arrivé à le refaire !

[azop]

Salut, je crois avoir compris, mais si tu me donne ta combine pour faire pareil sous excel, je te paye l'apéro !

tu as 3 listes, avec un index commun :

'((id1 val1 val10)(id2 val2 val20) ... (n))

'((id0 "ch1" "ch10")(id2 "ch2" "ch20") ... (n))

'((id1 1.0 10.0)(id2 2.0 20.0) ... (n))

 

tu veux obtenir les listes consolidées, dans le cas du dessus, seulment le id2 est touhjours présent:

'((id2 val2 val20 "ch2" "ch20" 2.0 20.0) ... (n))

est-ce que c'est ça ?

parceque sous excel, j'y suis arrivé une fois, et puis je ne suis jamais arrivé à le refaire !

 

en faite ce que je veux obtenir c'est le tableau entouré de rouge sur la capture d'écran.

en partant des listes :

(id1 10 21 m)

(id2 15 2 p)

(id0 12 10 p)

(id2 16 20 m)

(id1 1 10 m)

(id2 2 20 p)

le résultat sur autocad serait :

(id0 "" "" 12 10)

(id1 11 31 "" "")

(id2 16 20 17 22)

je pense qu'on peut y arriver en utilisant la commande "if" dans tout les sens sa doit bien être possible, mais y aurait il une solution plus simple

[GEGEMATIC]

salut,

je ne devrais jamais venir sur ces forums ...

voilà un lisp pour créer une liste d'association totalisant par id et par code m ou p.

après il faudra savoir l'exploiter avec des assoc .

si tua aplus de valeur que 2 de suite, il faudra passer à des nth au lieu des cdr cddr etc ..

 

(setq ldep 
'(("id1" 10 21 "m")
("id2" 15 2 "p")
("id0" 12 10 "p")
("id2" 16 20 "m")
("id1" 1 10 "m")
("id2" 2 20 "p")))

(setq lassoc
      (mapcar '(lambda (x) (list (car x) (list (last x) (cadr x) (caddr x)))) ldep))

;; à ce stade:
lassoc = (("id1" ("m" 10 21)) ("id2" ("p" 15 2)) ("id0" ("p" 12 10)) ("id2" ("m" 16 20)) 
("id1" ("m" 1 10)) ("id2" ("p" 2 20)))

(foreach l lassoc
 
  
   (if (setq tmp (assoc (setq cd (car l)) res));_si id déja répertorié
     (progn	
(setq nl (append tmp (list (cadr l))))
(setq res (subst nl tmp res))
     )
     
(setq res (cons l res))
    )
   )

(setq nlassoc (reverse res)
     res nil)

;; à ce stade:
nlassoc = (("id1" ("m" 10 21) ("m" 1 10)) ("id2" ("p" 15 2) ("m" 16 20) ("p" 2 20)) 
("id0" ("p" 12 10)))

(setq res nil  sres nil)
(foreach l nlassoc
 
   
     (setq id (car l))
     (foreach sl (cdr l)
(if (setq tmp (assoc (setq atm (car sl)) sres)) ;_si atom déja répertorié
  (progn
(setq nl (list atm
	       (+ (cadr sl)
		  (cadr tmp))
	       (+ (caddr sl)
		  (caddr tmp))
	       )
      )
   
(setq sres (subst nl tmp sres))
)
     
     
(setq sres (cons sl sres))
    )
   )
  
  (setq res (cons (list id sres) res))
 (setq sres nil)

)
;; à l'arrivée, tu a le contenu de ton tableau
res = (("id0" (("p" 12 10))) ("id2" (("m" 16 20) ("p" 17 22))) ("id1" (("m" 11 31))))

[Patrick_35]

Salut

 

Je suis amusé à faire un petit truc

 

(defun atoms (lst / chx ele lon new sel tab tri)
 (defun sel(lst)
   (reverse (cdr (reverse (cdr lst))))
 )
 (defun chx(lst)
   (cons (car lst) (if (eq (last lst) "m")
	      (append (sel lst) lon)
	      (append lon (sel lst))
	    )
   )
 )
 (setq lst (vl-sort lst '(lambda(a B)(< (car a)  (car B))))
tab (car lst)
lst (cdr lst)
 )
 (repeat (length (sel tab))
   (setq lon (cons 0 lon))
 )
 (setq tot (chx tab))
 (while (setq new (car lst))
   (setq tri (sel new))
   (if (eq (car new) (car tab))
     (if (eq (last new) "m")
(setq tot (cons (car tot) (mapcar '+ (cdr tot) (append tri lon))))
(setq tot (cons (car tot) (mapcar '+ (cdr tot) (append lon tri))))
     )
     (setq ele (cons tot ele)
    tot (chx new)
     )
   )
   (setq tab new
  lst (cdr lst)
   )
 )
 (reverse (cons tot ele))
)

 

(atoms '(("id1" 10 21 "m")("id2" 15 2 "p")("id0" 12 10 "p")("id2" 16 20 "m")("id1" 1 10 "m")("id2" 2 20 "p")))
(atoms '(("id1" 10 21 44 "m")("id2" 15 2 8 "p")("id0" 12 10 13 "p")("id2" 16 20 22 "m")("id1" 1 10 2 "m")("id2" 2 20 2 "p")))

 

 

ps : le 0 = ""

 

@+

[(gile)]

Salut,

 

(defun cross (lst / foo bar)
 (defun foo (l a)
   (if	l
     (foo
(cdr l)
(if (setq s (assoc (caar l) a))
  (subst (bar (car l) (cdr s)) s a)
  (cons (bar (car l) '(0 0 0 0)) a)
)
     )
     a
   )
 )
 (defun bar (l a)
   (cons
     (car l)
     (if (= "m" (last l))
(mapcar '+ (list (cadr l) (caddr l) 0 0) a)
(mapcar '+ (list 0 0 (cadr l) (caddr l)) a)
     )
   )
 )
 (vl-sort (foo lst nil) '(lambda (x y) (< (car x) (car y))))
)

 

(cross '(("id1" 10 21 "m") ("id2" 15 2 "p") ("id0" 12 10 "p") ("id2" 16 20 "m") ("id1" 1 10 "m") ("id2" 2 20 "p")))

retourne :

(("id0" 0 0 12 10) ("id1" 11 31 0 0) ("id2" 16 20 17 22))

[(gile)]

Une autre qui utilise une fonction de "groupage" par générateur de clé (imite la méthode .NET GroupBy).

 

(gc:GroupBy 'car '(("id1" 10 21 "m") ("id2" 15 2 "p") ("id0" 12 10 "p") ("id2" 16 20 "m") ("id1" 1 10 "m") ("id2" 2 20 "p")))

retourne :

(("id0" ("id0" 12 10 "p")) ("id2" ("id2" 2 20 "p") ("id2" 16 20 "m") ("id2" 15 2 "p")) ("id1" ("id1" 1 10 "m") ("id1" 10 21 "m")))

 

;; gc:GroupBy (gile)
;; Regroupe les éléments d'une liste selon la fonction spécifiée.
;; Retourne un liste de sous listes dont le premier élément est la clé générée par la fonction.
;;
;; Arguments
;; fun : fonction permettant d'extaire une clé de chaque élément
;; lst : liste à traiter
;;
;; Exemple
;; (gc:GroupBy '(lambda (x) (zerop (rem x 3))) '(1 2 3 4 5 6 7 8 9))
;; => ((T 9 6 3) (nil 8 7 5 4 2 1))

(defun gc:GroupBy (fun lst / key sub res)
 (setq fun (eval fun))
 (foreach l lst
   (setq res
   (if (setq sub (assoc (setq key (fun l)) res))
     (subst (cons key (cons l (cdr sub))) sub res)
     (cons (list key l) res)
   )
   )
 )
)      

(defun cross (lst / sum trim)
 (defun sum (lst)
   (apply 'mapcar (cons '+ (cons '(0 0) (mapcar 'trim lst))))
 )
 (defun trim (lst) (cdr (reverse (cdr (reverse lst)))))
 (mapcar
   (function
     (lambda (x)
(cons (car x)
      ((lambda (l)
	 (append
	   (sum (cdr (assoc "m" l)))
	   (sum (cdr (assoc "p" l)))
	 )
       )
	(gc:GroupBy 'last (cdr x))
      )
)
     )
   )
   (gc:GroupBy 'car lst)
 )
)