Defina un tipo de dato nuevo para modelar las 7 tiendas de "Meridian" de La Piedad.
1.- Se debe modelar de cada tienda:
- nombre del administrador
- ubicación
- las ventas de la semana 1, 2, 3 y 4
2.- Declarar una lista con al menos 5 tiendas
Empleando orden superior y lazyness, crear una función para cada caso:
3.- Indicar la ubicación de las tiendas que vendieron más de 100 mil al mes
4.- Indicar la ubicación de las tiendas que vendieron menos de 10 mil al mes
5.- Indicar el administrador de las tiendas que vendieron más de 100 mil al mes
6.- Indicar el administrador de las tiendas que vendieron menos de 10 mil al mes
7.- Genere una lista con los promedios de venta por tienda
8.- Genere una lista formada por las ventas más pequeñas de cada tienda
9.- Genere una lista formada por las ventas más grandes de cada tienda
10.-Indicar la ubicación de la tienda que tuvo la semana con menor venta
11.-Indicar el administrador de la tienda que tuvo la semana con menor venta
Ejercicios Programación Lógica, Unidad IV
Escriba un programa en Prolog para encontrar parejas.
Escriba REST Web Services en java (Back-end), que invoque el programa en prolog y devuelva los "matches" de una persona
Construya un cliente (Front-end) para invocar los Web Services:
- App móvil
- Web client
- Desktop client
//////////**************** Ejemplo consulta a un RDF empleando Jena
import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.util.FileManager;
public class SWcurso_consultaRDFS {
private static final String MY_RDF_FILE = "http://localhost:8080/vinos.rdf";
public static void main(String[] args) {
Model grafo = ModelFactory.createDefaultModel();
FileManager.get().readModel(grafo,MY_RDF_FILE);
String queryString =
"base <http://www.itmorelia.edu.mx/taller#>" +
"PREFIX tecmor: <http://www.itmorelia.edu.mx/taller#> " +
"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> " +
"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> " +
"SELECT * " +
"WHERE { " +
" ?sujeto tecmor:marca ?valor. " +
" ?sujeto tecmor:nombre ?valor2. " +
" } " ;
Query consulta = QueryFactory.create(queryString);
QueryExecution consulta_ej = QueryExecutionFactory.create(consulta,grafo);
ResultSet resultados = consulta_ej.execSelect();
ResultSetFormatter.out(System.out, resultados);
// ResultSetFormatter.asText(resultados);
consulta_ej.close();
}
}
Unidad de sistemas de producción, ejemplo de sintaxis CLIPS (Mayo 2018)
Crear programa con interfaz (Swing o Front invocando a un Web Service) que enlace a programa CLIPS
(deffacts sintomas
(sintoma pedro dolorCabeza)
(sintoma pedro dolorEstomago)
(sintoma pedro diarrea)
(sintoma pedro vomito)
(sintoma luis dolorCabeza)
(sintoma luis dolorEstomago)
(sintoma luis diarrea)
(sintoma luis vomito)
(sintoma juan cuerpoCortado)
(sintoma juan constipado)
(sintoma juan dolorCabeza)
(sintoma lucy dolorCabeza)
(sintoma lucy dolorEstomago)
(sintoma lucy mareo)
(sintoma lucy vomito)
)
(defrule diagnosticoDefinido
(sintoma ?n dolorCabeza)
(sintoma ?n dolorEstomago)
(sintoma ?n mareo)
(sintoma ?n vomito)
=>
(printout t ?n " padece infeccion estomacal" crlf)
(assert (diagnostico ?n infeccionEstomacal) )
)
(deffacts alergias
(alergia pedro penicilina)
(alergia luis aspirina)
(alergia juan naproxeno)
(alergia lucy penicilina)
)
(defrule diagnosticoEstimado
(sintoma ?n dolorCabeza)
(not (sintoma ?n dolorEstomago))
(sintoma ?n mareo)
(sintoma ?n vomito)
=>
(printout t ?n " diagnostico incierto, hacer estudios" crlf)
(assert (estudioRadio ?n cerebro) )
)
(defrule prescripMedica
(diagnostico ?n infeccionEstomacal)
(not (alergia ?n penicilina ))
=>
(printout t ?n " debe tomar penicilina" crlf)
(assert (presc ?n infeccionEstomacal penicilina) )
)
(defrule prescripMedica2
(diagnostico ?n infeccionEstomacal)
(not (alergia ?n esteroide) )
(not (presc ?n infeccionEstomacal ?x) )
=>
(printout t ?n " debe tomar esteroide" crlf)
(assert (presc ?n infeccionEstomacal esteroide) )
)
(deffacts promosFarmacia
(promo guadalajara penicilina)
(promo guadalajara ambroxol)
(promo guadalajara cefuracet)
(promo issseg esteroide)
(promo issseg ambroxol)
(promo issseg cefuracet)
)
(defrule promoMedic
(promo ?f ?medicamento)
(presc ?n ?mal ?medicamento)
=>
(printout t ?n " promo de " ?medicamento " en " ?f crlf)
(assert (recomendacion ?n ?mal ?f ?medicamento) )
)
/////////////////////********************************************Lenguajes y autómatas Ago-Dic 2016
Hacer un generador de sistemas que a partir de un lenguaje de alto nivel que describa una base de datos, genere la aplicación para altas, consultas y cambios de cada tabla.
A continuación se ilustra una gramática ilustrativa que imprime parcialmente el SQL a partir del lenguaje de alto nivel y genera una estructura de datos mínima para guardar la información de las tablas y campos indicados por un usuario.
grammar T;
@header {
import java.util.ArrayList;
import java.util.List;
}
@members{ //Estructura de datos para guardar información de las tablas introducidas por el
//Usuario de alto nivel
List <Tabla> tablas = new ArrayList<Tabla>();
Tabla tablaActual = null;
}
inicio : creacion usar tabla+ cerrar;
creacion : CREAR ID {System.out.println("CREATE DATABASE "+$ID.text);
};
usar : USAR ID {System.out.println("USE DATABASE "+$ID.text); };
tabla : TABLA ID INICIO
{
//código para generar SQL
System.out.println("CREATE TABLE "+$ID.text );
System.out.println(" ("+$ID.text+"_key AUTOINCREMENT NOT NULL");
//código para crear estructura de datos
Tabla t = new Tabla();
t.nombre =$ID.text;
tablas.add(t);
tablaActual = t;
//
}
campo+
FIN {
System.out.println(" ); ");
};
campo : ID (t=NUMERICO | t=ALFABETICO | t=FECHA)
{ //aquí hay que agregar código para generar SQL
//el que sigue es código para crear estructura de datos
Atributo a = new Atributo();
a.nombreAtributo = $ID.text;
a.tipoAtributo = $t.text;
tablaActual.atributos.add(a);
};
cerrar : CERRAR {
for (int i=0; i<tablas.size(); i++)
{
System.out.println("Tabla: "+tablas.get(i).nombre);
List <Atributo> atribs= tablas.get(i).atributos;
for (int j=0; j<atribs.size(); j++)
{
System.out.println("**Atributo: "+atribs.get(j).nombreAtributo);
System.out.println("**TipoAtrib: "+atribs.get(j).tipoAtributo);
}
}
};
CERRAR : 'cerrar';
NUMERICO : 'numeros';
ALFABETICO: 'letras';
FECHA : 'fecha' ;
TABLA : 'tabla' ;
INICIO: 'inicio' ;
FIN : 'fin' ;
USAR : 'usar' ;
CREAR : 'crear' ;
ID : ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|'0'..'9')* ;
WS :(' ' | '\n' | '\t' | '\r')+ {$channel=HIDDEN; } ;
Se debe generar el Lexer y Parser mediante ANTLR y después compilar junto con el archivo Test.java, Tabla.java y Atributo.java. Las clase Tabla.java es:
import java.util.ArrayList;
import java.util.List;
/**
*
* @author Gualo
*/
public class Tabla {
String nombre;
List <Atributo> atributos;
public Tabla() {
atributos = new ArrayList<Atributo>();
}
}
Y la clase Atributo.java es:
public class Atributo {
String nombreAtributo;
String tipoAtributo;
}
Un programa de prueba para la gramática sería
>java Test
crear DATOS
usar DATOS
tabla MASCOTAS
inicio
nombre letras
cantidad numeros
fin
tabla JUGUETES
inicio
nombre letras
compra fecha
color letras
precio numeros
fin
cerrar
^Z
Y la salida que muestra el ejercicio es
CREATE DATABASE DATOS
USE DATABASE DATOS
CREATE TABLE MASCOTAS
(MASCOTAS_key AUTOINCREMENT NOT NULL
);
CREATE TABLE JUGUETES
(JUGUETES_key AUTOINCREMENT NOT NULL
);
Tabla: MASCOTAS
**Atributo: nombre
**TipoAtrib: letras
**Atributo: cantidad
**TipoAtrib: numeros
Tabla: JUGUETES
**Atributo: nombre
**TipoAtrib: letras
**Atributo: compra
**TipoAtrib: fecha
**Atributo: color
**TipoAtrib: letras
**Atributo: precio
**TipoAtrib: numeros
Algunos aspectos de las materias
Ejemplo tomado del libro de ANTLR de Terence Parr, para paso de valores en reglas sintácticas
grammar T;
@header {
import java.util.HashMap;
}
@members {
HashMap memory = new HashMap();
}
prog: stat+ ;
// stat : expr NEWLINE | ID '=' expr NEWLINE | NEWLINE ;
stat: expr NEWLINE { System.out.println($expr.value); }
| ID '=' expr NEWLINE
{
memory.put($ID.text, new Integer($expr.value));
System.out.println("Asignando "+$expr.value+" a la variable "+$ID.text);
}
| NEWLINE
;
// expr: multExpr ( ('+'|'-') multExpr )*
expr returns [int value]
: temp1=multExpr {$value = $temp1.value;}
( '+' temp2=multExpr {$value = $value + $temp2.value;}
| '-' temp2=multExpr {$value = $value - $temp2.value;}
)*
;
// multExpr : atom ('*' atom)* ;
multExpr returns [int value]
: temp1=atom {$value = $temp1.value;}
('*' temp2=atom {$value *= $temp2.value;})*
;
atom returns [int value]
: INT { $value = Integer.parseInt($INT.text); }
| ID {
Integer v = (Integer)memory.get($ID.text);
if ( v!=null )
$value = v.intValue();
else
System.err.println("undefined variable "+$ID.text);
}
| '(' expr ')' {$value = $expr.value;}
;
ID : ('a'..'z'|'A'..'Z')+ ;
INT : '0'..'9'+ ;
NEWLINE : '\r'? '\n' ;
WS : (' '|'\t'|'\n'|'\r')+ {skip();} ;
//**************************************************
Uso de paso de valores entre reglas gramaticales para detectar errores semánticos simples
grammar T2;
@header {
// manda el import hasta la sección de imports del codigo generado
import java.util.HashMap;
}
@members {
// se crea la tabla de simbolos
HashMap memory = new HashMap();
}
prog: sentencia+ ;
sentencia: declaracion | asignacion;
declaracion: declInt | declFloat ;
//
// declInt : 'entero' ID (',' ID )* ';' ;
// declInt : 'entero' t1=ID {xxxxx} (',' t2=ID {xxxxx} )* ';' ;
declInt : TIPOINT t1=ID
{System.out.println("Decl.Var.Ent: "+$t1.text);
memory.put($t1.text,new Integer(1));
}
(',' t2=ID
{ System.out.println("Decl.Var.Ent: "+$t2.text);
memory.put($t2.text,new Integer(1));
}
)* SEMIC ;
// declFloat: 'float' t1=ID {xxx} (',' t2=ID {xxx} )* ';' ;
declFloat: TIPOFLOAT t1=ID {
System.out.println("Decl.Var.Flo: "+$t1.text);
memory.put($t1.text,new Integer(2));
}
(',' t2=ID { System.out.println("Decl.Var.Flo: "+$t2.text);
memory.put($t2.text,new Integer(2));
}
)* SEMIC ;
//////////////
// x= (sdf*6*6);
//
// asignacion : ID '=' expr ';' {***ver tipos*** } ;
//
asignacion: ID IGU expr SEMIC
{
Integer t = (Integer) memory.get($ID.text);
if (t==null)
System.out.println("Variable no declarada:"+$ID.text);
else { int tipoExpr = $expr.valor;
if( t.intValue() != tipoExpr )
System.out.println("Error tipo"+$ID.text+"="+$expr.text);
}
}
;
////////////////////////////////////
expr returns [int valor]
: t1=multExpr {$valor=$t1.valor;}
(('+' |'-' )
t2=multExpr
{ if($t1.valor!=$t2.valor)
{
System.out.println("Error de tipos:"+$t1.text+","+$t2.text);
$valor=3;
}
else $valor=$t2.valor;
} )* ;
multExpr returns [int valor]
: t1=atomo {$valor=$t1.valor;}
('*' t2=atomo
{
if($t1.valor!=$t2.valor)
{
System.out.println("Error de tipos:"+$t1.text+","+$t2.text);
$valor=3;
}
else $valor=$t2.valor;
} )* ;
// expr: multExpr (('+' |'-' ) multExpr)* ;
// multExpr : atom ('*' atom)*;
// atom: INT
// | ID
// | '(' expr ')' ;
atomo returns [int valor]
: ENTERO { $valor = 1; }
| FLOTANTE { $valor = 2; }
| ID
{
Integer t = (Integer) memory.get($ID.text);
if (t==null)
System.out.println("Variable no declarada:"+$ID.text);
else
$valor = t.intValue();
}
| PA expr PC {$valor = $expr.valor;} ;
PA : '(' ;
PC : ')' ;
IGU : '=' ;
TIPOFLOAT: 'float' ;
TIPOINT : 'int' ;
SEMIC : ';' ;
ID : 'a'..'z'+ ;
FLOTANTE : '0'..'9'+ '.' '0'..'9'+ ;
ENTERO : '0'..'9'+ ;
WS :(' '|'\t'|'\r'|'\n')+
{skip();} ;
//***********************
Expresiones lógicas
cond : '(' e ')' | eR;
e : cond (('and'|'or' ) cond )* ;
eR : '(' atomo OPREL atomo ')';
//*************************************************
El la materia de Lenguajes y Autómatas II se emplearán las herramientas ANTLR y DSL Tools
Integración de código de Parser y Lexer para generar una aplicación de ventanas en Netbeans.
Crear un proyecto nuevo que
incluya la clase Main.
Agregar una ventana y desde
la clase Main invocar a dicha ventana.
SELECCIONAR su proyecto: Menu
FILE -> Project Properties -> Libraries -> Compile -> Add Jar
Folder -> Agregar Antlr 3.1.3.jar (debe estar en la carpeta LIB de su
instalacioin de ANTLR)
//////////////////////////////////////////////////////////////////
En la ventana agregar dos
textArea, cambie el nombre para que se llamen: entrada
y
salida
Agregue un botón cuya acción
será tomar el texto de entrada y pasárselo al parser. Abajo se muestra el
código asociado al click de tal botón.
En la mayoría del código las
excepciones son introducidas por Netbeans
El código que nos toca
introducir a mano aparece en negritas. En este caso la gramática se llemó T.g,
de ahí el nombre de las Clases TLexer
y TParser
/////////////////////////////////////////////////////////////////////////////////////////////////
ANTLRInputStream input=null;
String s= ""; s= entrada.getText();
StringBufferInputStream str = new
StringBufferInputStream(s);
try {
input = new
ANTLRInputStream(str);
} catch (IOException ex) {
Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
}
TLexer lexer = new TLexer(input);
CommonTokenStream tokens =
new CommonTokenStream(lexer);
TParser parser = new TParser(tokens);
parser.setSalida(salida);
try {
parser.prog();
} catch (RecognitionException
ex) {
Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
En la clase TParser, declarar
un atributo que recibirá una referencia al textArea y que se empleará para escribir la salida del
compilador. La declaración será:
private javax.swing.JTextArea
salida;
y un método para recibir la
referencia
public void setSalida(javax.swing.JTextArea _salida)
{ salida=_salida; }
Buscar todos los
System.out.println(cadena de texto) y
cambiarlos por un
salida.append( cadena de texto); que escribirá una línea en el textArea de salida.
///////////////////////
Para eso el archivo de la
gramática debió generarse con el siguiente código para manejo de errores:
El código va después de
grammar T;
@members {
public void
displayRecognitionError(String[] tokenNames,
RecognitionException e) {
String hdr = getErrorHeader(e);
String msg =
getErrorMessage(e, tokenNames);
System.out.println("Que te fijes!!!: " + hdr
+ " " + msg);
}
}
El código aparecerá en el
Parser y será necesario cambiarlo para mandar los errores al TextArea
denominado salida
- Del app_bar_actividad_principal quitar el include y poner un
FrameLayout con nombre: fragment_container
Configuración del Navigation
Drawer (Nov 2017)
Se crea aplicación con actividad Navigation Drawer.
Si abrimos layout_actividad_principal.xml,
tenemos que su contenido es:
<include
layout="@layout/app_bar_actividad_principal"
… />
<android.support.design.widget.NavigationView
….
layout="@layout/app_bar_actividad_principal"
… />
<android.support.design.widget.NavigationView
….
app:headerLayout="@layout/nav_header_actividad_principal"
app:menu="@menu/layout_actividad_principal_drawer" />
app:menu="@menu/layout_actividad_principal_drawer" />
Esto es, la vista completa se compone de:
·
Actividad
principal : app_bar_actividad_principal.xml, quien
contiene:
o content_actividad_principal.xml
·
Vista
de navegación: NavigationView, la
cual se compone de:
o Cabecera: nav_header_actividad_principal.xml
o y opciones de menu: layout_actividad_principal_drawer.xml
El archivo actividad_principal.xml sirve para contener las opciones del
menú Settings, a la derecha de la toolbar
- Seleccionar el paquete que contiene clase de actividad principal, dar
botón derecho y hacer New->Fragment(Blank). Crear dos fragmentos Fragment1 y
Fragment2, desmarcar los checkboxes, dejar solo el que implica la creación del
layout
- Cambiar imports de clases recién creadas de Fragmentos a los
fragmentos. Debe quedar así
//import android.app.Fragment; import android.support.v4.app.Fragment;
- Arreglar los layouts de los fragmentos (a Relative o dejar como está,
depende de las necesidades del programador), agregar botones o componentes
requeridos
- En código de actividad globalizar a la clase (no necesario esto
porque en mi app no lo requiero)
NavigationView navigationview = nullo;
Toolbar toolbar = null;
- En Actividad_principal, establecer el fragmento de inicio, despueés
del setContentView
//////////////////////////
Fragmento_Principal fragmento =
new Fragmento_Principal();
android.support.v4.app.FragmentTransaction
fragmentTransaction =
getSupportFragmentManager().beginTransaction();
fragmentTransaction.replace(R.id.fragment_container,
fragmento );
fragmentTransaction.commit();
////////////////////////
- Cambiar el código de los eventos del itemdrawer, será el mismo de
arriba, sólo que la instancia del fragmento será distinta. En concreto cambiar
método:
public boolean
onNavigationItemSelected(MenuItem item) {
-
Modificar código de la clase fragmento, es
necesario inflar la vista del fragmento, y de ella obtener las referencias de
los componentes para programar su comportamiento
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
View v= inflater.inflate(R.layout.lay_fragmento1, container, false);
Button b = (Button) v.findViewById(R.id.btnFrag1);
b.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(getActivity(), "Desde fragmento", Toast.LENGTH_SHORT).show();
}
});
return v;
}
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
View v= inflater.inflate(R.layout.lay_fragmento1, container, false);
Button b = (Button) v.findViewById(R.id.btnFrag1);
b.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(getActivity(), "Desde fragmento", Toast.LENGTH_SHORT).show();
}
});
return v;
}