Espressioni: da dove si parte

Transcript

1 Università degli Studi di Bologna Facoltà di Ingegneria Fondamenti di Informatica T2 Modulo 2 Corso di Laurea in Ingegneria Informatica Anno accademico 2008/2009 Espressioni: da dove si parte La struttura di cui sopra è sufficiente per modellare le espressioni? 2

2 Critiche al modello Le operazioni (gli operatori) che possono agire su un operando sono contenute nell operando stesso Su tutti i tipi di operando sono possibili tutte le operazioni? Cosa accade se si desidera aggiungere un operazione? A parte un paio di metodi di comodo, altre informazioni sono contenute nell OperandDescriptor È proprio un descrittore di operando? Cosa accade all OperandDescriptor se si aggiungono operazioni? 3 Domande Critiche al modello Su tutti i tipi di operando sono possibili tutte le operazioni? Cosa accade se si desidera aggiungere un operazione? Risposte Non è detto che su tutti i tipi di operando siano possibili tutte le operazioni (l operazione modulo ha senso solo sugli interi!) Se si desidera aggiungere un operazione occorre specificarla nell interfaccia quindi TUTTI i tipi di operando devono implementarla caso precedente! 4

3 Critiche al modello Domanda OperandDescriptor è proprio un descrittore di operando? Risposta A parte le operazioni di comodo getnameofthistype() e isofthistype() che possono effettivamente appartenere ad OperandDescriptor, è evidente che getsumsubneutral() e getmuldivneutral() NON POSSONO APPARTENERE AL DESCRITTORE: sono relative ad una certa operazione aggiungere un operazione significherebbe anche dover aggiungere un metodo all OperandDescriptor! 5 Risultato L aggiunta di un operazione porta a: Inconsistenze in contesti che non possono prevedere l operazione stessa Modifiche a cascata sulle astrazioni (che dovrebbero essere il più possibile stabili ) È necessario un nuovo modello! 6

4 Un nuovo modello Proposte? 7 Un nuovo modello Occorre estrarre le operazioni (d ora in avanti operatori) dagli operandi L aggiunta di un nuovo operatore non deve impattare in alcun modo sulla struttura degli operandi Ogni operatore concreto deve essere una classe a se stante Deve esserci un astrazione che consenta di vedere tutti gli operatori nello stesso modo (per quanto possibile) Per aggiungere un operazione, si aggiunge una classe 8

5 Un nuovo modello Per generalizzare, gli operatori possono essere unari, binari o ternari (altro?) Unari: ad es. il not logico, il meno unario (inversione di segno), ecc. Binari: le operazioni classiche (somma, sottrazione, ecc.) Ternari: ad es. l espressione condizionale Condition? TrueValue : FalseValue 9 Un nuovo modello Rimane da risolvere il problema degli elementi neutri degli operatori binari però, poiché ogni operatore è un entità a se stante: ogni operatore ha il proprio elemento neutro recuperabile tramite un metodo dell operatore stesso se per un certo operatore non è previsto l elemento neutro, il metodo di recupero restituisce null in modo da indicare che l elemento neutro non esiste in quel caso 10

6 Un nuovo modello: UML L operatore generico: l unico dettagli che conosce è il simbolo associato Ora l elemento neutro è associato all operatore! Le operazioni non dotate di elemento neutro restituiscono null L operando generico: è in grado di restituire il proprio valore sotto forma di Object (il minimo sindacale) 11 Interi Semplifichiamo il dominio applicativo considerando solamente operatori binari, quindi eliminando operatori unari e ternari Realizziamo quanto necessario per computare semplici espressioni algebriche fra interi introducendo l operando intero ed i soliti quattro operatori base 12

7 Operando intero 13 Operatori che agiscono su interi 14

8 Verifica di funzionamento Scrivere semplici espressioni (inutile complicare inutilmente) e verificare il risultato Operand result = new IntAdd(). doop( new IntOperand(10), new IntMul().doOp( new IntOperand(7), new IntOperand(3))); result dev essere un IntOperand ((IntOperand)result).getIntValue() deve restituire public interface Operand Object getvalue(); Soluzioni public class IntOperand implements Operand private int value; public IntOperand(int value) setintvalue(value);... 16

9 Soluzioni public Object getvalue() return this.value; public int getintvalue() return this.value; protected void setintvalue(int value) this.value = value; public String tostring() return Integer.toString(this.value); 17 public interface Operator String getsymbol(); Soluzioni public interface BinaryOperator extends Operator Operand doop(operand left, Operand right); Operand getneutral(); 18

10 Soluzioni public class IntAdd implements BinaryOperator public Operand doop(operand left, Operand right) IntOperand intleft = (IntOperand)left; IntOperand intright = (IntOperand)right; return new IntOperand(intLeft.getIntValue() + intright.getintvalue()); public Operand getneutral() return new IntOperand(0); public String getsymbol() return "+"; 19 Soluzioni public class IntMul implements BinaryOperator public Operand doop(operand left, Operand right) IntOperand intleft = (IntOperand)left; IntOperand intright = (IntOperand)right; return new IntOperand(intLeft.getIntValue() * intright.getintvalue()); public Operand getneutral() return new IntOperand(1); public String getsymbol() return "*"; 20

11 Soluzioni public class IntSub implements BinaryOperator public Operand doop(operand left, Operand right) IntOperand intleft = (IntOperand)left; IntOperand intright = (IntOperand)right; return new IntOperand(intLeft.getIntValue() intright.getintvalue()); public Operand getneutral() return new IntOperand(0); public String getsymbol() return "-"; 21 Soluzioni public class IntDiv implements BinaryOperator public Operand doop(operand left, Operand right) IntOperand intleft = (IntOperand)left; IntOperand intright = (IntOperand)right; return new IntOperand(intLeft.getIntValue() / intright.getintvalue()); public Operand getneutral() return new IntOperand(1); public String getsymbol() return "/"; 22

12 Espressioni Con le entità progettate finora siamo in grado SOLAMENTE di valutare le espressioni Non è possibile: effettuare più volte la stessa valutazione a meno di ricostruire l espressione ottenere una rappresentazione dell espressione Cosa manca? 23 Espressioni Abbiamo operandi ed operatori ma non abbiamo qualcosa che mantenga la struttura delle espressioni Le espressioni sono sostanzialmente alberi che mettono in relazione operandi ed operatori + 10 * Non è necessario stabilire una priorità fra gli operatori: l ordine di esecuzione è inequivocabile

13 Alberi di Espressioni Un espressione è un albero che consente: la valutazione dell espressione; di ottenere una rappresentazione prefissa (prima l operatore, poi gli operandi) visita pre-order di ottenere una rappresentazione infissa (classica, con l operatore fra gli operandi attenzione all ordine di esecuzione!!!) visita in-order (se albero binario!) di ottenere una rappresentazione postfissa (prima gli operandi poi l operatore) visita post-order 25 Domanda Alberi di Espressioni La visita necessaria per la valutazione, di che tipo è? Risposta: Occorre PRIMA valutare gli operandi (che possono a loro volta essere espressioni ), POI si compongono gli operandi valutati con l operatore per effettuare il calcolo. Visita POST-ORDER! 26

14 Alberi di Espressioni Un espressione può essere: Un operando Un operatore binario che lavora su due espressioni (definizione ricorsiva!) La struttura può essere composta da: un interfaccia ExpressionTree che espone tutti i metodi di visita (valutazione e rappresentazioni varie); una classe OperandTreeNode che implementa ExpressionTree, che contiene un Operand e che realizza i metodi di visita una classe BinaryOperatorTreeNode che implementa ExpressionTree, che contiene un BinaryOperator e due ExpressionTree e che realizza i metodi di visita 27 Alberi di espressioni 28

15 Rappresentazione infissa * L albero sopra riportato, modella l espressione 10 * (7 + 3) e non 10 * Come prima approssimazione, accontentiamoci di mettere anche le parentesi che non servono in questo caso, quindi (10 * (7 + 3)) 29 Verifica di Funzionamento ExpressionTree expression = new BinaryOperatorTreeNode( new IntAdd(), new OperandTreeNode(new IntOperand(10)), new BinaryOperatorTreeNode( new IntMul(), new OperandTreeNode(new IntOperand(7)), new OperandTreeNode(new IntOperand(3)) )); Operand result = expression.eval(); String inorder = expression.getinfixrepresentation(); String preorder = expression.getprefixrepresentation(); String postorder = expression.getpostfixrepresentation(); 30

16 Soluzioni public interface ExpressionTree Operand eval(); String getprefixrepresentation(); String getinfixrepresentation(); String getpostfixrepresentation(); 31 Soluzioni public class BinaryOperatorTreeNode implements ExpressionTree private BinaryOperator operator; private ExpressionTree left; private ExpressionTree right; public BinaryOperatorTreeNode(BinaryOperator operator, ExpressionTree leftexpression, ExpressionTree rightexpression) this.operator = operator; this.left = leftexpression; this.right = rightexpression;... 32

17 Soluzioni... public BinaryOperator getoperator() return this.operator; public ExpressionTree getleft() return this.left; public ExpressionTree getright() return this.right; Soluzioni... public Operand eval() return operator.doop(left.eval(), right.eval()); public String getprefixrepresentation() return operator.getsymbol() + " " + getleft().getprefixrepresentation() + " " + getright().getprefixrepresentation();... 34

18 Soluzioni... public String getinfixrepresentation() return "(" + getleft().getinfixrepresentation() + " " + operator.getsymbol() + " " + getright().getinfixrepresentation() + ")"; public String getpostfixrepresentation() return getleft().getpostfixrepresentation() + " " + getright().getpostfixrepresentation() + " " + operator.getsymbol(); 35 Soluzioni public class OperandTreeNode implements ExpressionTree private Operand operand; public OperandTreeNode(Operand operand) this.operand = operand; public Operand eval() return operand; 36

19 Soluzioni... public String getprefixrepresentation() return operand.tostring(); public String getinfixrepresentation() return operand.tostring(); public String getpostfixrepresentation() return operand.tostring(); 37 Operandi Variabili Date le strutture precedenti, introdurre la classe IntVarOperand che consenta di modellare variabili intere IntVarOperand var = new IntVarOperand(3); ExpressionTree expression = new BinaryOperatorTreeNode( new IntAdd(), new OperandTreeNode(new IntOperand(10)), new BinaryOperatorTreeNode( new IntMul(), new OperandTreeNode(new IntOperand(7)), new OperandTreeNode(var))); 38

20 Operandi Variabili Operand result = expression.eval(); var.setintvalue(13); result = expression.eval(); Ovviamente, dopo aver variato il valore di un operando, il risultato della computazione deve cambiare Dove si colloca, nella gerarchia, il nuovo operando? 39 Soluzioni public class IntVarOperand extends IntOperand public IntVarOperand(int value) super(value); public void setintvalue(int value) super.setintvalue(value); 40