Ejercicio 1

Definir un predicado sus(X,Y,L1,L2) que sea capaz de sustituir un elemento X por otro Y en la lista L1, para dar L2.

Solución

1
2
3
4

%Ejercicio 2
sus(_,_,[],[]).
sus(X,Y,[HT],[YRes]):-X=H,sus(X,Y,T,Res).
sus(X,Y,[HT],[HRes]):-X\=H,sus(X,Y,T,Res).

Ejercicio 2

Definir la relación aplanar(Lista, Aplanada), donde Lista es en general una lista de listas, tan compleja en su anidamiento como queramos imaginar, y Aplanada es la lista que resulta de reorganizar los elementos contenidos en las listas anidadas en un único nivel, i.e. una lista plana. Por ejemplo:

1
2

?- aplanar([[a, b], [c, [d, e]], f], L).
L = [a, b, c, d, e, f]

Solución

1
2
3
4

%Ejercicio 3
aplanar([],[]).
aplanar([XR],[XP]):- atomic(X),aplanar(R,P).
aplanar([XR],P):-  not(atomic(X)),aplanar(X,P_X),aplanar(R,P_R),append(P_X,P_R,P).

Ejercicio 3

Definir un predicado igualesElem(L1,L2) que compruebe que L1 y L2 son listas que
contienen los mismos elementos independientemente del orden de aparición.

Solución

1
2
3
4
5

%Ejercicio 4 
igualesElem([],[]).
igualesElem([H1T1],[H2T2]):- length([H1T1],N),length([H2T2],N),((H1==H2,igualesElem(T1,T2))
                                (algun(H1,[H2T2]),delete([H1T1],H1,AUX1),delete([H2T2],H1,AUX2),igualesElem(AUX1,AUX2))).
algun(X,[HT]):-(X==H)algun(X,T).

Ejercicio 4

Definir un predicado descomponer(N,A,B) que permita resolver el problema de descomponer un número natural N en la suma de dos pares A y B. Esto es, descomponer(N,A,B) debe tomar como entrada un natural N y devolver dos naturales A y B tales que N = A + B.

Solución

1
2
3
4

descomponer(N,A,B):-
    between(0,N,A), A mod 2=:=0, 
    between(0,N,B), B mod 2=:=0,
    A+B=:=N.

Ejercicio 5

Rompecabezas de Brandreth. El cuadrado de 45 es 2025. Notad que si partimos el número
en dos obtenemos los números 20 y 25 cuya suma es, precisamente, 45. Obtener que otros números cuyo cuadrado es un número de cuatro cifras cumplen esta propiedad. Con este fin, definir un predicado numBrandreth (N, C) que devuelva uno de estos números N y su cuadrado C.

Solución

1

numBrandreth(N,C):-between(32,99,N), C is N*N, A is C mod 100, B is C//100, A+B=:=N.

Pues bien, en muchas ocasiones la principal dificultad es encontrar la herramienta idónea para llevar a cabo estos diagramas. Existen muchas aplicaciones libres que permiten dibujar diagramas de todo tipo (una de las más destacables es DIA), pero yo os voy a presentar una herramienta muy diferente: SDEdit. Esta aplicación está diseñada para realizar diagramas de secuencia únicamente, pero de forma totalmente automática. El usuario simplemente debe especificar formalmente el diagrama de secuencia en forma de texto, y el programa automáticamente realiza el diagrama gráficamente. Los resultados son muy buenos, como podéis ver en la siguiente imagen:

Para que os hagáis una idea de cómo es el código que maneja SDEdit, a continuación podéis ver el código empleado para generar el diagrama anterior:

#![Modificar cuenta (escenario normal)]
visitante:Actor
w:Ventana de modificación
i:Gestor de usuarios
p:Persistencia
visitante:w.cambiar datos
visitante:w.pulsar botón de guardar
w:i.datos modificados
i:p.datos modificados
p:i.cambios exitosos
i:w.cambios exitosos
w:visitante.cambios realizados

Como podéis ver, no es nada complicado y el resultado es bastante bueno. Espero que os sea útil.

Hoy en día es casi imprescindible el uso de Internet o de bases de datos alojadas en la red por parte de nuestas aplicaciones Android. Uno de los métodos más fáciles y comunes para realizar una comunicación hacia dichos servicios y bases de datos se realiza mediante el consumo de servicios web, los cuales en la mayoría de los casos actuan como una capa intermedia entre nuestra aplicación e Internet.Hoy explicaremos como enlazar nuestra aplicación con nuestros servicios web.

Nota:Si no sabeis como crear un servicio web bajo .NET os recomiendo que echeis un ojo a éste artículo en el que explico como crearlo.

Obtención e importación de la librería ksoap2

Lo primero de todo es descargar la librería que nos permitirá la conexión hacia el servicio web. Se trata de ksoap2 y desde aquí podemos descargar el .jar .Una vez descargado y creado un proyecto Android en Eclipse, en la carpeta /res del proyecto crearemos una carpeta llamada lib en la que guardaremos el .jar (para saber siempre donde buscarlo a la hora de añadirlo a nuestro proyecto).

Ahora procederemos a añadirlo como librería a nuestro proyecto. Suponiendo que utilizamos Eclipse, hacemos click derecho sobre el proyecto y vamos a Propiedades, en la sección Java Build Path nos movemos hasta la pestaña Libraries, damos a Add JARs y procedemos a seleccionar el jar descargado (Lo acabamos de poner dentro de la carpeta lib del proyecto).

Una vez que ya tenemos nuestro librería añadida estamos listos para usarla. Para ello deberemos importarla añadiendo esto a la lista de import de la clase que vaya a hacer uso de la librería:

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;

Importada la librería vamos a ver como se utiliza. Los pasos para realizar una conexión son por regla general los siguientes:

• Preparación de los datos necesarios para la conexión del servicio web (dirección del servicio web, nombre del método).
• Preparación de los datos a enviar al servicio web (en el caso que hubiera).
• Apertura de la conexión con los datos necesarios.
• LLamada al método y obtención de los datos provenientes del servicio werb (en el caso que hubiera).
• Tratamiento de dichos datos devueltos.

Nota: el último punto aunque no parezca importante si que hay que indicarlo para explicar mas tarde el procesamiento de datos complejos provenientes del servicio web.

Preparación de los datos para la conexión

Para llamar al servicio web necesitaremos cuantro cadenas de texto (String) que usaremos siempre para realizar las llamadas a los métidos del servicio web.

El primero es el denominado “namespace” cuyo valor nos indica el propio servicio web al crearlo. El namespace viene indicado en la cabecera del servicio web:

[WebService(Namespace = "http://ip:puerto/NombreDelServicio/")]

Por lo que la cadena que define el namespace sería:

private static String NAMESPACE = "http://ip:puerto/NombreDelServicio/";

El segundo es la URL del servicio web, que viene a ser la adición del nombre del archivo .asmx a la cadena que define el NAMESPACE:

private static String URL = NAMESPACE+"Service1.asmx";

El tercer dato que necesitamos es el nombre de método que guardaremos en la variable METHOD:

private static String METHOD;

El cuaro dato será el SOAPACTION, que será una combinación del NAMESPACE y del método al que llamemos:

private static String SOAPACTION = null;

Apertura de la conexión y adición de los datos

Definidos los datos iniciales veamos la preparación de datos en caso de que queramos enviar datos al servicio web.Para ello haremos uso de la clase SoapObject, que es un tipo de datos de encapsulación para poder enviar y recibir datos del servicio web (actua como un parseador de xml que es lo que se acaba enviando o recibiendo de un servicio web), y de la clase PropertyInfo que es una clase que nos permite añadir información al objeto SoapObject. Veamos un ejemplo.

METHOD = "method";
SoapObject request = new SoapObject(NAMESPACE, METHOD);
PropertyInfo pi1 = new PropertyInfo();
pi1.setName("variable1");
pi1.setValue(“a”);
request.addProperty(pi1);

Hay que tener mucho cuidado al añadir las variables, ya que el nombre de éstas debe coincidir con el nombre de las varibles del método al que llamamos en el servicio web. Como se ve lo que hacemos es crear un objeto PropertyInfo al que añadiremos el nombre y el valor de la variable que deseamos enviar.

Una vez que tenemos los datos a enviar, pasaremos a abrir la conexión. Para ello utilizaremos la clase SoapSerializationEnvelope y la clase HttpTransportSE:

SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
SoapEnvelope.VER12);
envelope.dotNet = true; //indicamos que utilizaremos servicios .NET
envelope.setOutputSoapObject(request); //añadimos a la conexión el objeto SoapObject anteriormente creado
HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
androidHttpTransport.debug = true; //nos aseguramos así de que funcione siempre

LLamada al método y obtención de los datos provenientes del servicio web

Ya que tenemos abierta la conexión no queda mas que definir la variable SOAPACTION y realizar la llamada.

SOAPACTION = NAMESPACE + METHOD;
try {
	androidHttpTransport.call(SOAPACTION, envelope);
	SoapObject response = envelope.getResponse();
	//tratamiento de la respuesta
} catch (Exception e) {
	Log.d("error", e.getMessage().toString());
	return null;
}

De ésta manera llamamos al método del servicio web. Si el metodo del servicio web devuelve algún dato tendremos que tratarlo. En el caso de que nos encontremos con algún tipo complejo de datos (como una lista o de alguna clase que hayamos creado para tal propósito) deberemos tratarlo para recuperar la información. Para ello utilizaremos la clase SoapObject que encapsula los datos recibidos sean cual sean su naturaleza y nos proporciona una serie de métidos para poder extraer la información tal y como se devolvió desde el servicio web.

Tratamiento de datos complejos provenientes de un servicio web

Pongamos que el método del servicio web al que llamamos devuelve un List, el tratamiento de datos sería algo así:

SOAPACTION = NAMESPACE + METHOD;
List l = new ArrayList();
try {
	androidHttpTransport.call(SOAPACTION, envelope);
	SoapObject response = envelope.getResponse();
	//tratamiento de la respuesta
	if (response != null) {//comprobamos que la respuesta no esté vacía
                //recorremos el objeto
		for (int i = 0; i < response.getPropertyCount(); i++) {
                           //obtenemos el elemento i de la lista (sabemos que es un String)
                           l.add(response.getProperty(i).toString());
                           Log.d("elmento"+i+"devuelto",response.getProperty(i).toString());
		}
		return l;
	} else {
		return null;
	}
} catch (Exception e) {
	Log.d("error", e.getMessage().toString());
	return null;
}

Explicaré mejor el código de arriba. La variable response del tipo SoapObject obtiene el List que se devolvío por parte del servicio web y mediante un bucle utilizando la variable getPropertyCount() que nos devuelve el número de elementos que posee, recorremos el objeto como si recorrieramos el List. Cada elemento obtenido mediante el bucle es del tipo SoapObject, al cual simplemente haremos un toString() ya que sabemos que es un String. Hay que tener mucho cuidado a la hora del procesamiento de los datos devueltos ya que hay que estar totalmente seguro de que tipo de datos devuelve el método invocado.

Si los datos fueran mas complejo aún (imaginemos un List<List>) deberíamos extraer cada SoapObject del objeto devuelto por parte del servicio web (que a su vez sería un List) para, mediante otro bucle anidado, recorrer la segunda lista obteniendo ya si los valores de las cadenas de texto que contienet. Sería algo así:

if (response != null) {//comprobamos que la respuesta no esté vacía
        //recorremos el objeto
	for (int i = 0; i < response.getPropertyCount(); i++) {
        //obtenemos el elemento i del List< List< String > >;
        SoapObject element = response.getProperty(i);
       /*recorremos el List< String > i */
        for(int j=0;j< element.getPropertyCount();j++){
	        String a = element.getProperty(i).toString();
	        //tratamos la cadena a
	}
}

Y con esto daríamos por concluída la lección sobre conexiones a servicios web .NET en Android usando ksoap2. Éstas conexiones nos vendrán muy bien por ejemplo para acceder a datos que están alojados en bases de datos en la red o simplemente para realizar operaciones fuera del alcance de nuestro dispositivo.

Enlace: aquí.

Pues bien, sin más preámbulos, aquí tenéis los ejercicios:

Enunciado

El siguiente programa Prolog especifica una base de datos deductiva sobre relaciones familiares. Completar el código dado, respondiendo a los diferentes apartados, mediante la lectura de estos fragmentos del Génesis.

“He aquí la descendencia de Teraj: Teraj engendró a Abram (posteriormente llamado `Abraham’, que significa `Padre de multitud’), Najor, y Harán. Harán engendró a Lot … La mujer de Abram se llamaba Sarai (o Sara) y la de Najor Melca, hija de Harán, padre de Melca y de Jesca.”

“Sarai, la mujer de Abram, no le había dado hijos, pero ella tenía una esclava egipcia de nombre Agar. … tomó a Agar y se la dio por mujer a Abram, … Agar parió un hijo a Abram y a este hijo tenido de Agar, Abram le llamó Ismael.”

Estando en la tierra de Guerar, Abram confeso que: ” es verdad que ella (Sarai) también es mi hermana, hija de mi padre pero no de mi madre, y ahora es mi mujer.”

“Sara, pues, concibió y parió un hijo en su vejez, en el tiempo predicho por Dios. Y Abraham llamó al hijo que le nació Isaac (que significa `el que ríe’).” Isaac casó con Rebeca, “hija de Batuel, el que Melca parió a Najor” y hermana de Labán. Isaac y Rebeca tuvieron dos hijos, Esaú y Jacob, pero ésta es otra historia.

El código dado por el ejercicio es:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

%%% HECHOS
 
padre(abraham,isaac).
padre(haran,lot).
padre(haran,melca).
padre(haran,jesca).
hombre(isaac).
hombre(lot).
mujer(melca).
mujer(jesca).
 
%%% REGLAS
 
ascendiente_directo(X, Y) :- (padre(X, Y) madre(X, Y)).
ascendiente(X, Z) :- ascendiente_directo(X, Z).
ascendiente(X, Z) :- ascendiente_directo(X, Y), ascendiente(Y, Z).
hijo(X,Y) :- hombre(X), ascendiente_directo(Y,X).
hija(X,Y) :- mujer(X), ascendiente_directo(Y,X).

Se pide responder a los siguientes apartados:

• Completar la base de datos con los hechos extraídos del fragmento del génesis anterior.
• Definir las relaciones: ascendente, descendente, abuelo, hermano, tío, sobrino y primo.
• Definir un predicado que nos informe de las relaciones que hoy consideramos incestuosas.

Solución

La solución que propongo es la siguiente (ya todo el código junto):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

				%HECHOS
%hombre
hombre(abraham).
hombre(isaac).
hombre(lot).
hombre(najor).
hombre(ismael).
hombre(haran).
hombre(teraj).
hombre(batuel).
hombre(laban).
hombre(esau).
hombre(jacob).
 
%mujer
mujer(rebeca).
mujer(melca).
mujer(jesca).
mujer(sara).
mujer(agar).
 
%esclava
esclava(agar).
 
%padre
padre(abraham, isaac).
padre(abraham, ismael).
padre(haran, lot).
padre(haran, melca).
padre(haran, jesca).
padre(teraj, abraham).
padre(teraj, sara).
padre(teraj, najor).
padre(teraj, haran).
padre(batuel, rebeca).
padre(batuel, laban).
padre(najor, batuel).
padre(isaac, esau).
padre(isaac, jacob).
 
%madre
madre(agar, ismael).
madre(sara, isaac).
madre(rebeca, esau).
madre(rebeca, jacob).
madre(melca, batuel).
 
%casados 
casado(abraham, sara).
casado(isaac, rebeca).
casado(najor, melca).
 
 
				%REGLAS
%hijo
hijo(X, Y) :- padre(Y, X), hombre(X).
hija(X, Y) :- padre(Y, X), mujer(X).
 
%casados
casados(X, Y) :- casado(X, Y) casado(Y, X).
 
%ascendiente_directo
ascendiente_directo(X, Y) :- padre(X, Y) madre(X, Y).
 
%abuelo
abuelo(X, Y) :- padre(X, Z), ascendiente_directo(Z, Y).
 
%abuela
abuela(X, Y) :- madre(X, Z), ascendiente_directo(Z, Y).
 
%nieto
nieto(X, Y) :- (abuelo(Y, X) abuela(Y, X)), hombre(X).
 
%nieta
nieta(X, Y) :- (abuelo(Y, X) abuela(Y, X)), mujer(X).
 
%ascendiente
ascendiente(X, Y) :- ascendiente_directo(X, Y).
ascendiente(X, Y) :- abuelo(X, Y) abuela(X, Y).
 
%hermano
hermano(X, Y) :- hombre(X), (ascendiente_directo(Z, X), ascendiente_directo(Z, Y)), X\=Y.
 
%hermana
hermana(X, Y) :- mujer(X), (ascendiente_directo(Z, X), ascendiente_directo(Z, Y)), X\=Y.
 
%hermanos
hermanos(X, Y) :- hermano(X, Y) hermana(X, Y) hermano(Y, X) hermana(Y, X).
 
%descendiente_directo
descendiente_directo(X, Y) :- ascendiente_directo(Y, X).
 
%descendiente
descendiente(X, Y) :- descendiente_directo(Y, X).
descendiente(X, Y) :- nieto(X, Y) nieta(X, Y).
 
%tio_carnal
tio_carnal(X, Y) :- hermanos(X, Z), ascendiente_directo(Z, Y), hombre(X).
tia_carnal(X, Y) :- hermanos(X, Z), ascendiente_directo(Z, Y), mujer(X).
 
%tio_no_carnal
tio_no_carnal(X, Y) :- casados(X, Z), tia_carnal(Z, Y).
tia_no_carnal(X, Y) :- casados(X, Z), tio_carnal(Z, Y).
 
%tio
tio(X, Y) :- tio_carnal(X, Y) tio_no_carnal(X, Y), not(padre(X,Y)), X\==Y.
 
%tia
tia(X, Y) :- tia_carnal(X, Y) tia_no_carnal(X, Y), not(madre(X,Y)), X\==Y.
 
%sobrino
sobrino(X, Y) :- hombre(X), (tio(Y, X) tia(Y, X)).
 
%sobrina
sobrina(X, Y) :- mujer(X), (tio(Y, X) tia(Y, X)).
 
%primo
primo(X, Y) :- hombre(X), (tio(Z, X) tia(Z, X)), ascendiente_directo(Z, Y),X\==Y.
 
%prima
prima(X, Y) :- mujer(X), (tio(Z, X) tia(Z, X)), ascendiente_directo(Z, Y),X\==Y.
 
%primos
primos(X, Y) :- primo(X, Y) primo(Y, X) prima(X, Y) prima(Y, X).
 
%incestuosos
incestuosos(X, Y) :- casados(X, Y), hombre(X), mujer(Y),(hermanos(X, Y) primos(X, Y) ascendiente_directo(X, Y) descendiente_directo(X, Y) abuelo(X, Y) nieto(X, Y) abuela(X, Y) nieta(X, Y) tio(X, Y) tia(X, Y) sobrino(X, Y) sobrina(X, Y)).

Espero que os sirva. Y si quereis aprender Programación Declarativa y Prolog, os recomiendo el libro “Programación lógica. Teoría y Práctica”, de Pascual Julián Iranzo y María Alpuente Frasnedo, que está muy bien escrito y completamente en español.

Bueno, aquí os dejo unas prácticas resueltas de Simulación. No implica que este todo bien, es más se hicieron de una forma muy muy rápida, así que seguro que contiene algunos errores, pero viene muy bien como ayuda para empezar.

Viendo el código en Matlab me da vergüenza como está programado (no intentéis programar en Matlab como lo hacéis en Java o C, porque entonces estaréis perdiendo mucho potencial). Creo que toda la parte que implica sólo la programación en Matlab es compatible con Octave (sólo habrá que cambiar en ciertos lugares un poco de la sintaxis), pero para la parte de Simulink es imprescindible Matlab.

Espero que podáis utilizarlo, lo mejoréis y nos lo enviéis para que podamos volver a colgarlo para los siguientes que lo necesiten.

Si tienes otros apuntes, prácticas, o lo que sea y quieres compartirlo dinoslo y lo publicamos.

PD: Hay algunos datos “sospechosos” a quién los encuentre, le doy un premio.

Pues bien, hoy os quiero presentar a YakiTo, un conversor multimedia escrito en Java en el que estoy trabajando para presentarlo al concurso universitario de software libre. Está pensado, principalmente, para resultar sencillo al usuario menos experimentado, así como para ofrecer múltiples idiomas de la interfaz gráfica, y posibilitar ciertas características que no son muy comunes en estos conversores, como la conversión de varios videos de forma paralela o la ausencia absoluta de dependencias externas (salvo Java, claro). Todavía está en desarrollo, pero ya existe una versión funcional en la web del proyecto. Una de las ventajas de la forma en la que estoy desarrollando YakiTo es lo sencillo que resulta colaborar en él, incluso sin tener ni idea de programación, así que si te apetece ayudar a un proyecto de software libre aquí puedes ver cómo hacerlo.

Para instalarlo sólo teneis que ir a la web del proyecto y descargar la versión de vuestro sistema operativo (YakiTo está disponible para Windows y GNU/Linux, aunque también se distribuye para otros sistemas operativos, pero con menos garantía de que funcionen las cosas). La aplicación tiene el siguiente aspecto:

Tened en cuenta que la versión actual está un poco limitada: sólo dispone del idioma Español y de unos cuantos perfiles de prueba. Lo que me gustaría es que le echarais un ojo y fuerais familiarizándoos con YakiTo. Si la gente colabora conmigo, pronto dispondré de numerosos idiomas y perfiles de conversión para todo tipo de dispositivos. EEspero que mi proyecto os cause buena impresión y estéis atentos a las nuevas versiones que se vayan lanzando.

Un saludo.

External port: 5228 Internal port: 5228 Protocol: TCP/UDP

Por si a alguien le interesa conocer los puertos de otras aplicaciones, lo encontré en esta página web que puede que os resulte de interés.

- Información sobre el teléfono (IMEI, red, hacer un ping a google.es, establecer tipo de red preferido,…)

- Información de la batería(temperatura, nivel carga, estado, voltaje,tiempo desde el inicio,…)

- Historial de la batería (con gráficas y porcentajes del uso )

- Estadísticas de uso (tiempo de uso, número de incios de cada aplicación instalada)

- Información del servicio Blur (sólo para los Motorola con Moto Blur)

Es bastante curioso, estoy descubriendo poco a poco Android, y la verdad es que tiene muchas cosas que me gustan (aunque otras no).