Cadeira de Procura e Planeamento

Transcrição

1 Cadeira de Procura e Planeamento Fausto Almeida Mestrado em Engenharia Informática e de Computadores 1º Ano 1

2 Lisp Diferentes ambientes de desenvolvimento Allegro Common Lisp v8.2 or v9.0 fortemente recomendado pois vai ser usado para testar os projectos Steel Bank Common Lisp C-lisp CMU-CL 2

3 Elementos da linguagem Elementos primitivos números: 10, 1.567, 5/8 símbolos: s1, if, +, -, * símbolos especiais: T, NIL Combinações notação prefixa listas (* ( ) 23) (- 23 (/ (* 57 34) 687)) (and (= 3 4) (< 3 4) (> 3 4)) 3

4 Avaliaçao Ciclo read-eval-print avaliação vs compilação Elementos primitivos Combinações Formas especiais quote, if,... Macros and, or, cond... 4

5 Avaliação > (and (= 10 10) (> 10 5)) T > (or 10 (> 22 8) teste) 10 > (and (= 10 10) teste) Error: Attempt to take the value of the unbound variable `TESTE'. [condition type: UNBOUND-VARIABLE] > 5

6 Listas Muitas Primitivas cons, list, consp, listp, first, rest, car, cdr, cadr, cdar (até 3 combinações de a e d), second (até 10), nth, length, append, find, filter, replace, remove, remove-duplicates... > (cons 1 ()) (1) > (cons 1 '(1 2 3)) ( ) > (cons 1 ( )) (1. 6) > (rest '( )) (1 2 3) > 6

7 Lisp - Hierarquia de tipos 7

8 Lisp - Hierarquia de tipos 8

9 Primitivas de Controle Mais comuns if, cond > (if (> 10 5) 10 5) 10 > (cond ((> 10 5) 10) (T 5)) 10 9

10 Funções > (defun meu-max (x y) (if (> x y) x y)) MEU-MAX > (meu-max 10 5) 10 10

11 Funções > (defun max (x y) (if (> x y) x y)) Error: Attempt to make a FUNCTION definition for the name MAX. This name is in the COMMON-LISP package and redefining it is a violation for portable programs. Replacing the current definition of #<Function MAX> may be dangerous. The package COMMON-LISP has PACKAGE-DEFINITION-LOCK set, which causes the system to signal this violation. [condition type: PACKAGE-LOCKED-ERROR] 11

12 Funções Recursivas > (defun comp (l) (if (null l) 0 (1+ (comp (rest l))))) COMP > (comp '(1 2 3)) 3 12

13 Funções Recursivas > (trace comp) (COMP) > (comp '(1 2 3)) 0: (COMP (1 2 3)) 1: (COMP (2 3)) 2: (COMP (3)) 3: (COMP NIL) 3: returned 0 2: returned 1 1: returned 2 0: returned

14 Funções que recebem funções > (funcall #' ) 6 > (apply #'+ '(1 2 3)) 6 > (mapcar #'1+ '(1 2 3)) (2 3 4) 14

15 Funções com Argumentos Opcionais > (defun ex (a b &optional c (d 66) &rest keys &key test (start 0)) (list a b c d keys test start)) EX > (ex 1 2) (1 2 NIL 66 NIL NIL 0) > (ex :test 'equal :start 50) ( (:TEST EQUAL :START 50) EQUAL 50) 15

16 Atribuição > (setf var1 20 var2 30) 30 > (psetf var1 100 var2 (+ var1 10)) NIL > var1 100 > var2 30 > 16

17 Constantes e variáveis globais USER(35): (defconstant VALOR-PI ) VALOR-PI USER(36): VALOR-PI USER(37): (setf VALOR-PI 3.14) Error: Cannot change the value of VALOR-PI -- it is a constant. 17

18 Constantes e variáveis globais USER(7): (defvar *ano* 2000) *ANO* USER(8): *ano* 2000 USER(9): (setf *ano* 2001) 2001 USER(10): (defvar *ano* 2005) *ANO* USER(11): *ano*

19 Constantes e variáveis globais USER(1): (defparameter *idade* 25) *IDADE* USER(2): *idade* 25 USER(3): (setf *idade* 23) 23 USER(4): *idade* 23 USER(5): (defparameter *idade* 18) *IDADE* USER(6): *idade* 18 19

20 Variáveis locais (let ((x 10)) (+ (let ((x 11) (y (+ x 4))) (+ x y)) (+ x 2))) > 37 (let ((x 10)) (+ (let* ((x 11) (y (+ x 4))) (+ x y)) (+ x 2))) > 38 20

21 Closures (defun contador () (let ((x 0)) # (lambda () (incf x)))) > (setf *contador-1* (contador)) #<Interpreted Closure (:INTERNAL #x20bd785a> > (funcall *contador-1*) 1 > (funcall *contador-1*) 2 > (setf *contador-2* (contador)) #<Interpreted Closure (:INTERNAL #x20bf8152> > (funcall *contador-2*) 1 21

22 Funções locais (defun soma-quadrados (x y) (flet ((quadrado (x) (* x x))) (+ (quadrado x) (quadrado y)))) (defun posicao (el l) (labels ((posicao-aux (pos l) (cond ((null l) nil) ((= el (first l)) pos) (t (posicao-aux (1+ pos) (rest l)))))) (posicao-aux 1 l))) 22

23 Devolver Múltiplos Valores > (values 1 2) 1 2 > (values 1 2 3) > (values) > (values 1) 1 > 23

24 Devolver Múltiplos Valores multiple-value-list form => list multiple-value-setq vars form => result > (multiple-value-setq (quotient remainder) (truncate 3.2 2)) 1 > quotient 1 > remainder 1.2 > 24

25 Devolver Múltiplos Valores multiple-value-bind (var*) values-form declaration* form* > (multiple-value-bind (f r) (floor 103 5) (list f r)) (20 3) > 25

26 Ciclos > (let ((n 0)) (loop (print (1+ n)) (setq n (1+ n)) (when (> n 100) (return 'fim)))) FIM > (do ((n 0 (1+ n))) ((>= n 100) 'fim) (print (1+ n))) FIM 26

27 Ciclos > (dotimes (n 100 'fim) (print (1+ n))) FIM > (dolist (n '(a b c) 'fim) (print n)) A B C FIM 27

28 Arrays USER(3): (array-dimensions #((1 2)(3 4))) (2) USER(1): (setf array1 (make-array '(3 3) :initial-contents '((1 2 3) (4 5 6) (7 8 9)))) #2A((1 2 3) (4 5 6) (7 8 9)) USER(2): (setf array2 (make-array '(3 3) :initial-element 1)) #2A((1 1 1) (1 1 1) (1 1 1)) USER(6): (array-dimensions array1) (3 3) USER(5): (aref array1 0 1) 2 USER(8): (setf (aref array1 0 2) 0) 0 USER(9): array1 #2A((1 2 0) (4 5 6) (7 8 9)) 28

29 Arrays > (defun conta-negativos (array-tri-dim) (let ((num-negativos 0)) (dotimes (i (array-dimension array-tri-dim 0) num-negativos) (dotimes (j (array-dimension array-tri-dim 1)) (dotimes (k (array-dimension array-tri-dim 2)) (if (< (aref array-tri-dim i j k) 0) (incf num-negativos))))))) CONTA-NEGATIVOS > (setf a1 (make-array '(2 2 2) :initial-contents '(((-1 2) (-1 2)) ((-1 2) (-1 2))))) #3A(((-1 2) (-1 2)) ((-1 2) (-1 2))) > (conta-negativos a1) 4 29

30 Structures Criação de um novo tipo de structure ALUNO : > (defstruct aluno nome numero ano) ALUNO São criadas automaticamente as primitivas: make-aluno, aluno-nome, aluno-numero, aluno-ano, aluno-p, copy-aluno > (setf aluno-1 (make-aluno)) #S(ALUNO :NOME NIL :NUMERO NIL :ANO NIL) > (aluno-nome aluno-1) NIL > (aluno-numero aluno-1) NIL > (aluno-ano aluno-1) NIL > (setf (aluno-nome aluno-1) "João Pereira") "João Pereira" > (aluno-nome aluno-1) "João Pereira" 30

31 Structures > (setf aluno-2 (make-aluno :nome "Luís" :numero :ano 2003)) #S(ALUNO :NOME "Luís" :NUMERO :ANO 2003) > (aluno-nome aluno-2) "Luís" > (aluno-p aluno-2) T > (setf aluno-3 (copy-aluno aluno-2)) #S(ALUNO :NOME "Luís" :NUMERO :ANO 2003) > (eq aluno-2 aluno-3) NIL 31

32 Hash Tables make-hash-table &key test size rehash-size rehashthreshold => hash-table Test é por defeito a função eql. Só é possível usar eql, eq e equal. gethash key hash-table &optional default => value, present-p hash-table-p object => generalized-boolean hash-table-count hash-table => count 32

33 Hash Tables > (setq table (make-hash-table)) #<EQL hash-table with 0 #x20ccb42a> > (gethash 1 table) NIL NIL > (setf (gethash 1 table) "one") "one > (gethash 1 table) "one T > 33

34 Hash Tables remhash key hash-table => generalized-boolean clrhash hash-table => hash-table maphash function hash-table => nil 34

35 Hash Tables > (setq table (make-hash-table)) #<EQL hash-table with 0 #x20cd88fa> > (dotimes (i 10) (setf (gethash i table) i)) NIL > (let ((sum-of-squares 0)) (maphash #'(lambda (key val) (let ((square (* val val))) (incf sum-of-squares square) (setf (gethash key table) square))) table) sum-of-squares)

36 Macros Uma macro é uma forma LISP que é expandida para outra forma. > (defmacro nil! (x) (list 'setf x nil)) NIL! > (setf a 5) 5 > a 5 > (nil! a) NIL > a NIL 36

37 Macros > (macroexpand-1 '(nil! a)) (SETF A NIL) T > (macroexpand '(nil! a)) (LET* ((#:G NIL)) (SETQ A #:G114294)) T 37

38 Macros > (defmacro while (test &rest body) (list* 'loop (list 'unless test '(return nil)) body)) WHILE > (setf i 8) 8 > (while (< i 10) (print (* i i)) (incf i)) NIL > (macroexpand-1 '(while (< i 10) (print (* i i)) (incf i))) (LOOP (UNLESS (< I 10) (RETURN NIL)) (PRINT (* I I)) (INCF I)) T 38

39 Macros Uso de backquote, vígula > (defmacro while-2 (test &rest body) `(loop (unless,test (return nil)),@body)) WHILE-2 > (macroexpand-1 '(while-2 (< i 10) (print (* i i)) (incf i))) (LOOP (UNLESS (< I 10) (RETURN NIL)) (PRINT (* I I)) (INCF I)) T > (macroexpand-1 '(while (< i 10) (print (* i i)) (incf i))) (LOOP (UNLESS (< I 10) (RETURN NIL)) (PRINT (* I I)) (INCF I)) T 39

40 Macros > (defmacro for (var start stop &body body) `(do ((,var,start (1+,var))) FOR > (macroexpand-1 '(for i 10 (fact 4) (print i))) (DO ((I 10 (1+ I))) ((> I (FACT 4))) (PRINT I)) 40

41 Macros Versão que não avalia repetidamente a forma de paragem > (defmacro for (var start stop &body body) `(do ((,var,start (1+,var)) (gstop,stop)) ((>,var gstop)),@body)) FOR 41

42 Macros Problemas > (for i (print i)) NIL > (for i (decf gstop) (print gstop)) NIL 42

43 Macros Utilização de gensym > (defmacro for (var start stop &body body) (let ((gstop (gensym))) `(do ((,var,start (1+,var)) (,gstop,stop)) FOR > (macroexpand-1 '(for i 10 (fact 4) (print i))) (DO ((I 10 (1+ I)) (#:G (FACT 4))) ((> I #:G114334)) (PRINT I)) T > (macroexpand-1 '(for i 10 (fact 4) (print i))) (DO ((I 10 (1+ I)) (#:G (FACT 4))) ((> I #:G114336)) (PRINT I)) T 43

44 Desenvolvimento Lisp 1- Desenvolvimento de um prototipo rápido, utilizando abstracção para facilitar as mudanças 2 - Instrumentação do programa atravs do profiling, de maneira a determinar onde é que se perde a maioria do tempo (regra dos 10%) 3 - Substituir as partes lentas por partes mais rápidas. 3.1 Alto nível Transformar processos recursivos em iterativos Memoization Lazy Evaluation 3.2 Baixo nível Evitar listas de argumentos complexas Evitar funções genéricas Evitar consing (utilização de funções destrutivas) Declarações Usar o tipo correcto de dados 44

45 Processos recursivos vs iterativos Recursão com operações adiadas processo recursivo (defun my-length (lst) (if (null lst) 0 (1+ (my-length (cdr lst))))) Recursão sem operações adiadas processo iterativo (defun my-length-tail (lst) (labels ((len (lst acc) (if (null lst) acc (len (cdr lst) (1+ acc))))) (len lst 0))) 45

46 Memoization Valores calculados por uma função são armazenados para posterior reulitização (let ((table (make-hash-table))) (defun fib (n) (multiple-value-bind (val found-p) (gethash n table) (if found-p val (setf (gethash n table) (if (<= n 1) 1 (+ (fib (1- n)) (fib (- n 2))))))))) 46

47 Memoization Generalização (defun memo (fn) (let ((table (make-hash-table))) #'(lambda (arg) (multiple-value-bind (val found-p) (gethash arg table) (if found-p val (setf (gethash arg table) (funcall fn arg))))))) 47

48 Memoization > (setf fact-fn (memo #'fact)) > (funcal fact-fn 5) > (trace fact) (FACT) > (funcall fact-fn 5) 0: (FACT 4) 1: (FACT 3) 2: (FACT 2) 3: (FACT 1) 3: returned 1 2: returned 2 1: returned 6 0: returned > (funcall fact-fn 5) 120 > (funcall fact-fn 6) 0: (FACT 5) 1: (FACT 4) 2: (FACT 3) 3: (FACT 2) 4: (FACT 1) 4: returned 1 3: returned 2 2: returned 6 1: returned 24 0: returned

49 Memoization Melhorias (defun memoize (fn-name) (setf (fdefinition fn-name) (memo (fdefinition fn-name)))) (defun memo (fn) (let ((table (make-hash-table :test #'equal))) #'(lambda (&rest args) (multiple-value-bind (val found-p) (gethash args table) (if found-p val (setf (gethash args table) (apply fn args))))))) 49

50 Memoization > (trace fact) > (memoize 'fact) #<Interpreted Closure (:INTERNAL #x280eb2aa> CL-USER(19): (fact 5) 0[9]: ((:INTERNAL MEMO) 5) 1[9]: ((:INTERNAL MEMO) 4) 2[9]: ((:INTERNAL MEMO) 3) 3[9]: ((:INTERNAL MEMO) 2) 4[9]: ((:INTERNAL MEMO) 1) 5[9]: ((:INTERNAL MEMO) 0) 5[9]: returned 1 4[9]: returned 1 3[9]: returned 2 2[9]: returned 6 1[9]: returned 24 0[9]: returned > (fact 5) 0[9]: ((:INTERNAL MEMO) 5) 0[9]: returned > (fact 6) 0[9]: ((:INTERNAL MEMO) 6) 1[9]: ((:INTERNAL MEMO) 5) 1[9]: returned 120 0[9]: returned > 50

51 Avaliação vs Compilação > (defun fib (n) (if (<= n 1) 1 (+ (fib (- n 1)) (fib (- n 2))))) FIB > (time (fib 30)) ; cpu time (non-gc) 46,126 msec user, 0 msec system ; cpu time (gc) 23,755 msec user, 0 msec system ; cpu time (total) 69,881 msec (00:01:09.881) user, 0 msec system ; real time 69,880 msec (00:01:09.880) ; space allocation: ; 26,925,472 cons cells, 0 symbols, 86,164,448 other bytes, 0 static bytes

52 Avaliação vs Compilação > (compile 'fib) FIB NIL NIL > (time (fib 30)) ; cpu time (non-gc) 181 msec user, 0 msec system ; cpu time (gc) 0 msec user, 0 msec system ; cpu time (total) 181 msec user, 0 msec system ; real time 180 msec ; space allocation: ; 1 cons cell, 0 symbols, 0 other bytes, 0 static bytes > 52

53 Directivas do Compilador Directivas para modificar a forma como as funções são compiladas em LISP: - speed - diz respeito à velocidade do código gerado - compilation-speed - Velocidade da compilação - safety - quantidade de verificação de erros no código gerado - space - espaço ocupado em memória pelo código gerado - debug - quantidade de informação retida para efeitos de debug Directivas podem ter associado um valor entre: 0 (pouco importante) e 3 (muito importante). Directivas podem ser introduzidas no código: - Globalmente através da instrução declaim - Localmente através da instrução declare 53

54 Directivas do Compilador Globalmente (declaim (optimize (speed 3) (compilation-speed 0) (space 3) (safety 0))) Localmente (defun fact (n) (declare (optimize (speed 3) (safety 0) (debug 0))) (if (= n 0) 1 (* n (fact (- n 1))))) 54

55 Evitar consing Implemantação 1 (defun totais (l) (reduce #'+ (remove-if #'oddp (mapcar #'first l)))) Implementação 2 (defun totais2 (l) (let ((res 0)) (dolist (elm l res) (when (not (oddp (first elm))) (incf res (first elm)))))) 55

56 Evitar consing > (setf *lista* (cria-lista 10000)) (( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )...) > (compile 'totais) TOTAIS NIL NIL > (compile 'totais2) TOTAIS2 NIL NIL 56

57 Evitar consing > (setf *lista* (cria-lista )) (( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )...) > (time (totais *lista*)) ; cpu time (non-gc) 0 msec user, 0 msec system ; cpu time (gc) 62 msec user, 0 msec system ; cpu time (total) 62 msec user, 0 msec system ; real time 62 msec ; space allocation: ; 150,001 cons cells, 1,063,384 other bytes, 0 static bytes

58 Evitar consing > (setf *lista* (cria-lista )) (( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( ) ( )...) > (time (totais2 *lista*)) ; cpu time (non-gc) 0 msec user, 0 msec system ; cpu time (gc) 16 msec user, 0 msec system ; cpu time (total) 16 msec user, 0 msec system ; real time 16 msec ; space allocation: ; 1 cons cell, 1,063,384 other bytes, 0 static bytes

59 Tipificação Globalmente (declaim (single-float *count*)) Localmente (defun soma (x y) (declare (optimize (size 3) (speed 3) (debug 0) (safety 0)) (fixnum x y)) (+ x y)) 59

60 Tipificação (defun soma (x y) (+ x y)) (compile 'soma) (disassemble 'soma) ;; ;; code start: #x210460cc: ;; 0: 55 pushl ebp ;; 1: 8b ec movl ebp,esp ;; 3: 56 pushl esi ;; 4: 83 ec 24 subl esp,$36 ;; 7: 83 f9 02 cmpl ecx,$2 ;; 10: jz 14 ;; 12: cd 61 int $97 ; EXCL::TRAP-ARGERR ;; 14: 80 7f a3 00 cmpb [edi-93],$0 ; SYS::C_INTERRUPT ;; 18: jz 22 ;; 20: cd 64 int $100 ; EXCL::TRAP-SIGNAL-HIT ;; 22: 8b d8 movl ebx,eax ;; 24: 0b da orl ebx,edx ;; 26: f6 c3 03 testb bl,$3 ;; 29: 75 0e jnz 45 ;; 31: 8b d8 movl ebx,eax ;; 33: 03 da addl ebx,edx ;; 35: jo 45 ;; 37: 8b c3 movl eax,ebx ;; 39: f8 clc ;; 40: c9 leave ;; 41: 8b 75 fc movl esi,[ebp-4] ;; 44: c3 ret ;; 45: 8b 5f 9f movl ebx,[edi-97] ; EXCL::+_2OP ;; 48: ff call *[edi+39] ; SYS::TRAMP-TWO ;; 51: eb f3 jmp 40 ;; 53: 90 nop 60

61 Tipificação (defun soma (x y) (declare (optimize (size 3) (speed 3) (debug 0) (safety 0))) (+ x y)) (compile 'soma) (disassemble 'soma) ;; ;; code start: #x21049d3c: ;; 0: 8b d8 movl ebx,eax ;; 2: 0b da orl ebx,edx ;; 4: f6 c3 03 testb bl,$3 ;; 7: 75 0d jnz 22 ;; 9: 8b d8 movl ebx,eax ;; 11: 03 da addl ebx,edx ;; 13: jo 22 ;; 15: 8b c3 movl eax,ebx ;; 17: f8 clc ;; 18: 8b 75 fc movl esi,[ebp-4] ;; 21: c3 ret ;; 22: 8b 5f 9f movl ebx,[edi-97] ; EXCL::+_2OP ;; 25: ff jmp *[edi+39] ; SYS::TRAMP-TWO 61

62 Tipificação (defun soma (x y) (declare (optimize (size 3) (speed 3) (debug 0) (safety 0)) (fixnum x y)) (+ x y)) (compile 'soma) (disassemble 'soma) ;; ;; code start: #x2104b4cc: ;; 0: 03 c2 addl eax,edx ;; 2: f8 clc ;; 3: 8b 75 fc movl esi,[ebp-4] ;; 6: c3 ret ;; 7: 90 nop 62