CONS e APPEND

Esses tempos postei uma rotina no forum autolisp que iterava uma lista de elemetos e retornava todas as combinações 2 a 2 possíveis nesta lista, sem repetir e não importando a ordem dos elementos, bom, ela funciona tranquilamente, mas se alguem já testou para um grande número de elementos, notou que ele é um tanto LENTA DEMAIS…

Mas por que será? a rotina é pequena, não faz rodeios… em fim… essa semana estive fazendo uns testes com as funções CONS e APPEND do autolisp, pra ver qual retornava resultados mais rápidos… fiz testes tambem entre o FOREACH e o REPEAT

Destes dois últimos, concluí que o FOREACH tem uma pequena vantagem, quase que imperceptível, mas isso deve ser porque para usar o REPEAT, preciso incrementar um índice manualmente… Bom, o caso mesmo é entre o CONS e o APPEND (ou a forma como escrevi os programas… não sei)

Os programas testados são estes:
clique para ver…

;devolve uma lista interada de uma função no estilo todos-contra-todos sem repetir combinações
(defun todos-contra-todos (lst fun / l c q r)
(
setq l 0
q (length lst))
(
repeat (1- q)
(
setq c (1+ l))
(
repeat (q c)
(
setq r (append r (list (fun (nth l lst) (nth c lst))))
c (1+ c)))
(
setq l (1+ l)))
r)

(defun todos-contra-todos2 (lst fun / a b lst3)
(
foreach a lst
(foreach b (setq lst (cdr lst))
(
setq lst3 (append lst3 (list (fun a b))))))
lst3)

(defun todos-contra-todos3 (lst fun / a b lst3)
(
foreach a lst
(foreach b (setq lst (cdr lst))
(
setq lst3 (cons (fun a b) lst3))))
(
reverse lst3))

;rotina para criar uma lista temporaria:
(defun expandlist (el qtd / lst)
(
repeat qtd (setq lst (cons el lst))))

;rotina para calcular o tempo de execução:
(defun testtime (fun / t1 t2)
(
setq t1 (getvar “date”)
t1 (* 86400.0 (t1 (fix t1))))
(
eval fun)
(
setq t2 (getvar “date”)
t2 (* 86400.0 (t2 (fix t2))))
(
t2 t1))

;|********************************TESTES*****************************
;testem as opções:
(todos-contra-todos3 ‘(1 2 3 4 5) (lambda (a b) (list a b)))
-> ((1 2) (1 3) (1 4) (1 5) (2 3) (2 4) (2 5) (3 4) (3 5) (4 5))

(todos-contra-todos2 ‘(1 2 3 4 5) (lambda (a b) (list a b)))
-> ((1 2) (1 3) (1 4) (1 5) (2 3) (2 4) (2 5) (3 4) (3 5) (4 5))

(todos-contra-todos ‘(1 2 3 4 5) (lambda (a b) (list a b)))
-> ((1 2) (1 3) (1 4) (1 5) (2 3) (2 4) (2 5) (3 4) (3 5) (4 5))
;todas retornam o mesmo valor… o que é de se esperar

;criar uma lista com 100 elementos:
(setq aa (expandlist nil 100))

;AVALIAR O TEMPO DE EXECUÇÃO DE CADA UMA DAS SUBROTINAS:
(testtime ‘(todos-contra-todos aa (lambda (a b) nil))) ;2.60996
(testtime ‘(todos-contra-todos2 aa (lambda (a b) nil))) ;2.57798
(testtime ‘(todos-contra-todos3 aa (lambda (a b) nil))) ;0.0149667 !!!!
;|

como podem ver nos programas e nos testes, o programa “todos-contra-todos3” obteve um tempo cerca de 200 vezes melhor!!! e detalhe: a lista precessada tinha apenas 100 elementos….

teste com uma lista de 500 elementos, “todos-contra-todos3” obteve um tempo de resposta de 1.07 segundos, já os outros…. ainda estão processando!!!

donde concluo que, usar o CONS é preferível ao APPEND, pois demora menos…
deve ser por que o append avalia a lista TODA ANTES, procura o seu final e aí acrescenta uma nova lista no fim… sei lá….

façam o teste, copiem a rotina e testem… o rogério ( do forum autolisp ) já fez o teste e chegou em valores próximos aos meus…

Deixe um comentário

Carrinho de compras
Scroll to Top