Avaliador de Avaliador de ExpressõesExpressões

Luiz Carlos d´Oleron (lcadb)Luiz Carlos d´Oleron (lcadb)

O ProblemaO Problema

1.1. Modelar (sub-conjunto das) expressões Modelar (sub-conjunto das) expressões da lógica proposicional (sintaxe e da lógica proposicional (sintaxe e propriedades)propriedades)

2.2. Avaliar cadeias de caracteres (String’s) Avaliar cadeias de caracteres (String’s) contra as regras de formação de contra as regras de formação de expressõesexpressões

3.3. A especificação do projeto está em:A especificação do projeto está em:http://www.cin.ufpe.br/~lcadb/logica/avaliador.http://www.cin.ufpe.br/~lcadb/logica/avaliador.htmlhtml

Definido uma expressãoDefinido uma expressão

Cadeia de caracteres formada Cadeia de caracteres formada com o alfabeto:com o alfabeto:

Ω* = 0,1,x,y,z, ),(,.,-,+Ω* = 0,1,x,y,z, ),(,.,-,+

E obedecendo as regras de E obedecendo as regras de construçãoconstrução

Regras para EBF - Regras para EBF - EExpressão xpressão BBem em FFormadaormada

1.1. Todas expressão atômica é EBFTodas expressão atômica é EBF

2.2. Se Se EE é uma EBF, então é uma EBF, então ((E) E) também é EBF;também é EBF;

3.3. Se Se E1E1 e e E2E2 são EBF´s então são EBF´s então (E1 (E1 E2)E2) é também EBF; é também EBF;

4.4. Nada mais é uma EBFNada mais é uma EBF

Obs1: Obs1: : .,+: .,+

Obs2: Esta é só uma pincelada na teoria, todos os Obs2: Esta é só uma pincelada na teoria, todos os detalhes estão nas notas de aula de Ruydetalhes estão nas notas de aula de Ruy

““Exemplinhos”Exemplinhos”

‘‘1’ é EBF1’ é EBF ‘‘x’ é EBFx’ é EBF ‘‘(1.x)’ é EBF(1.x)’ é EBF ‘‘1.x’ não é EBF1.x’ não é EBF ‘‘-(1.x)’ não é EBF-(1.x)’ não é EBF ‘‘(-(1.x))’ é EBF(-(1.x))’ é EBF ‘‘((x+1)+z)’ é EBF((x+1)+z)’ é EBF ‘‘(x+1+z)’ não é EBF(x+1+z)’ não é EBF

Bem vindo ao mundo VirtualBem vindo ao mundo Virtual

Desafios:Desafios: Adaptar o modelo matemático a Adaptar o modelo matemático a

uma realidade virtualuma realidade virtual Para isso usaremos algumas Para isso usaremos algumas

linguagens que não são linguagens que não são especializadas para isso:especializadas para isso:

Java, C ou C++Java, C ou C++

Modelo de NegóciosModelo de Negócios

Exemplo: (x + (-y))Exemplo: (x + (-y))Expressao x = new ExpressaoAtomica(‘x’);

Expressao y = new ExpressaoAtomica(‘y’);

Expressao negY = new Negacao(y);

Expressao ou = new ExpressaoOU(x, negY);

String e = ou.representacao();

System.out.println(“Altura de ” + e + “ : ” + ou.altura());

System.out.println (“Número de operadores de ” + e + “ : ” + ou.numeroOperadores());

Altura de (x+(-y)) : 2Número de operadores de (x+(-y)) : 2

Definição recursiva: Definição recursiva: representacao()representacao()//na classe ExpressaoAtomicaString representacao()

return this.simbolo + “”;

//na classe NegacaoString representacao()

return “(-” + this.getE().representacao() + “)”;

//na classe ExpressaoE, bem parecido na//ExpressaoOUString representacao()

return “(” + this.getE1().representacao() + “.” + this.getE2().representacao() + “)”;

Definição recursiva: altura ()Definição recursiva: altura ()

//na classe ExpressaoAtomicaint altura()

return 0;

//na classe Negacaoint altura()

return 1 + this.getE().altura();

//na classe ExpressaoBinariaint altura()

int a1 = this.getE1().altura(); int a2 = this.getE2().altura();

return 1 + Math.max(a1,a2);

Definição recursiva: Definição recursiva: numeroOperadores ()numeroOperadores ()//na classe ExpressaoAtomicaint numeroOperadores()

return 0;

//na classe Negacaoint numeroOperadores()

return 1 + this.getE().numeroOperadores();

//na classe ExpressaoBinariaint numeroOperadores()

int a1 = this.getE1().numeroOperadores(); int a2 = this.getE2().numeroOperadores();

return 1 + a1 + a2;

Definição recursiva: Definição recursiva: listaSubExpressoes()listaSubExpressoes()//na classe ExpressaoAtomicaList listaSubExpressoes ()

List retorno = new ArrayList();//o conjunto de subexpressões de uma expressão //atomica é ela mesmaString e = this.representacao();retorno.add(e);return retorno;

//na classe NegacaoList listaSubExpressoes ()

//pega lista de sua sub-expressãoList retorno = this.getE().listaSubExpressoes();//adiciona a si mesmaString e = this.representacao();retorno.add(e);return retorno;

Definição recursiva: Definição recursiva: listaSubExpressoes()listaSubExpressoes()//na classe ExpressaoBinariaList listaSubExpressoes ()

//pega lista de suas sub-expressõesList retorno = this.getE1().listaSubExpressoes();List temp = this.getE2().listaSubExpressoes();Object o = null;Iterator i = temp .iterator();while(i.hasNext())

o = i.next();//Só adiciona se não contiverif(!retorno.contains(o))

retorno.add(o);

//adiciona a sim mesmaString e = this.representacao();retorno.add(e);return retorno;

E agora?E agora?

Já sabemos modelar as Já sabemos modelar as estruturas EBF (a parte mais estruturas EBF (a parte mais fácil)fácil)

Só falta fazer o computador Só falta fazer o computador “ver” uma expressão e dizer se “ver” uma expressão e dizer se ela é válida ou não...ela é válida ou não...

SoluçãoSolução

As regras de validação EBF são As regras de validação EBF são tão poderosas que vamos usá-tão poderosas que vamos usá-las de fora para dentrolas de fora para dentro

Usaremos recursão para:Usaremos recursão para: Dada uma expressão Dada uma expressão φφ

qualquer, identificaremos suas qualquer, identificaremos suas sub-expressões (se existirem), sub-expressões (se existirem), validando recursivamentevalidando recursivamente

Validando expressõesValidando expressões

Dado Dado φφ φφ é construída com o alfabeto? é construída com o alfabeto? Se Se φφ é atômica, é válida é atômica, é válida Senão, Senão, Ela possui parênteses em número e ordem Ela possui parênteses em número e ordem

corretos?corretos? Se possuir, calcularemos o Se possuir, calcularemos o operador raiz*operador raiz* Com o operador raiz em mãos, Com o operador raiz em mãos,

identificamos a(s) sub-expressão (ões) e identificamos a(s) sub-expressão (ões) e repetimos o procedimento nela(s)repetimos o procedimento nela(s)

Exemplo: ((x+1).(-y))Exemplo: ((x+1).(-y))

Construída com o alfabeto Construída com o alfabeto ((x+1).(-y)) não é atômica((x+1).(-y)) não é atômica 3x‘(’ por 3x‘)’, começando com 3x‘(’ por 3x‘)’, começando com

‘(’ e terminando com ‘)’ ‘(’ e terminando com ‘)’ Procurando o op. Raiz > ‘.’ Procurando o op. Raiz > ‘.’ Agora repetimos os passos com Agora repetimos os passos com

(x+1) e depois com (-y)(x+1) e depois com (-y) ......

Encontrando o operador raizEncontrando o operador raiz

O operador raiz é o operador que O operador raiz é o operador que fica na raiz da árvore da fica na raiz da árvore da expressão:expressão:

Para encontrá-lo vamos contarPara encontrá-lo vamos contar

Encontrando o operador raizEncontrando o operador raiz

1.1. Desconsidere o primeiro ‘(’ e o Desconsidere o primeiro ‘(’ e o último ‘)’último ‘)’

2.2. Percorra a expressão e vá Percorra a expressão e vá contando sempre a diferença contando sempre a diferença ∆∆ entre o número de ‘(’ e o entre o número de ‘(’ e o número de ‘)’número de ‘)’

3.3. O primeiro operador (+,- ou .) O primeiro operador (+,- ou .) que você encontrar quando (que você encontrar quando (∆ ∆ == 0) é o operador raiz.== 0) é o operador raiz.

É isso aí.É isso aí.

O resto são detalhes de O resto são detalhes de implementação. Leiam atentamente a implementação. Leiam atentamente a especificação e testem várias vezes seus especificação e testem várias vezes seus programas. Mantenham uma lista de programas. Mantenham uma lista de expressões para testes.expressões para testes.

Boa SorteBoa Sorte