Teaching

Ejercicios para Programación Funcional, Unidad 3.

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









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();
    }
}


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




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
….
    app:headerLayout="@layout/nav_header_actividad_principal"
    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

 - Del app_bar_actividad_principal quitar el include y poner un FrameLayout con nombre: fragment_container
- 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;
}