Representação do conhecimento híbrida com regras e objetos André Novaes, Bruno Jamir Jacques Robin CIn-UFPE

Roteiro  Motivação da integração regras + objetos  Variedades de integração  JEOPS: um sistema de produção embutido em Java  Flora: uma extensão orientada a objetos de Prolog  Comparação JEOPS X Flora

FRC híbridos regras+objetos: motivação fortes  Pontos fortes dos sistemas baseado em regras  fornece com built-in dedução lógica da 1 a ordem com negação por falha  um mecanismo de inferência poderoso e o mais versátil de todos  com semântica formal  que pode também servir de base para implementação de outros mecanismos como abdução, indução, planejamento, raciocínio não monótono  usam regras que:  são intuitivas e modulares  preservam a verdade (detachment)  pode ser adquiridas por aprendizagem de máquina fracos  Pontos fracos dos sistemas baseado em regras  codificação não intuitiva do conhecimento terminológico e procedimental  quase nenhuma facilidade para estruturação de entidades complexas  limitações das ferramentas e metodologias de desenvolvimento distribuído em larga escala  pouca padronização  poucos serviços computacionais não de IA implementados com regras  interoperabilidade limitada com outras linguagens

FRC híbridos regras+objetos: motivação fortes  Pontos fortes dos sistemas orientado a objetos como FRC  codificação intuitiva do conhecimento terminológico e procedimental  facilidade para estruturação de entidades complexas  ferramentas e metodologias de desenvolvimento distribuído em larga escala consolidadas e muito difundidas  API para os mais variados serviços computacionais e linguagens  ênfase na padronização, interoperabilidade e reuso fracos  Pontos fracos dos sistemas orientado a objetos como FRC  sem máquina de inferência built-in de propósito geral  qualquer mecanismo de inferência além da herança deve ser implementado de zero  parte comportamental codificada de maneira procedimental  ausência da técnicas de aprendizagem de máquina de classes e objetos  sem semântica formal

FRC híbridos regras+objetos: almejar “o melhor dos 2 mundos” Requisitos Raciocino: Linguagem declarativa Predicados com variáveis lógicas Dedução automática Semântica formal Completude computacional Requisitos OO: Identidade de objetos Objetos complexos Classes Encapsulamento Herança Sobrescrita e sobrecarga FRC Híbrido Regras + Objetos

Regras + Objetos Formalismos de Representação do Conhecimento Híbridos Regras + Objetos Inferência Baseada em Regras Inferência Baseada em Modelagem Orientada a Objetos Sistemas de Produção Programação em Lógica Sistemas de Produção Embutidos em Linguagem Orientada a Objetos EOOPS Programação em Lógica Orientada a Objetos OOLP Programação em Lógica Descritiva Sistemas de Produção com Frames Frames Lógicas Descritivas Linguagem de Programação Orientada a Objetos

Escaláveis e Persistentes Formalismos de Representação de Conhecimento Escaláveis e Persistentes Híbridos Regras + Objetos Inferência Baseada em Regras Sistemas de Produção Programação em Lógica BD Ativos OO BD Dedutivos OO DOOD Serviços de Banco de Dados BD Relacional BD Orientado a Objetos BD Ativos BD Dedutivos BD Objeto- Relacional

Regras e objetos: como integrar? Sistema Baseado em Regras Base de Regras f1(...,X,...) ...  fn(...,X,...)  f0(...,X,...) Base de Fatos f1(...,a,...) fn(...,a,...) f0(...,a,...) f1(...,b,...) fn(...,c,...) f0(...,d,...) Sistema Orientado a Objetos Hierarquia de Classes Cn Ani: Cnq Mnj: {while... do... if... then... else... } Cp Api: Cpk Mpj: {while... do... if... then... else... } Cm Ami: Cmr Mmj: {while... do... if... then... else... } Base de Objetos Opi Api: Opk Omj Ami: Omr Opmk Ami: Omr

Integrar regras com objetos: alternativas sintáticas  Sistema híbrido = sistema orientado a objetos no qual:  métodos procedimentais das classes foram substituídos por  bases de regras encapsuladas  Sistema híbrido = sistema baseado em regras no qual:  instâncias de termos lógicos na base de fatos  foram substituídos por objetos instâncias de uma hierarquia de classes  termos lógicos nas premissas e conclusões das regras  foram substituídos por padrões de objetos com variáveis lógicas no lugar de:  nome de objetos e valores de atributos  possivelmente também nome de classe e atributos

Substituir base de fatos por base de objetos Base de Regras f1(...,X,...) ...  fn(...,X,...)  f0(...,X,...) Hierarquia de Classes Cn Ani: Cnq Mnj: {while... do... if... then... else... } Cp Api: Cpk Mpj: {while... do... if... then... else... } Cm Ami: Cmr Mmj: {while... do... if... then... else... } Base de Objetos Opi Api: Opk Omj Ami: Omr Opmk Ami: Omr

Substituir métodos procedimentais por bases de regras Hierarquia de Classes Cn Ani: Cnq Mnj: Cp Api: Cpk Mpj: Cm Ami: Cmr Mmj: fpj1(...,X,...) ...  fpjn(...,X,...)  fpn0(...,X,...) fnj1(...,X,...) ...  fnjn(...,X,...)  fnn0(...,X,...) fmj1(...,X,...) ...  fmjn(...,X,...)  fmn0(...,X,...) Base de Objetos Opi Api: Opk Omj Ami: Omr Opmk Ami: Omr

Integrar regras com objetos: alternativas de implementação Camada de Regras Linguagem Hóspede Orientada a Objetos Camada Orientada a Objetos Linguagem Hóspede Lógica Linguagem de Regras Orientada a Objetos Linguagem de Implementação Orientada a Objetos Linguagem de Regras Orientada a Objetos Linguagem de Implementação Lógica LoPiX, SiLRI CLIPS, RAL/C++, NéOpus, JESS, JEOPS Flora, Logtalk

Sistemas de produção orientados a objetos EOOPS CLIPS RAL/C++ NéOpus JESS JEOPS Sistema Ling. Progr. C++ Smalltalk Java Unif. Integr. - +/ Serviços /- + Eficiência +/- + Encad. Resol. Conflitos /-

Regras JESS  Pode usar classes Java, com restrições  Regras com sintaxe própria (lisp-like) (defrule RegraAvo "O pai do pai de alguém é seu avô” ?a <- (Pessoa (nome ?nomeAvo)) ?p <- (Pessoa (nome ?nomePai) (pai ?a)) ?n <- (Pessoa (nome ?nomeNeto) (pai ?p)) => (printout t ?nomeAvo “ é avô de ” ?nomeNeto crlf)) class Pessoa { private String nome; private Pessoa pai;... } (defclass Pessoa Pessoa)

JEOPS: Java Embedded Object-Oriented Production System  Sistema desenvolvido no CIn-UFPE  Base de conhecimento JEOPS:  Parte intencional terminológica: definições de classes Java  Parte extensional: definições de objetos Java  Parte intencional dedutiva: regras de produção onde booleano  cada premissa invoca algum método Java booleano definido em uma classe da parte terminológica da base  cada ação invoca um método Java arbitrário definido em uma classe da parte terminológica da base  Base de fato substituída por base de objetos  Fases de casamento de padrão e de execução de ações incluem herança  Fase de resolução de conflito não modificada (mas poderia se aproveitar da herança)

Lembrete sobre sistemas de produção Base de FatosBase de Regras unificação Conjunto de Conflito resolução de conflitos Regra Novos Fatos execução Ciclo Obs: para não ter de re-testar a cada ciclo, só testa os fatos modificados (retirados, adicionados)

 Mudança de paradigma  Fatos: Termos Lógicos  Objetos  Predicados: Símbolos Lógicos  Métodos Booleanos Java  Casamento estrutural  Casamento comportamental (pertinência a classes + veracidade dos predicados) Casamento de padrão comportamental Nome: Marcos Nome: José Nome: João pai Pessoa Pai(João, José) Pai(José, Marcos)  p1, p2, p3: Pai(p1,p2)  Pai(p2,p3)  Avo(p1,p3) Regra Avo Para todo objeto p1, p2 e p3 da classe Pessoa, SE p1.ehPai(p2); p2.ehPai(p3); ENTÃO

Regras JEOPS n Rule ::= "rule" "{" "}" n Rule Body ::= ? n Declarations ::= "declarations" ( ("," )* )* n Local Declarations ::= "localdecl" ( "=" )* n Conditions ::= "conditions" ( )* n Actions ::= (Action)+ n Action ::= "assert" "(" ")" | "retract" "(" ")" | "modified" "(" ")" |

JEOPS - Arquitetura Gera entradas Agente Base de Conhecimentos Base de Objetos Rete Base Interna de Regras Conjunto de Conflito Consulta JEOPS flush assert runobjects Knowledge Base Assert = insere objetos na base de objetos Objects = recupera objetos da base de objetos Flush = limpa base de fatos

Esquema de Compilação JEOPS Compilation Environment JEOPS Compilation Environment JEOPS Engine JEOPS Rule Pre-Compiler Rule Base (.rules) Rule Base (.java) Application (.java) JAVA Compiler ByteCodes (.class) JEOPS Runtime Environment JEOPS Runtime Environment JEOPS Inference Engine JEOPS Compilation Environment JEOPS Compilation Environment JEOPS Engine JEOPS Rule Pre-Compiler Rule Base (.rules) Rule Base (.java) Application (.java) JAVA Compiler ByteCodes (.class) JEOPS Runtime Environment JAVA Runtime Environment JEOPS Inference Engine Mais simples de implementar Mais rápido de executar

Exemplo ilustrativo: base de conhecimento de planejamento de safári  Motivação:  Exemplos clássicos não ficam naturais se resolvidos utilizando Regras + OO  Problema das rainhas  Resolução do fibonacci  Exemplo do Wumpus não ilustra bem o problema  Objetos simples sem herança  Sem cálculos matemáticos  Sem casamento de padrões por classes  Solução  Modelagem de um novo problema com  Vários objetos  Regras com casamento de padrões por tipos  Herança  Problema: sem profundidade de associação de objetos

Exemplo ilustrativo: base de conhecimento de planejamento de safári  Organizando uma expedição de safári  Objetivos:  Qual animal será a caça?  Em que ambiente será realizado o safári?  Veículo:  Aquático?  Terrestre?  Tripulação:  Quantos guias serão necessários?  Quantos caçadores?  Quantos motoristas?  Armas:  Armas de fogo?  Armas brancas?

Base de conhecimento de planejamento de safári: Ontologia UML

Como implementar o safári em JEOPS?  Diagrama de Classes  Classes UML  Classes Java  Restrições OCL  regras de produção OO  Encadeamento de regras  Detalhamento dos Casos de Uso + Diagrama de seqüências  Comportamento do fluxo e chamadas à base de conhecimento  Métodos numéricos  Métodos nas classes Java

Passos de desenvolvimento de uma base de conhecimento JEOPS 1. Definir as classes  Atributos e métodos 2. Definir as regras  Interação entre os objetos da base 3. Voltar ao passo 1 4. Deixar a base de conhecimentos trabalhar Escolher estratégia de resolução de conflito

Exemplo de uso: Safári  Definição das classes  Arma, ArmaFogo, GrupoSafari,... Abstract class Arma { private int preco; private String nome;... } class ArmaFogo extends Arma { private int calibre; private int qtdMunicao; private int precoMunicao;... } class GrupoSafari{ public Vector tripulantes; public Vector pertences; public Vector veiculos; public int financiamento; public int numeroMaximoTripulantes;... }

Exemplo de uso: Safári  Criação das regras rule ContrataGuia{ declarations GrupoSafari g; Guia guia; localdecl conditions g.getTripulantes().size() < g.getNumeroMaximoTripulantes(); g.getLocal().instanceOf(LocalTerrestre); ((LocalTerrestre) g.getLocal).getAberto() == false; g.getNumeroGuias == 0; actions g.putTripulante(guia); modified(g); }

Exemplo de uso: Safári  Criação dos objetos RegrasSafari base = new RegrasSafari(); base.assert(new AnimalAquatico(“baleia”, "grande", false)); base.assert(new LocalAquaticoTerrestre("Pântano", "raso", false)); base.assert(new VeiculoAquatico("Lancha", 8, new Vector("baixa", "media"));...  Execução do motor de inferência base.run();

JEOPS: características interessantes  Pré-compilação de regras  Regras convertidas em classes Java  Extensão de Rete para objetos complexos com herança  Algoritmo eficiente de casamento de padrão entre fatos e premissa de regra  Estratégias built-in de resolução de conflitos  LRUConflictSet  MRUConflictSet  NaturalConflictSet  OneShotConflictSet  PriorityConflictSet  KEOPS:  Versão J2ME para rodar em dispositivos móveis  Usado para implementar inteligência embutidos em jogos para celulares

JEOPS: aplicações práticas  Agentes de administração de rede  Jogos interativos  Recuperação de informação na web  Música computacional

Flora = Frame Logic + HiLog + Transaction Logic + XSB Prolog tabelado XSB Flora HiLogTransaction LogicFrame Logic Organização do conhecimento em hierarquia de classes Representação de conhecimento taxonômico Herança múltipla e dinâmica Uso de processos de desenvolvimento OO Terminação garantida em muito mais casos Cache se sub-provas Negação por falha com semântica declarativa bem fundamentada Compilador Flora Atualizações na base de fatos Integrado ao backtrack Representação de conhecimento procedimental Sintaxe de ordem superior Semântica da 1 a ordem Meta-programação Meta-consultas ao esquema

Exemplo de programa Flora Classes: veiculo[capacidade=>integer]. veiculoAquatico::veiculo[profundidade=>>string]. armaFogo::arma[ calibre *=> integer, qtdMunicao *=> integer, precoTotal(integer)*=>integer ]. arma[preco*=>integer, precoMunicao(10)->8, precoMunicao(12)->9]. rifle::armaFogo[calibre*->12,preco*->500]. Instâncias: baleia:animalAquatico[porte->grande,perigoso->nao]. bote:veiculoAquatico[profundidade->>baixa]. lancha:veiculoAquatico[profundidade->>{baixa,media}].

Exemplo de programa Flora Regras A[precoTotal*->P] :- A::armaBranca[preco*->P]. X:grupo[armas->>{arpao}] :- X:grupo[animal->baleia]. X[veiculos->>{V}] :- comprouVeiculo, X:grupo.local:localAquatico[profundidade->P], V:veiculoAquatico[profundidade->>P], btinsert{comprouVeiculo}. A[precoTotal(Q)*->T] :- A::armaFogo[preco*->P,calibre*->C], arma[precoMunicao(C)->PC], T is PC*Q+P. X[armas->>{rifle_ld1:rifle_longa_dist[qtdMunicao->10],rifle1:rifle[qtdMunicao->20]}] :- X:grupo[animal->_A:animalTerrestre[porte->T]], T \= pequeno, Soma is rifle_longa_dist!precoTotal(10) + rifle!precoTotal(20), precoArmasMaximo(PM), Soma < PM.

Exemplo de programa Flora Consultas g1:grupo[animal->leao]. g2:grupo[animal->baleia]. ?- G:grupo[armas->>R[qtdMunicao->Y]]. G = g1 R = rifle1 Y = 20 G = g1 R = rifle_ld1 Y = 10 ?- G:grupo[armas->>R:armaBranca]. G = g2R = arpao ?- G :grupo[animal->A], tnot A[porte->medio]. G = g2A = baleia

Sintaxe c1::c2Herança de classesanimalTerrestre::animal o1:c1Instanciação de Objetoleao:animalTerrestre c[m=>t]Assinatura de Métodos Univalorados grupo[animal=>animal]. c[m=>>t]Assinatura de Métodos Multivalorados grupo[armas=>>arma]. c[m->v]Métodos Univaloradosgrupo[animal->leao]. c[m->>{v 1,...,v n }]Métodos Multivaloradosgrupo[armas->>{rifle1,rifle2}]. *-> *->> *=> *=>> Métodos que são herdados pelas subclasses/instancias rifle::armaFogo[calibre*->12]. armaFogo::arma[calibre *=> integer]. Agrupando:veiculoAquatico::veiculo[profundidade=>integer,profundidade*->media]. rifle:armaFogo[calibre->12,preco->500]. g1:grupo[animal->X[porte->medio]]. Legenda: c: classe, o: objeto, m: método, v: valor, p: parâmetro

Sintaxe head :-p 1,...p n Regra X:grupo[armas->>{arpao}] :- X:grupo[animal->baleia]. ?- p 1,...p n Conculta tnot Negação tabelada X[voa->sim] :- X:ave, tnot X:pinguim. \+ Negação não tabeladap(X) :- \+ q(X). X \= Z Diferença X[irmao->Y] :- X[pai->Z], Y[pai->Z], X \= Z. c1.m1, c1!m1 (m. Herdado) Expressão de caminho –método univalorado ?- g1.animal[porte->X] ?- g1[animal->A], A[porte->X] o1..m2, o1!!m2 (m.herdado) Expressão de caminho -método multivalorado ?- g1..arma[preco->X] ?- g1[arma->>A], A[preco->X] ;ou?- a:[porte->medio] ; a:[porte->grande]

Sintaxe  Predicados como em Prolog: g1:grupo[armas->>{a1,a2}]. arma_grupo(g1,a1). arma_grupo(g1,a2).  Permite aninhar objetos em predicados arma_grupo(a1:arma[preco->100]).  Não permite aninhar predicados dentro de objetos

Consultas Flora X SQL SQL - Classes create table animal ( id_animal varchar(...), porte varchar(...) ); create table grupo ( id_grupo varchar(...), id_animal varchar(...), ); SQL - Instancias insert into grupo values(...) insert into animal values(...) SQL - Consultas select animal.porte as X from grupo, animal where grupo.id_grupo = g1 and grupo.id_animal = animal.id _ animal Flora ?- g1:grupo.animal[porte->X]

Herança elefante[cor*->cinza]. clyde:elefante[cor->branca]. ?- clyde[cor->X]. X = branca d[m*->e]. d::b. b[m*->c]. a:b. a:d :- a[m->c]. ?- X[m*->Y]. X = b Y = c X = d Y = e ?- X[m->Y]. X = a Y = c X = a Y = e

HiLog  Sintaxe de alto nivel  Semântica de primeira ordem  Podem aparecer em qualquer lugar onde um simbolo de função apareça  Ex: p(f(x))(a,b,c), g(f)(g)[m(h(x))->b]  Variaveis podem aparecer em qualquer parte  Permite meta-programação  Todos os metodos univalorados da classe c1:  ? - c1[M=>T]  Todas as subclasses de classes com o metodo m:  ? - X::c1[m=>_]  Traduzido por predicados apply/N  closure(R) (X,Y)  apply(apply(closure,R),X,Y)

Transaction Logic  Permite atualização da base de fatos  Representação de conchecimento procedimental  Sintaxe: operacao{literais[|query]}  Non-Backtrackable update  Operações desfeitas quando há backtrack  insert,insertall,delete,deleteall,erase,eraseall  Backtrackable update  Operações persistem após backtrack  btinsert,btinsertall,btdelete,btdeleteall,bterase,bteraseall  Problemas com tabelamento

Transaction Logic transfer(Amt,Acct1,Acct2) :- withdrawn(Amt,Acct1), deposit(Amt,Acct2). withdrawn(Amt,Acct) :- balance(Acct,Bal), Bal >= Amt, Bal2 is Bal - Amt,change_balance(Acct,Bal,Bal2). deposit(Amt,Acct) :- balance(Acct,Bal), Bal2 is Bal + Amt,change_balance(Acct,Bal,Bal2). change_balance(Acct,Bal1,Bal2) :-... ?- insert{balance(c1,100)}, insert{balance(c2,0)}, insert{balance(c3,0)}. ?- transfer(100,c1,c2),transfer(100,c1,c3). ?- balance(c1,X). Com backtrack change_balance(Acct,Bal1,Bal2) :- btdelete{balance(Acct,Bal1)}, btinsert{balance(Acct,Bal2)}. X = 100. Sem backtrack(como em prolog) change_balance(Acct,Bal1,Bal2) :- delete{balance(Acct,Bal1)}, insert{balance(Acct,Bal2)}. X = 0.

F-Logic: aplicações práticas  Engenharia de software:  especificação formal executável orientada a objetos  Inteligência artificial:  representação do conhecimento por meio de regras e hierarquias conceituais  Banco de dados:  BD dedutivas orientada a objetos  integração de dados  integração de codificações  integração de esquemas  integração de BD com modelos de dados diferentes  Web semântica:  Agentes inteligentes de processamento de informação na web  Dedução automática sobre documentos, objetos e dados na web

Implementações de F-Logic  Flora:  F-Logic + HiLog + Transaction Logic  Compilador F-Logic para XSB Prolog implementado em Prolog  Domínio público, open source  Stony Brook University, New York  LoPiX:  F-Logic + XPath + XML  Implementado em C++, no entanto sem API C++  Domínio público, executável  University of Freiburg, Alemanha  SiRLI:  F-Logic com extensões lógicas (quantificadores existenciais, conectivas)  Implementado em Java  Comercial, ontoprise.com  TRIPLE  F-Logic + RDF  Compilador para Flora  Domínio público  Stanford/DFKI  Floracle  F-Logic + HiLog + Transaction Logic  Compilador para Oracle9i  Em desenvolvimento no CIn por mim! 

Substituir métodos procedimentais por bases de regras: exemplo (Linguagem Pluto) class person [ address => string; spouse => person; public mary(person); public divorce(); X[mary(Y)] :- X[not spouse -> Z, gender -> G], Y[not spouse -> Z1], not gender -> G], ins X[spouse -> Y], ins Y[spouse -> X]; X[divorce] :- del X[spouse -> Y], del Y[spouse -> X]] class employee isa person[ worksIn => dept; salary => integer; public raise(integer); X[raise(Y)] :- S2 is S1 + S2 * Y, del X[sakary ->S1], ins X[salary -> S2]] class dept. tom:employee[worksIn -> cpsc, spouse -> pat, salary -> 20000]. cpsc:dept. pat:person[spouse -> tom]. Substituir fatos por objetos: exemplo (Linguagem Flora) person[address => string, spouse => person, mary(person) => void, divorce => void]. employee::person[worksIn => dept, salary => integer, raise(integer) => void]. X:person[mary(Y:person[gender -> Gy]), gender -> Gx] :- not X.spouse, not Y.spouse, Gx =/ Gy, ins(X[spouse -> Y]), ins(Y[spouse -> X]). X:person[divorce,spouse -> Y[spouse -> X]] :- del(X[spouse -> Y]), del(Y[spouse -> X]). X:employee[raise(R:integer), salary -> S] :- S1 is S + R, del(X[salary -> S]), ins(X[salary -> S1]). tom:employee[worksIn -> cpsc, spouse -> pat, salary -> 20000]. cpsc:dept. pat:person[spouse -> tom].

Qual conhecimento codificar nas regras e qual conhecimento codificar nos objetos?  Não existe metodologia estabelecida para fazer tal escolha  Com a experiência da codificação de bases de conhecimento em domínio diversos, o engenheiro do conhecimento desenvolve intuição para distinguir entre:  conhecimento dedutivo x conhecimento terminológico  conhecimento declarativo x conhecimento procedimental  Identificar critérios gerais e rigorosos para fazer essas distinções permanece um problema aberto de pesquisa  Conhecimento dedutivo melhor codificado com regras  Conhecimento terminológico melhor codificado com hierarquia de classes  Conhecimento procedimental melhor codificado com métodos

Flora  Programação em lógica OO Prolog  Hospedado em Prolog tabelado  Sem procedimentos  Sem procedimentos imperativos  Sem encapsulamento estrutural  Unificação estrutural incorporando herança  Com semântica  Com semântica formal regressivo  Encadeamento regressivo  Variáveis lógicas em qualquer posição de estruturas de objetos ou classes  Fracamente  Fracamente tipada  Generaliza modelos de dados relacional, orientado a objetos e objeto-relacional JEOPS  Sistema de produção OO Java  Hospedado em Java  Com procedimentos  Com procedimentos imperativos  Com encapsulamento comportamental  Casamento de padrões comportamental incorporando herança  Sem semântica  Sem semântica formal progressivo  Encadeamento progressivo  Variáveis apenas em posição de nome de objeto e valor de atributo  Fortemente  Fortemente tipada Flora x JEOPS

Vantagens de Flora  Linguagem multiuso:  especificação formal executável  programação  banco de dados  representação do conhecimento  Semântica formal bem definida  Concisão do código  Expressões de ordem superior para meta-programação e consultas a esquema de BD  Prototipagem rápida de meta- interpretadores para:  abdução, indução, resolução de restrições, planejamento e raciocínio bayesiano  Encadeamento regressivo natural para agentes deliberativos  Eficiência Vantagens de JEOPS  Incorporação imediata dos milhares de serviços disponíveis via API Java  Fácil de aprendizagem para larga base de desenvolvedores Java  Encadeamento progressivo natural para agentes reativos Flora x JEOPS

Flora x JEOPS: comparação para safári armaFogo::arma[calibre *=> integer,qtdMunicao *=> integer, precoTotal(integer)*=>integer ]. public class ArmaFogo extends Arma{ private int calibre; private int quantidadeMunicao; private int precoMunicao; public ArmaFogo(String nome, int preco, int calibre, int quantidadeMunicao, int precoMunicao){ super(nome, preco);... } public void setCalibre(int calibre){...} public int getCalibre(){...}... public int getPrecoTotal(){...}... } rifle::armaFogo[calibre*->12,preco*->500]. public class Rifle extends ArmaFogo{ public Rifle( String nome, int quantidadeMunicao, int precoMunicao){ super(nome, 500, 12, quantidadeMunicao, precoMunicao); }

Flora x JEOPS: comparação para safári baleia:animalAquatico[ porte->grande, perigoso->nao ]. lancha:veiculoAquatico[ profundidade->>{baixa,media} ]. pantano:localAquatico, localTerrestre[ profundidade->baixa, aberto->nao ]. AnimalAquatico baleia = new AnimalAquatico("grande", false); VeiculoAquatico lancha = new VeiculoAquatico("Lancha", 8, new Vector("baixa", "media") ); LocalAquaticoTerrestre pantano = new LocalAquaticoTerrestre( "Pântano", "raso", false);

Flora x JEOPS: comparação para safári X[veiculos->>{V}] :- comprouVeiculo, X:grupo.local:localAquatico[profundidade->P], V:veiculoAquatico[profundidade->>P], btinsert{comprouVeiculo}. rule CompraVeiculoAquatico{ declarations GrupoSafari g; VeiculoAquatico embarcacao; conditions g.getVeiculos().size()==0; g.getLocal().instanceOf(LocalAquatico); embarcacao.getProfundidades().contains( ((LocalAquatico)g.getLocal()).getProfundidade()); actions g.putVeiculo(embarcacao); modified(g); }

Flora x JEOPS: comparação para safári A[precoTotal(Q)*->T] :- A::armaFogo[ preco*->P, calibre*->C ], arma[precoMunicao(C)->PC], T is PC*Q+P. public int getPrecoTotal(){ int preco = 0; preco = this.getPreco() + (this.getPrecoMunicao() * this.getQuantidadeMunicao()); return preco; }

Flora x JEOPS: comparação para safári grupo1[armas->>R[qtdMunicao->Y]] GrupoSafari grupo = New GrupoSafari(...);... Vector armas = grupo.getArmas(); Arma arma = null; for(int i; i< armas.size(); i++) { arma = (Arma) armas.get(i); System.out.println(arma.toString()); }