PROLOG - Horario de Clase

Lenguajes de Programación - Semana 9 - PUNTOS EXTRA

Se plantea el siguiente acertijo:

”Un alumno de ITS, debido al nerviosismo del primer día de clase, ha anotado el nombre de sus profesores (Elisa, Fernando y Carlos), las asignaturas que se imparten (Lógica, Programación y Matemáticas) y el día de la semana de las distintas clases (lunes, miércoles y viernes), pero sólo
recuerda que:
- La clase de Programación, impartida por Elisa, es posterior a la de Lógica
- A Carlos no le gusta trabajar los lunes, día en el que no se imparte Lógica
Ayudale a relacionar cada profesor con su asignatura, así como el día de la semana que se imparte
(Sabemos que cada profesor imparte una única asignatura y que las clases se dan en días diferentes)”

Analicemos el problema mentalmente:

Tenemos 3 materias:

Lógica
Programación
Matemáticas

Tenemos 3 dias:

Lunes
Miércoles
Viernes

Tenemos 3 maestros:

Elisa
Carlos
Fernando

Con base a la redacción del problema tenemos las siguientes proposiciones:

Elisa da programación.
Carlos no trabaja el lunes.
El lunes no hay clase se Lógica.
Programación se imparte cualquier día posterior al Lunes.

Para acomodar los días en que se imparte cada materia sabemos solamente que los lunes no hay lógica, como programacón se da el día posterior a lógica entonces no puede impartirse el miércoles , y aunque necesitamos un día anterior ese día anterior no puede ser el lunes, entonces las materias se imparten en el siguiente orden:

Matemáticas los Lunes
Lógica los Miércoles
Programación los Viernes

Como Carlos no trabaja los lunes entonces solo le queda el miércoles para impartir clase porque Elisa le gan&ocute; los viernes, a Fernando no le qued&ocute; de otra mas que dar matemáticas. Entonces la respuesta al problema es:

Fernando da Matemáticas los Lunes
Carlos da Lógica los Miércoles
Elisa da Programación los Viernes

Analicemos el problema en PROLOG:

Primero convertimos cada una de las proposiciones en hechos:

materia(logica).
materia(programacion).
materia(matematicas).
maestro(elisa).
maestro(fernando).
maestro(carlos).
dia(lunes).
dia(miercoles).
dia(viernes).

Tendremos 3 formatos de respuesta diferentes:

imparte(X,Y) "Profesor X imparte la materia Y"
trabaja(X,Z) "Profesor X trabaja el día Z"
clase(Y, Z) "Hay clase Y el dia Z"

Tenemos la siguientes proposiciones predefinidas:

imparte(elisa, programacion). "Elisa imparte programacón"

Entonces para saber que maestro va el resto de las materias aplicaremos la siguiente regla:

imparte(X, Y) :- maestro(X), X\=elisa, materia(Y), imparte(elisa,YA), YA\=Y. "Sera verdad si hay un maestro X, a excepcion de Elisa; y existe una materia Y. Sacamos a Elisa de este conjunto porque ya sabemos que clase imparte, además recursivamente quitaremos el curso que imparte Elisa."

Sabemos tambien que Carlos ira cualquier día que no sea lunes, entonces:

trabaja(carlos, Z) :- dia(Z), Z\=lunes. " Carlos trabaja algún día Z, a excepción del Lunes"

La regla general queda:

trabaja(X, Z) :- maestro(X), X\=carlos, dia(Z), Z\=miercoles. "Sera verdad si hay un maestro X, quitando a Carlos, un dia Y. Quitamos a Carlos porque ya sabemos que lunes no va y los miercoles porque Carlos no va lunes y el viernes es de Elisa"

Tambien tenemos conocimento de que la clase de lógica no se da los lunes, entonces:

clase(logica, Z) :- dia(Z), Z\=lunes, Z\=viernes. "Sera verdad que logica se imparte el dia Z, si ese dia no es lunes o viernes; porque el lunes no aplica y el viernes tampoco puesto que sabemos hay una clase delante de ella"

clase(programacion, Z) :- dia(Z), Z\=lunes, clase(logica, ZA), ZA\=Z. "Sera verdad que programación se da un día Z, si ese día no es lunes; porque sabemos que hay una clase anterior a ella. Recursivamente quitamos el día en el que lógica puede impartirse"

La regla general queda:

clase(Y, Z) :- materia(Y), Y\=logica, Y\=programacion, clase(logica, ZA), clase(programacion, ZB), dia(Z), ZA\=Z, ZB\=Z. "Sera verdad si hay una materia Y que no sea lógica o programación, y cualquier día de la semana que no sean los días en que se imparte lógica y programación"

PROGRAMA COMPLETO

materia(logica).
materia(programacion).
materia(matematicas).
maestro(elisa).
maestro(fernando).
maestro(carlos).
dia(lunes).
dia(miercoles).
dia(viernes).
imparte(elisa, programacion).
imparte(X, Y) :- maestro(X), X\=elisa, materia(Y), imparte(elisa, YA), YA\=Y.
trabaja(carlos, Z) :- dia(Z), Z\=lunes.
trabaja(X, Z) :- maestro(X), X\=carlos, dia(Z), Z\=miercoles.
clase(programacion, Z) :- dia(Z), Z\=lunes, clase(logica, ZA), ZA\=Z.
clase(logica, Z) :- dia(Z), Z\=lunes, Z\=viernes.
clase(Y, Z) :- materia(Y), Y\=logica, Y\=programacion, clase(programacion, ZA), clase(logica, ZB), dia(Z), ZA\=Z, ZB\=Z.

Abrimos un archivo en emacs y lo llamaremos "horario.pro" (en terminal tecleamos: emacs -nw horario.pro ), tecleamos el código que les acabo de mostrar y guardamos todo.
Despues procedemos a abrir el interprete SWI-PROLOG:


Posteriormente cargamos el código que acabmos de guardar:


** OPCIONALMENTE PODEMOS TECLEAR LA OPCION listing. PARA VER LA CARGA DEL ARCHIVO, YO LA OMITO PORQUE LA IMAGEN ES MUY LARGA PARA ESTA ENTRADA.

Ahora evaluamos el problema, en este caso hay que concatenar todas nuestras preguntas para que se evalún juntas, si las ponemos separadas solo se nos mostraran todas las combinaciones de maestros, días y clases, pueden probarlo si quieren; asi evaluaremos toda la pregunta completa:

imparte(X,Y),trabaja(X,Z),clase(Y,Z).

Y este es el resultado:


Como ven, el resultado es el horario armado tal como la respuesta que obtuvimos analíticamente.

PD: La "a" al lado de la respuesta de Elisa la teclee yo, sirve para mostrar toda la lista de resultados sin tener que aplanar la tecla ";" para listar respuesta tras respuesta.

SALUDOS!!! ^_^

PROLOG - Cuatro Perros

Lenguajes de Programación - PUNTOS EXTRA

Se establece el siguiente razonamiento:

CUATRO PERROS

Tenemos cuatro perros: un galgo, un dogo, un alano y un podenco. Éste último come más que el galgo; el alano come más que el galgo y menos que el dogo, pero éste come más que el podenco. ¿Cuál de los cuatro será más barato de mantener?

La crisis esta dura, queremos una mascota y necesitamos saber cuál de todos los perros que nos mostraron en la tienda de mascotas es mas barato de mantener, analizando el problema mentalmente tenemos las siguientes proposiciones:

El Podenco come más que el Galgo.
EL Alano come más que el Galgo.
El Dogo come más que el Alano.
El Alano come más que el Podenco.

Entonces el orden (del más caro de mantener, al mas barato) es el siguiente:

1. DOGO
2. ALANO
3. PODENCO
4. GALGO

El Galgo es el mas barato a la larga, asi que corremos a comprarlo. ^_^

Vamos a analizar el mismo problema en PROLOG.

Primero convertimos las proposiciones a hechos para que sean compatibles con PROLOG, los hechos se basaran en "quien come mas que quien", es decir, tendremos esta sintaxis en los hechos:

come_mas(X , Y) "X come mas que Y.

Entonces:

come_mas(podenco, galgo).
come_mas(alano, galgo).
come_mas(dogo, alano).
come_mas(alano, podenco).

La regla se basara obviamente en "quien come menos de todos los demas", asi que generalizaremos la regla de la siguiente manera

come_menos(X, _) "X come menos que todos"

Esta regla aplica entonces a la inversa del hecho "quien come mas que quien", es decir, para evaluar quien come menos necesitamos el miembro Y del que come mas.

Entonces la regla queda así:

come_menos(X,_) :- come_mas(_,X).

PROGRAMA COMPLETO:

come_mas(podenco, galgo).
come_mas(alano, galgo).
come_mas(dogo, alano).
come_mas(alano, podenco).

come_menos(X,_) :-
come_mas(_,X).

Abrimos un archivo en emacs y lo llamaremos "perros.pro" (en terminal tecleamos: emacs -nw perros.pro ), tecleamos el código que les acabo de mostrar y guardamos todo.
Despues procedemos a abrir el interprete SWI-PROLOG:


Posteriormente cargamos el código que acabmos de guardar:


Ahora evaluamos el problema:

come_menos(X, _) "Quien come menos que todos?"

EJECUCIÓN:


Efectivamente, PROLOG nos responde que el Galgo come menos que todos los demas perros, ahora estamos mas que convencidos de comprar un Galgo.

SALUDOS!!! ^_^

CLASE - Selección e Iteración

Lenguajes de Programación - Semana 11 - Tarea 9 - Tercera Presentación

ALGORITMO DE FLOYD-WARSHALL

Diapositiva 1



Diapositiva 2


Ideado por Robert W. Floyd en 1962 basado en el Teorema de Warshall, es un algoritmo de análisis y optimizacion. Su objetivo encontrar la distancia mínima entre los vertices que forman un grafo, los cuales pueden tener una direccion y una ponderacion.

Diapositiva 3


Tenemos un grafo G con n vertices V y queremos ir por el Camino C, osea, ir del vertice 1 al 4. Sabemos que podemos pasar por puntos intermedios K que iran desde V1+1 a Vn-1. El algoritmo comparara todos los posibles caminos entre el par de vértices, teniendo un posible punto intermedio y se hara la estimación del camino más corto entre dos vértices, hasta que se sabe que la estimación es la óptima.
Este es el pseudocodigo lo explicare al grandes razgos la parte verde indica la carga de los datos, la funcion floyd_warshall, recibe el numero de vertices y una matriz cuadrada W de n X n vertices, se crea la matriz principal de distancias y una matriz de pasos, despues con los cliclos for de va cargando uno a uno los datos de W a D.
La parte roja son los ciclos principales del algoritmo, ahi se van comparando las distancias del vertice i al j pasando por k. Se comparan la suma de las coordenadas de las componentes de la matriz, si la suma es menor a la distancia original se mejora y se marca el paso en la matriz pasos y al terminar se regresa la matriz D optimizada
El algoritmo realiza V^3 comparaciones, es decir, aqui se pueden realizar hasta 64 comparaciones!!!

Diapositiva 4: Resultados Animación


Diapositiva 5: Referencias



Descarga: presentacion.odp

Descarga animación: Presentacion.mpeg

Saludos!! ^_^

PROLOG - Programas Aritméticos

Laboratorio de Lenguajes de Programación - Semana 7

Ya vimos como utilizar Prolog para resolver problemas lógicos, esta vez tengo un 2 ejemplos aritméticos.

IDENTIFICAR NUMEROS POSITIVOS Y NEGATIVOS

Para saber si un número es positivo o negativo necesitamos saber como deseamos ver el resultado final, en este caso yo utilizaré un hecho con 2 argumentos:

numero(X, Y).

donde: X sera el número el cual yo deseo saber si es positivo, negativo o nulo; y Y me mostrará el resultado.

Ahora, por simple razonamiento: un número positivo es aquel mayor a 0, los negativos son menores a 0 y el 0 es el único nulo. Entonces:

X > 0: POSITIVO
X < 0: NEGATIVO
X == 0: NULO

Con este razonamiento podemos proceder a realizar el programa, abrimos un archivo en emacs (emacs -nw numeros.pro), procedemos a teclear la siguientes reglas:

numero(X,Y) :- X > 0 , Y = 'POSITIVO'.
numero(X,Y) :- X < 0 , Y = 'NEGATIVO'.
numero(X,Y) :- X == 0, Y = 'NULO'.

Lo guardamos en alguna ubicación donde nos sea facil ubicarlo.

Ahora, abrimos SWI-PROLOG en una terminal, ahi tecleamos prolog.
Una vez en el interprete compilamos el código con el comando consult('ubicacion_del_archivo')., aqui una captura de los 2 anteriores pasos:


Ahora comprobemos que el programa funciona correctamente, con los siguientes cuestionamientos:

numero(1,X).
numero(5,X).
numero(-2,X).
numero(-120,X).
numero(0,X).

RESULTADO:



El programa funciona correctamente.

POTENCIA EN PROLOG

Otro clásico de la programación, este ejemplo lo tome para que vean como Prolog es compatible con la recursividad.

Para empezar, utilizaremos un hecho con 3 argumentos:

potencia(X, Y, Z)

donde: X es la base, Y es el exponente, Z es el resultado.

Al momento de calcular una potencia tenemos 2 posibles casos que nunca cambian:

0 ^ 0 = no se puede calcular.
n ^ 0 = 1 ; siempre sera uno.

La potencia recursiva se calcula en base a esta regla:

X^Y = X * potencia(X,Y-1)

Abrimos un archivo de texto y tecleamos el siguiente código:

potencia(0,0,'ERROR') :- !.
potencia(X,0,1) :- X =\= 0.
potencia(X,Y,Z) :- A is Y -1, potencia(X,A,B), Z is B*X.

La primera linea es caso de error una base 0 elevada a un exponente 0.
La segunda linea se especifica que si una base N ,siempre que N sea diferente de 0, se eleva a un exponente 0 siempre es 1.
La tercera linea es el caso recursivo, se crea una variable A que guarda el decremento de Y hasta que el exponente es 0, se crea una nueva funcion potencia(X,A,B) donde B guarda el resultado de la multiplicación B * X durante la recursión, el resultado real se guarda en Z de la primera función potencia(X,Y,Z).

Abrimos en la terminal el interprete SWI-PROLOG y compilamos el código:


Ahora realizamos algunos calculos para probar el programa:


En ejemplo solo pongo la base y el exponente, es decir potencia(2,3,X) (2 elevado a la 3); pongo una X mayúscula porque quiero que el programa me evalue la operación y me regrese el resultado, recordemos que la funcion original es potencia(X,Y,Z) : X es la base, Y es el exponente, Z es el resultado.

**Es importante volver a mencionar que cuando queremos evaluar algun argumento de un hecho debemos poner en ese argumento cualquier letra (variable) en MAYÚSCULA, si no nos interesa evaluar algun argumento escribimos un GUIÓN BAJO.

Espero y les hayan servido estos ejemplos.

SALUDOS!!! ^_^

PROLOG - Cuñados

Laboratorio de Lenguajes de Programación - Semana 7

SE PLANTEA EL SIGUIENTE RAZONAMIENTO:

¿Qué persona es cuñado de Quién?
Se tienen los siguientes parentescos:
Pedro es hermano de Luis. Luis es el esposo de Ana; Antonio es el esposo de Elsa y Juan es el hermano de Luis. Carlos es hermano de Juan. Elsa es hermana de Luis y esposa de Antonio.


ANÁLISIS

Tenemos dos parejas de esposos:

esposos(luis, ana). luis esposo de ana
esposos(elsa, antonio). antonio esposo de elsa

Ahora, tenemos los siguientes parejas de hermanos:

hermanos(luis, pedro).
hermanos(luis, juan).
hermanos(juan, carlos). por consiguiente:
hermanos(luis,carlos).
hermanos(luis, elsa)., como elsa es hermana de luis, entonces se tienen los siguientes parentescos:
hermanos(elsa, luis).
hermanos(elsa, carlos).
hermanos(elsa, juan).
hermanos(elsa, pedro).

RAZONAMIENTOS

Para que Antonio tenga cuñados, es necesario que Elsa tenga hermanos, todos los hermanos de Elsa son cuñados de Antonio; y todos los hermanos de Luis son cuñados de Ana; esto nos parece lógico a nosotros, pero recordemos que a prolog es necesario declararselo, entonces:

cunados(X, Z), en este caso X puede ser Ana o Antonio, los que no pertenecen a la familia; y Z sera algun miembro de la familia de hermanos; Y sera el esposo/esposa de X

Z sera cuñado de X si: X y Y son esposos, y ademas Y y Z son hermanos

ejemplo literal:

luis es cuñado de antonio si: antonio y elsa son esposos y ademas elsa y luis son hermanos
carlos es cuñado de ana si: ana y luis son esposos y ademas luis y carlos son hermanos

La condición quedara algo asi:

cunados(X,Z) :- esposos(Y,X) , hermanos(Y,Z)

HIPÓTESIS

El programa completo tendría la siguiente declaración:

cunados(X,Z) :- esposos(Y,X) , hermanos(Y,Z).
esposos(luis, ana).
esposos(elsa, antonio).
hermanos(elsa, luis).
hermanos(elsa, juan).
hermanos(elsa, carlos).
hermanos(elsa, pedro).
hermanos(luis, pedro).
hermanos(luis, juan).
hermanos(juan, carlos).
hermanos(luis, carlos).
hermanos(luis, elsa).

EJECUCIÓN

Abrimos un archivo de texto, lo tecleamos y lo guardamos con la terminación *.pro / *.prolog.

Ahora veamos su ejecución, abrimos una terminal y ahora escribimos prolog para abrir el entorno de SWI-PROLOG:



Despues compilamos el código que tecleamos:


Queremos saber de las parejas de esposos quienes son los cuñados de Ana y quienes los de Antonio, asi que le preguntamos a Prolog lo siguiente:

cunados(antonio,X). (cunados de antonio?), no importa quien, listar todas las posibilidades.

cunados(ana,X). (cunados de ana?), no importa quien, listar todas las posibilidades.

RESULTADOS



CONCLUSIÓN

Sabiamos que cada uno tendría 4 cuñados, lo que aqui comprobamos es que el programa que tecleamos funciono bien porque nos regreso los resultados que esperabamos, si Luis tiene 4 hermanos, esos 4 hermanos son los cuñados de Ana, y los 4 hermanos de Elsa son los 4 cuñados de Antonio.

SALUDOS!!! ^_^

LENGUAJES LÓGICOS - Resolución de Problemas

Lenguajes de Programación - Semana 9 - Tarea 7

Resolución de Problemas

MATCHING SOCKS
You are about to leave for holiday, but you forgot socks! You race back to your room, but all the lights are off, so you can't see the color of the socks.

Never mind, because you remember that in your drawer there are ten pairs of white socks, ten pairs of black socks, and eleven pairs of blue socks, but they are all mixed up.

How many of your socks do you need to take before you can be sure to have at last one matching pair?

Atinale a los calcetines
Estas por irte de vacaciones, ¡pero olvidaste los calcetines! Entonces te apresuras de vuelta a tu cuarto, pero todas las luces están apagadas, por lo que no puedes ver el color de los calcetines.

No te preocupas, porque sabes que en tu cajón hay 10 pares de calcetines blancos, 10 pares de calcetines negros y 11 de calcetines azules, pero están revueltos.

¿Cuántos calcetines necesitas sacar para estar seguro de que mínimo haz armado un par?

RESPUESTA

Se trata de un juego de azar, podemos tomar un puñado de calcetines y obtener varios pares de calcetines, pero no se trata de eso.
Tenemos 31 calcetines en el cajón, de 3 colores diferentes. Podemos hacer varias combinaciones, por ejemplo:

- 2 blancos 1 negro
- 2 blancos 1 azul
- 2 negros 1 blanco
- 2 negros 1 azul
- 2 azules 1 blanco
- 2 azules 1 negro
- 3 negros
- 3 blancos
- 3 azules

En la lista anterior vemos que el azar sigue jugando el papel determinante para obtener un par, y es que prácticamente todos los colores tienen la misma probabilidad de salir (aprox. 30%).

Para romper las reglas de azar que rigen este caso hay que sacar tres calcetines y suponer que los tres son de diferente color, como ya tenemos todos los colores disponibles esta por demás decir que el cuarto calcetín tiene que ser 100% par de alguno de los tres anteriores, ya sea par blanco, azul o negro.

LA SOLUCION ES SACAR CUATRO CALCETINES Y ASI OBTENDREMOS UN PAR

SALUDOS !!! ^_^

LENGUAJES LÓGICOS - Generalidades PROLOG

Lenguajes de Programación - Semana 9 - PUNTOS EXTRA

Es un lenguaje declarativo e interpretado, es decir, se usa para representar conocimientos sobre determinado universo y las relaciones entre los objetos de ese universo. A partir de esos conocimientos el sistema comienza a deducir todos las cuestiones que se pueden plantear, las cuales pueden ser verdaderas o falsas.

En la sintaxis de Prolog se utilizan cláusulas y comandos.

Las cláusulas son definidas por nosotros y se subdividen en hechos y reglas, terminan cada una en punto siempre, por ejemplo:

HECHO: nombre_pred(X, Y, Z, ...).
Donde X, Y, Z son los argumentos del hecho y pueden ser dos, tres, etc...

REGLA: nombre_pred(X, Y, Z, ...) :- pred1(...) , pred2(...).
Esto se puede leer: nombre_pred es verdad si pred1 y pred2 son verdad

Podemos utilizar la siguiente tabla:

:-	Condición	Si... entonces...
,	Conjunción	... y ...
;	Disyunción	... o ...

En cambio los comandos son los objetivos que se plantean al sistema, por ejemplo:

Supongamos que tengo el hecho:

raton(jerry). (jerry es un raton)

quiero saber los siguientes comandos asi que le pregunto al sistema:

a) ?- raton(mickey). (Es mickey un raton?), el sistema respondera FALSE porque no lo he declarado asi.

b) ?- raton(X). (qué cosa es un raton?), el sistema respondera X = jerry, osea, jerry es un raton.

A los comandos tambien se les conoce tambien como GOAL (metas).

Las variables son secuencias de caractéres alfanumericos que comienzan siempre en mayúscula o con guión bajo, por ejemplo:

Variable1
_Variable2

Vamos a ver un ejemplo sencillo de ejecución de prolog. Para ello tenemos primero que instalar el interprete de Prolog en nuestro sistema, teclearemos en una terminal los siguientes comandos: sudo apt-get install swi-prolog y sudo apt-get install gprolog.

Una vez instalados los paquetes vamos a iniciar alguno de los interpretes, en mi caso abriré GPROLOG, asi que tecleamos en la terminal gprolog, se vera algo como esto:


Ahora declaremos algunos hechos para comprobar si son verdaderos; abrimos un documento de emacs (emacs -nw ejemplo1.pro) y tecleamos lo siguiente:

vehiculo(X,Y,Z):-auto(X,Y,Z);camioneta(X,Y,Z).
auto(dodge,45000,rojo).
auto(nissan,20000,blanco).
camioneta(ford,60000,negro).
camioneta(chevrolet,50000,azul).

Donde: X es la marca del auto, Y es el precio y Z es el color.

Ahora ustedes diran, qué quiere decir esto, bueno mas o menos se traduce asi:

un vehiculo es verdad si auto es verdad o camioneta es verdad
dodge es un auto que cuesta 45000 y es color rojo
nissan es un auto que cuesta 20000 y es color blanco
ford es una camioneta que cuesta 60000 y es color negro
chevrolet es una camioneta que cuesta 50000 y es colo azul

La primera linea tambien quiere decir que cualquier auto y cualquier camioneta se consideran vehiculos.

GUARDAMOS EL DOCUMENTO CON TERMINACION *.PRO Ó *.PROLOG

Ahora, regresamos al interprete gprolog y compilamos el archivo, ello usamos la siguente sintaxis: consult('/home/usuario/ubicacion/ejemplo1.pro')., cada uno sabe donde guardo el archivo, presionamos enter y en mi caso se ve algo asi:


Ahora, hagamosle algunas preguntas al sistema para ver que nos responde:

vehiculo(_,_,_). (existen vehiculos?), en este caso se escriben guiones bajos porque no nos interesan sus caracteristicas, solo si existen en el dominio:


el sistema nos responde yes , es decir, si hay vehiculos.

vehiculo(X,_,_) (marcas de los vehiculos?) recordemos: X es la marca del auto, Y es el precio y Z es el color; en Y y Z escribimos guiones bajos porque solo nos interesa la marca:


el sistema nos muestra la primera marca, despues hay que presionar la tecla de punto y coma para listar las demas marcas, el sistema cierra la pregunta con un yes.

vehiculo(ford,Y,_). (precio del vehiculo ford?) En este caso especificamos la marca y escribirmos la Y para el precio, un guion bajo porque no nos interesa su color.


El sistema nos da la respuesta y cierra con un yes.

vehiculo(X,_,azul) (dime la marca del vehiculo azul, si este existe?) X para la marca, guion bajo porque no nos interesa el precio y especificamos el color:


Para terminar: vehiculo(X,Y,Z). (dame las caracteristicas de todos los vehiculos). Cubrimos todos los argumentos con variables para saber sus caracteristicas:


Una vez mas, nos mostrara el primer resultado, presionamos la tecla punto y coma para listar los demas.

Bueno, espero y les haya servido este mini-mini tutorial, y que haya sido lo mas explicito posible.

SALUDOS!!! ^_^

FUENTE: http://es.wikipedia.org/wiki/Prolog

LENGUAJES FUNCIONALES - Generalidades Haskell

Laboratorio de Lenguajes de Programación - Semana 6

Haskell es otro bello lenguaje funcional, sencillo pero difícil, les voy a mostrar algunas de las caracteristicas básicas de este lenguaje.

Primero instalemos el interprete que usaremos, tecleemos en la terminal:

sudo apt-get install hugs

Esto nos instalara el interprente Hugs para comenzar a usar Haskell, veremos una pantalla como esta:


Podemos usar Haskell como cualquiero otro lenguaje de programacion, es decir, una gran calculadora, podemos ingresar algunos calculos sencillos como 2+5, 5+10, 2^3, etc; o podemos usar algunas de las funciones predefinidas como div 10 2 que divide 10 entre 2:


Si deseamos escribir alguna función mas compleja tenemos que proceder a escribirla en un archivo de texto, guardarla con formato *.hs y despues interpretarla.
Les mostrare como escribir una funcion para calcular la secuencia Fibonacci ^_^

Abrimos el interprete emacs escribiendo en terminal emacs -nw fibo.hs

Lo padre de Haskell es que muchas funciones las podemos definir como su definicion matematica lo expresa:


regresemos a Emacs y comencemos a escribir:


Lo guardamos con el comando CTRL X + CTRL S y regresamos a la ventana de hugs donde cargaremos el archivo, para ello escribiremos la secuencia:

:load /home/usuario/ubicacion/archivo.hs

donde "ubicación" es la carpeta donde han guardado el código, y "archivo.hs" es el código con el nombre que ustedes hayan elegido; en mi caso escribire:

:load /home/juancarlos/fibo.hs , asi se vería en pantalla:


Ya solo restaría introducir el nombre de la función Fibonacci, en mi caso:

fib 10 para que el programa me muestre el número de la secuencia en la posición 10.

Resultado:


Este es solo un ejemplo de muchos que podemos realizar en Haskell, SALUDOS ^_^ !!

Fuentes:
http://es.wikipedia.org/wiki/Haskell
http://es.wikipedia.org/wiki/Sucesi%C3%B3n_de_Fibonacci

LISP - Factorial de un número

Laboratorio de Lenguajes de Programación - Semana 6

Continuamos analizando este bello lenguaje, ahora les traigo el siguiente código

Factorial de un número

Primero comenzamos por definir el nombre de la función:
(defun factorial...

Para calcular el factorial de un valor necesitamos una variable que almacene el valor:
...(N)...

Despues hay que definir las condiciones del cálculo, es decir un caso base:
...(if (= N 1) 1 ...

Por último escribimos la recursion:
...(* N (factorial (- N 1)))))

FUNCION COMPLETA: (defun factorial (N) (if (= N 1) 1 (* N (factorial (- N 1)))))

Aqui les muestro como debe quedar en la terminal, el cálculo corresponde al factorial de 6, 5, 4 y 3:



Saludos!!! ^_^

LISP - Potencia de un número

Laboratorio de Lenguajes de Programación - Semana 6

Vimos como escribir algunas funciones muy básicas en LISP, esta vez haremos algunas un poco mas complicadas, recuerden que hay que tener mucho cuidado con los espacios que pasamos ya que LISP es muy sensible a ello.

Potencia de un número

Primero el nombre de la función y las dos variables que necesitamos, una para la base y otra para el exponente:
(defun potencia (X Y)...

Despues establecemos las posibles causas que puedan marcarnos un error, es decir, si la base y el exponente son ceros:
...(cond ((and (= X 0)(= Y 0)) 'Error)...

Despues los casos base:
...((= X 0)0) ((= Y 0) 1)...

Por ultimo el bloque recursivo:
...(T(* X (potencia X (- Y 1))))))

FUNCIÓN COMPLETA: (defun potencia (X Y) (cond ((and (= X 0)(= Y 0)) 'Error) ((= X 0)0) ((= Y 0)1) (T(* X (potencia X (- Y 1))))))

Este es el resultado en la terminal, calculando la potencia de 2 elevado a la 5, y la potencia de 3 elevado a la 4:



SALUDOS ^_^ !

LENGUAJES FUNCIONALES - Generalidades LISP

Laboratorio de Lenguajes de Programación - Semana 6

Este lenguaje tiene la caracteristica de que toda su sintaxis va escrita entre parentesis por lo que hay que tener cuidado al ir escribiendo las funciones ya que seguro al final nos llevaremos mas de un parentesis abierto que habra que cerrar; además de que su escritura es de tipo prefija (operadores y/o condiciones por delante) ya que todo se maneja por medio de listas, de ahi su nombre: LISt Processing

Les voy a mostrar algunos ejemplos en este bello lenguaje.

Para comenzar tenemos que instalar en nuestro equipo algún interprete de LISP, yo instalé el llamado CLISP, para ello escribi en la terminal

sudo apt-get install clisp

para iniciarlo solo debemos escribir clisp en la terminal, veremos esta pantalla:


Vamos a lo básico, algunas operaciones aritméticas (cuidado con pasar espacios de mas o de menos):

Para sumare escribimos: (+ 20 75)
Resta: (- 100 30)
Multiplicación: (* 2 5 6)
División: (/ 60 3)

Vamos con algo mas complejo, lo bueno en lisp es la capacidad de crear funciones personalizadas que nos evitan mucho tiempo, dinero y esfuerzo puesto que las podremos utilizar mientras el interprete este abierto, esto se hace con la función (defun ...), hagamos algunas funciones sencillas:

Calcular el cuadrado de un número: (defun cuadrado (x) (* x x))

Función que regresa el triple de un valor: (defun triple (X) (* X 3))

El nombre de la funció es lo que escribamos despues de defun, la (X) es lo que la función recibira, el segundo parentesis ya es la operación que la función realizara con el valor recibido.

Estos son los resultados en la terminal:



SALUDOS ^_^ !!

LENGUAJES FUNCIONALES - Generalidades Scheme

Lenguajes de Programación - Semana 7 - Tarea 6

Scheme usa un dialecto parecido al de LISP, es decir, su notación es prefija, además de ofrecer la posibilidad de crear nuestras propias funciones para utilizarlas varias veces.

Lo primero que hay que hacer es instalar un interprete de Scheme, si que vamos a irnos directo a nuestra terminal y escribiremos el comando:

sudo apt-get install mit-scheme

Despues podemos inicializarlo escribiendo el comando: mit-scheme, asi se vera la terminal con el interprete ejecutandose:


Vamos a ver algunas generalidades de este lenguaje.

Primero, ya sabemos que toda su sintaxis es prefija, lo que en otros lenguajes es 2 + 5, en notación prefija sería es (+ 2 5), se puede decir que el operando es una función y 2, 5 son las variables que esta recibe.

EJEMPLOS:

(+ 1 2 3) = 6
(- 5.3 2) = 3.3
(- 5 2 1) = 2
(* 2 4 8) = 64
(/ 50 10) = 5


VARIABLES

Para declarar una variable global se utiliza la función

(define var val)

, donde var es el nombre de la variable y val es el valor asignado a dicha variable; por ejemplo:

(define x 5) esto es: x = 5
(define siete 7) esto es: siete = 7

Las variables declaradas bajo este método serán globales, es decir visibles durante todo el programa.

Para una variable local se utiliza la función

(let ((var val)) ... procesos ... ).

Se sigue la mism sintaxis que en la función define, solo que las variables serán locales al alcance de let.

FUNCIONES

Esta es una cualidad distintiva de Scheme, la definición de funciones personalizadas, claro que no es una cualidad única de este lenguaje ya que en cualquier otro tambien es posible hacerlo.
Para ello se utiliza la función

(defun (nombre_fun arg1 arg2) ... procesos ... )

, donde nom_fun es el nombre de nuestra función, y arg1 y arg2 son los argumentos que enviaremos a la función.

EJEMPLOS

Primero abrimos una nueva pestaña en la misma terminal o abrimos otra nueva, como sea, donde abriremos un documento en emacs con el nombre que queramos, pero con la terminación *.scm (extension del interprete Scheme), en mi caso escribiré emacs -nw areas.scm y tecleamos lo siguiente:

(define pi 3.14159)
(define (cuadrado x) (* x x))
(define (circulo x)(* pi x x ))
(define (triangulo x y) (/ (* x y) 2))
(define (rombo x y) (/ (* x y) 2))
(define (trapecio x y z) (/ (* (+ x y) z) 2))

Yo creo que no hace falta explicar mucho que hace este programita, son 5 formulas para calcular el área de las figuras geometricas detalladas en el código.

Guardamos los cambios y ahora vamos a cargar el archivo al interprete de Scheme, en la ventana de la terminal con el interprete Scheme tecelamos la ubicación del archivo que acabamos de escribir, en mi caso:

(load "/home/juancarlos/temp/areas.scm")

Se verá algo asi:


Ahora empezamos a probar cada una de las formulas que definimos, por si hay alguna duda les explico que realiza cada función:

(define pi 3.14159) : Se define el valor de Pi.
(define (cuadrado x) (* x x)) : Ecuación para calcular el área de un cuadrado, la función recibe un solo parámetro, la longitud de los lados y realiza el producto de los mismos.

(define (circulo x)(* pi x x )) : Ecuación para calcular el área de un circulo, la función recibe un solo parámetro, la longitud del radio, eleva su valor al cuadrado y lo multiplica por el valor de Pi.

(define (triangulo x y) (/ (* x y) 2)) : Ecuación para calcular el área de un triangulo, la función recibe dos parámetros, las longitudes de la base y la altura, los multiplica y divide el producto entre 2.

(define (rombo x y) (/ (* x y) 2)) : Ecuación para calcular el área de un rombo, la función recibe dos parámetros: las longitudes de la diagonal mayor y menos, las multiplica y divide su producto entre 2.

(define (trapecio x y z) (/ (* (+ x y) z) 2)) : Ecuación para calcular el área de un trapecio, la función recibe tres parámetros: las longitudes de las bases mayor y menor, y la altura; suma las bases las multiplica por la altura y divide todo el producto entre 2.

Asi se realiza la ejecución del programa:


SALUDOS!! ^_^

R - Matrices y determinantes

Lenguajes de Programación - Semana 7 - Tarea 6

R tiene la capacidad de manejar matrices de datos, vamos a realizar algunas operaciones con este tipo de dato:

Para comenzar abrimos nuestra terminal e iniciamos R, ya sabemos que para iniciarlo hay que escribir una "R" asi mayúscula en la línea de comandos.

Vamos a realizar un producto entre matrices, sabemos que para mutiplicar matrices el número de columnas de la primera debe coincidir con el numero de filas de la segunda o viceversa

Declaramos nuestras matrices, en este caso de 3 por 3 para obedecer la regla del producto de matrices:

escribimos en terminal: a <- matrix(c(-2, 1, -3, 1, 2, 3, 1, -2, -1) nrow=3, ncol=3)
declaramos otra matriz: b <- matrix(c(-1, 2, 3, -3, -2, 1, 3, -1, 2) nrow=3, ncol=3)

para ver las matrices solo escribimos el nombre de la matriz, ya sea a o b:



Para multiplicar la matriz solo escribimos a*b y el programa realizara el calculo

De la misma manera podemos sumar, restas o dividir las matrices

Para resolver la matriz por el método de determinantes solo escribimos la función det() y entre parentesis el nombre de la variable que contiene nuestra matriz, en este caso det(a)



SALUDOS A TODOS ^_^

R - Gráficas

Lenguajes de Programación - Semana 7 - Tarea 6

Función Curve()

La función curve() nos sirve en lenguaje R para generar gráficas de una función continua en un rango de valores, el ejemplo mas común son las funciones trigonométricas.

La sintaxis de la función es curve( expr, from, to) donde:

expr: es una expresión escrita en función de x
form... to... es el rango de valores en el cual la gráfica será dibujada

Vamos a ver algunos ejemplos de como Lenguaje R hace uso de esta función.

Comenzamos abriendo nuestra terminal e iniciamos el ambiente de programación R y escribimos la funcion curve, en este ejemplo la funci%oacute;n seno, que le daremos valores de 0 a 2pi radianes

curve (sin(x), form=0, to=2*pi)


RESULTADO:


Podemos probar con otras funciones trigonometricas (cos, tan, arsen, etc)

Para crear una gráfica sencilla hecha con nuestros propios datos, hay que crear 2 variables, en este ejemplo voy a graficar las calificaciones de un grupo de alumnos.
Primero creamos una variable alumno que almacenara cuantos alumnos graficaremos, en este caso de 0 a 100.

Escribimos en la terminal alumno <- 1:10

Ahora vamos a agregar una variable calificacion los valores de calificaciones de cada alumno:

escribimos calificacion <- c(9, 8, 7, 6, 8, 10, 10, 6, 7, 5)

y por ultimo graficamos los valores con la función plot(alumno, calificaciones, type="h", lwd=30, main="Calificaciones")


RESULTADO:

Espero y les sea de utilidad esta entrada...

SALUDOS ^_^!