La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Mosaic manipola oggetti primitivi (ruota e unisci) regole: 1.un mosaico è uno dei pezzi primitivi 2.si ottiene ruotano di 90° in senso orario un mosaico.

Presentazioni simili


Presentazione sul tema: "Mosaic manipola oggetti primitivi (ruota e unisci) regole: 1.un mosaico è uno dei pezzi primitivi 2.si ottiene ruotano di 90° in senso orario un mosaico."— Transcript della presentazione:

1 mosaic manipola oggetti primitivi (ruota e unisci) regole: 1.un mosaico è uno dei pezzi primitivi 2.si ottiene ruotano di 90° in senso orario un mosaico 3.si ottiene unendo un mosaico a destra di un mosaico della stessa altezza 4.niente altro è un mosaico

2

3

4 sintassi di espressioni che denotano mosaici E è una espressione se E è a E è b E è ruota(E 1 ) e E 1 è unespressione E è unisci(E 1,E 2 ), e E 1 e E 2 sono espressioni niente altro è espressione ::= a | b | ruota( ) | unisci(, )

5 semantica delle espressioni specifica il mosaico denotato da unespressione unisci(ruota(ruota(b)),a) che mosaico definisce?

6 funzioni definite dallutente fun controruota(x) = ruota(ruota(ruota(x))) fun impila(x,y) = controruota(unisci(ruota(y),ruota(x)))

7 dichiarazioni locali let in end let fun controruota(x) = ruota(ruota(ruota(x))) fun impila(x,y) = controruota(unisci(ruota(y),ruota(x))) in impila(controruota(b),ruota(b)) denota il mosaico precedente espressione let o let-binding

8 nomi per valori definiti dallutente val = let val x = E 1 in E 2 end dice che loccorrenza del nome x nellespressione E 2 rappresenta il valore di E 1 let val no = controruota(b) val se = ruota(b) in impila(no,se) end dichiarazione di valore espressione precedente con nomi più significativi

9

10 discussione: abbiamo lasciato in sospeso molti punti – notazione: nellespressione unisci(a,b) la funzione unisci è scritta prima dei suoi argomenti; esistono altre notazioni? – valutazione: nel valutare lespressione E 1 e E 2 si valuta prima E 1 e poi E 2 ? e se la prima espressione influenza la seconda? – funzioni: cosa succede se una funzione è definita in termini di se stessa? – ambito dei nomi: cambiare i nomi può cambiare il significato di una espressione? – checking: cosa succede se una funzione riceve meno argomenti di quelli previsti, o argomenti di tipo diverso?

11

12 Notazioni per le espressioni -infissa (a+b) -prefissa (+ab) costante o variabile op applicato a a e b si scrive op a b - postfissa (ab+)

13 associatività e precedenza come si valuta a + b * c ?? - parentesi - precedenza fra operatori - raggruppati da sinistra verso destra operatori associativi a sinistra (es. sottrazione) operatori associativi a destra (es. potenza)

14 rappresentazione ad albero di unespressione radice -> operatore per ogni operando figlio della radice -> sottoalbero per loperando b*b-4*a*c _ * bb * c 4 * a

15 alberi astratti: denotano la struttura dellespressione senza tener conto della notazione lalbero dellesempio precedente è lo stesso per le tre notazioni prefissa:-*bb**4ac infissa:b*b-4*a*c postfissa:bb*4a*c*-

16 Valutazione di espressioni in generale, per valutare (E op F) si valutano E ed F in qualche ordine e si applica ai valori risultanti loperatore op - valutazione come riscrittura di alberi - valutazione tramite stack

17 valutazione come riscrittura di alberi infissa 7 * 7 – 4 * 2 * 3 = 49 – 4 * 2 * 3 = 49 – 8 * 3 = 49 – 24 = 25 postfissa 7 7 * 4 2 * 3 * – = * 3 * – = * – = – = 25

18 _ * 77 * 3 4 * 2 _ 49* 3 * 4 _ * _ 24 25

19 valutazione tramite stack espressione in notaz. postfissa leggere da sinistra a destra se cè una costante c, push(c) se cè un operatore binario op, push(pop op pop) risultato = top

20 valutazione tramite stack espressionestackazione 7 7 * 4 2 * 3 * –7push * 4 2 * 3 * –7 7push * 4 2 * 3 * –49mult 7 7 * 4 2 * 3 * –49 4push * 4 2 * 3 * –49 4 2push * 4 2 * 3 * –49 8mult 7 7 * 4 2 * 3 * –49 8 3push * 4 2 * 3 * –49 24mult 7 7 * 4 2 * 3 * –25subtr

21 Dichiarazioni e applicazioni di funzione funzioni come corrispondenze f : A -> B mappa gli elementi del dominio in quelli del codominio f è totale se associa ad ogni elemento di A uno di B f è parziale se è indefinita per qualche elemento di A

22 funzioni come algoritmi una dichiarazione di funzione è formata da - nome - parametri - regola per calcolare il risultato partendo dai parametri dichiarazione: fun ( ) = applicazione: ( ) es.fun successore (n) = n+1;successore(2+3)

23 valutazione (attivazione) innermost ( )è calcolata: - valuta le espressioni in - sostituisci i risultati ai parametri formali nel corpo della funzione -valuta il corpo - restituisci il valore come risposta la tecnica è detta anche chiamata per valore

24 valutazione selettiva if then else fun abs(n)= if n >= 0 then n else 0-n fun or(n)= if x = true then true else if y = true then true else false

25 funzioni ricorsive una funzione f è ricorsiva se il suo corpo contiene unapplicazione di f (o se può attivare se stessa, anche indirettamente); ad esempio fun fib(n)= if (n=0 or n=1) then 1 else fib(n-1)+fib(n-2) la funzione è valutata come sempre: i parametri attuali sono calcolati e sostituiti nel corpo della funzione esempio: fib(4).

26 ricorsione lineare una funzione f è ricorsiva lineare se una attivazione di f(a) può attivare al più una singola attivazione di f; ad esempio fun fattoriale(n)= if n=0 then 1 else n*fattoriale(n-1) la funzione è valutata in due fasi: – winding, in cui sono iniziate nuove attivazioni – unwinding, in cui le attivazioni rilasciano il controllo (LIFO)

27

28 ricorsione tail una funzione f è tail ricorsiva se restituisce un valore (senza richiedere risorsione) oppure il risultato di una attivazione ricorsiva; ad esempio fun g(n,a)= if n=0 then a else g(n-1, n*a) in questo caso tutto il lavoro è fatto nella fase di winding

29

30 ambito lessicale: significato dei nomi in un programma rinominare in modo consistente le variabili non cambia il valore di unespressione; per rinominare occorre esprimere il concetto di variabile locale (bound) fun successore(x)= x+1 fun successore(n)= n+1 cosa succede se la dichiarazione di funzione fa riferimento a nomi non locali?? fun sommay= x+y successore(5) è sempre 6 y non è locale; dipende dal contesto.

31 regole di ambito lessicale (lexical scope rules): usano il testo del programma in cui si trova una dichiarazione di funzione per determinare il contesto di valutazione dei nomi non locali let val x=2 in x+x end il valore di una espressione non cambia se sostituiamo tutte le occorrenze di una variabile nellambito di un binding di x con una nuova variabile binding di x tutte le occorrenze di x in questa espressione sono nello scope (ambito) del binding (legame)

32 let val x=3 in let val y=4 in x*x+y*y end end let val x=2 in let val x=x+1 in x*x end end se rimpiazzo x con y nel binding più interno ottengo let val x=2 in let val y=x+1 in y*y end end lambito del binding di y include le due occorrenze di y in x*x+y*y lambito del binding di x include le due occorrenze di x in x*x+y*y

33 tipo di unespressione: indica i valori che essa può rappresentare e le operazioni che possono essere applicate una espressione (un oggetto) può avere più di un tipo?? – livello macchina: i valori supportati direttamente dallarchitettura sono i tipi elementari (con operazioni diverse) – livello del linguaggio: tipi strutturati o aggregati (con costruttori di tipo) – livello utente: raggruppamenti di dati e funzioni con nomi (classi)

34 costruttori di insiemi (ognuno con la sua sintassi, gli elementi dellinsieme costruito, le operazioni ammesse): prodotto: A B = {(a,b) | a A, b B} primo(a,b)secondo(a,b) funzione:f:A B es: int int int (insieme di tutte le funzioni che associano un intero a una coppia di interi) sequenza:dato linsieme A, la chiusura di Kleene (A*) sono tutte le ennuple formate a partire da A

35 sistemi di tipi un insieme di regole per associare un tipo alle espressioni di un linguaggio; il sistema rigetta unespressione se non può associare un tipo esempio espressione = variabile, costante, E+F, E-F, E*F, E/F regole di tipo = – i nomi di variabili che cominciano con una lettera fra I e N sono di tipo int – tutti gli altri nomi sono di tipo real – un numero è real se contiene il punto decimale; tutti gli altri sono int –se E ed F sono dello stesso tipo, allora E+F, E-F, E*F, E/Fsono espressioni dello stesso tipo

36 di che tipo è I+J ?? di che tipo è X+Y ?? di che tipo è X+J ?? operatori aritmetici a ogni operatore op è associata una regola che specifica il tipo di unespressione E op F, partendo dai tipi di E ed F overloading simboli di operatori comuni (come + o *) sono sovraccarichi, cioè hanno significati diversi a seconda del contesto in cui sono usati. +: int int intoppure *: int int int

37 coercion (conversione forzata) cosa succede se sommo un int e un real??

38 tipi e controllo degli errori (type checking) garantisce che le operazioni in un programma siano applicate in modo proprio si verifica un errore di tipo se una funzione di tipo S T è applicata a un elemento a che non è di tipo S un programma eseguito (o compilato) senza errori di tipo si dice type safe rispetto ai tipi – controllo statico (sistema forte) – controllo dinamico (sistema debole)

39 introduzione a ML le espressioni, le funzioni e i let binding usati finora sono quelli di ML datatype direzione= nord | sud | est | ovest fun sensoorario(x)= if x=nord then est else if x=est then sud else if x=sud then ovest else nord; valori associati al tipo direzione

40 datatype binalbero= foglia | nonfoglia of binalbero * binalbero foglia nonfoglia(foglia, foglia) nonfoglia(foglia, nonfoglia(foglia, foglia)) definizione ricorsiva

41 fun contafoglie(foglia)= 1 | contafoglie(nonfoglia(s,t))= contafoglie(s)+contafoglie(t) – scrivere la funzione che dice se un albero è una foglia – scrivere la funzione che estrae il sottoalbero destro e sinistro di un albero funzione ricorsiva che conta le foglie dellalbero

42 datatype intalbero= vuoto | nodo of int * intalbero * intalbero albero binario di ricerca

43 fun inserisci(k, vuoto) =nodo(k, vuoto, vuoto) | inserisci(k, nodo(n, s, t)) = if (kn) then nodo(n, s, inserisci(k, t)) else nodo(n, s, t); fun appartiene(k, vuoto) = false | appartiene(k, nodo(n, s, t)) = if (kn) then appartiene(k, t) else true;


Scaricare ppt "Mosaic manipola oggetti primitivi (ruota e unisci) regole: 1.un mosaico è uno dei pezzi primitivi 2.si ottiene ruotano di 90° in senso orario un mosaico."

Presentazioni simili


Annunci Google