Hoja 9 (27 de Abril de 2010)

P1: Minimiza el siguiente autómata finito determinista. El estado inicial es el estado a.

autómata no minimizado

autómata inicial

Paso 1: eliminamos estados no accesibles.

Un estado no accesible es un estado que no esta relacionado con el conjunto de estados al que pertenece el estado inicial o perteneciendo a este no tiene símbolos de entrada solo de salida. en este caso eliminamos el elemento i, al eliminar el estado i el estado d queda sin símbolos de entrada por lo tanto d tampoco es accesible.

estados no alcanzables eliminados

Paso 2: construimos la matriz de estados

matriz de estados

X/X ^a b *c e f g h
^a “” “” “” “” “” “” “”
b “” “” “” “” “” “” “”
*c “” “” “” “” “” “” “”
e “” “” “” “” “” “” “”
f “” “” “” “” “” “” “”
g “” “” “” “” “” “” “”
h “” “” “” “” “” “” “”

cada estado es equivalente entre si por lo tanto los descartamos de la misma forma que un triangular de la matriz

X/X ^a b *c e f g h
^a ~ “” “” “” “” “” “”
b ~ ~ “” “” “” “” “”
*c ~ ~ ~ “” “” “” “”
e ~ ~ ~ ~ “” “” “”
f ~ ~ ~ ~ ~ “” “”
g ~ ~ ~ ~ ~ ~ “”
h ~ ~ ~ ~ ~ ~ ~

un estado no final no va a ser equivalente a un estado no final por lo tanto marcamos las celdas donde se relacione un estado final y uno no final

X/X ^a b *c e f g h
^a ~ “” X “” “” “” “”
b ~ ~ X “” “” “” “”
*c ~ ~ ~ X X X X
e ~ ~ ~ ~ “” “” “”
f ~ ~ ~ ~ ~ “” “”
g ~ ~ ~ ~ ~ ~ “”
h ~ ~ ~ ~ ~ ~ ~

llegados a este punto comenzamos a emparejar los estados no marcados:

  • (a,b) X
    • con 0 vamos a (b,g) no esta marcado no hacemos nada
    • con 1 vamos a (f,c)  esta marcado por lo tanto marcamos (a,b)
  • (a,e) X
    • con 0 vamos a (b,h)  esta en la diagonal principal no hacemos nada
    • con 1 vamos a (f,f)   esta en la diagonal principal no hacemos nada
    • quedamos a la espera de lo que suceda cuando miremos (b,h)
  • (a,f) X
    • con 0 vamos a (b,c) como esta marcado marcamos (a,f)
    • con 1 vamos a (f,g) como no esta marcado no hacemos nada
  • (a,g) X
    • con 0 vamos a (b,g) como no esta marcado ni no comprobado esperamos a lo que suceda al comprobar (b,g)
    • con 1 vamos a (f,e) que no esta marcado no hacemos nada
  • (a,h) X
    • con 0 vamos a (b,c) como esta marcado marcamos (a,h)
    • 1 no lo miramos porque (a,h) ya se ha marcado
  • (b,e) X
    • con 0 vamos a (g,h) como no esta marcado no hacemos nada.
    • con 1 vamos a (c,f) como esta marcado marcamos (b,e)
  • (b,f) X
    • con 0 vamos a (g,c) como (c,g) esta marcado marcamos (b,f)
    • 1 no lo miramos porque (b,f) ya se ha marcado.
  • (b,g) X
    • con 0 vamos a (g,g) como esta en la diagonal principal no hacemos nada
    • con 1 vamos a (c,e) como esta marcado marcamos (b,g)
    • (a,g) estaba a la espera de (b,g) como (b,g) se ha marcado también marcaremos (a,g)
  • (b,h) X
    • con 0 vamos a (g,c) como (c,g) ya esta marcado marcamos (b,h)
    • 1 no lo miramos porque (b,h) ya se ha marcado
    • (a,e) estaba a la espera de (b,h) como lo hemos marcado marcamos también (a,e)
  • (e,f) X
    • con 0 vamos a (h,c)  como (c,h) esta marcado marcamos (e,f)
    • 1 no lo miramos porque (e,f) ya esta marcado
  • (e,g) X
    • con 0 vamos a (h,g) o (g,h) como no esta marcado ni comprobado esperamos a comprobar (g,h)
    • con 1 vamos a (f,e) o (e,f) como  esta marcado marcamos (e,g)
    • marcamos también (d,f) y (d,h) porque estaban a la espera de (e,g)
  • (e,h) X
    • con 0 vamos a (h,c) como (c,h) esta marcado marcamos (e,h)
    • 1 no lo miramos porque (e,h) ya se ha marcado
  • (f,g) X
    • con 0 vamos a (c,g) como ya esta marcado marcamos (f,g)
    • 1 no lo miramos porque ya hemos marcado (f,g)
  • (f,h)
    • con 0 vamos a (c,c) como esta en la diagonal principal lo obviamos
    • con 1 vamos a (g,g) como esta en la diagonal principal lo obviamos
  • (g,h) X
    • con 0 vamos a (g,c) como (c,g) esta marcado marcamos (g,h)
    • 1 no lo miramos porque ya hemos marcado (g,h)

Finalmete la matriz queda de la siguiente forma

X/X ^a b *c e f g h
^a ~ X X X X X X
b ~ ~ X X X X X
*c ~ ~ ~ X X X X
e ~ ~ ~ ~ X X X
f ~ ~ ~ ~ ~ X “”
g ~ ~ ~ ~ ~ ~ X
h ~ ~ ~ ~ ~ ~ ~

las casillas no marcadas indican estados equivalentes en este caso solo tenemos una casilla no marcada que es (f,h) que nos indica que f es equivalente a h quedando el autómata mínimo de esta forma:

autómata mínimo

nuestro autómata mínimo esta formado por 7 estados  para comprobar si la minimización  esta bien realizada minimizamos el automata original en JFlap y comparamos su equivalencia y el numero de estado del autómata mínimo generado, el automata minimo generado es el siguiente:

autómata mínimo jflapel numero de estados es el mismo el los dos autómatas y el lenguaje generado es equivalente  por lo que debería de estar bien

P2: Determina el Indice(RL) del lenguaje definido por una expresión regular sobre el alfabeto {a, b, c} que define todas las palabras que tengan por lo menos dos a’s consecutivas o por lo menos dos b’s consecutivas (mira hoja 6 si quieres).

Para saber el indice  (RL) de la expresión regular  tenemos que realizar el siguiente proceso de conversión
Expresión Regular –> AFND-ε –> AFND —> AFD —> AFD mínimo

la expresión regular es (a + b + c)∗ (aa + bb)(a + b + c)∗

el numero de estados del AFD minimo sera el indice del RL en caso que sea completo sino tenemos que sumarle 1 por el estado de error

Paso 1 Expresión Regular a AFND-ε:
Para realizar esta conversión nos basamos en los cinco casos básicos:

  • caso 1:para caso “A”Regla 1 expresión regular a AFND
  • regla 2:para caso  “epsilon”Regla 2 expresión regular a AFND
  • regla 3:para caso “AB”Regla 3 expresión regular a AFND
  • regla 4:para caso “A+B”Regla 4 expresión regular a AFND
  • regla 5:para caso “A*”Regla 5 expresión regular a AFND

Dividimos la expresión regular en los subconjuntos mínimos a generando un árbol de descomposición.

árbol derivación expresión regularempezamos a modelar desde el segundo nivel ya que el primero es muy sencillo

(a+b+c)*

(a+b+c)*

(aa+bb)

(aa+bb)

unimos los autómatas del segundo nivel y generaremos el automata que describe la expresión regular (a + b + c)∗ (aa + bb)(a + b + c)∗.

AFND from REGEXPcomparamos con el JFlap y son equivalentes por lo tanto este paso va bien, ahora eliminamos las transiciones epsilon.

AFND TO AFDY el AFD generado lo minimizamos

AFD Mínimocomo es completo el indice(RL) es igual a 4 , si no fuera completo habría que añadir el estado de error siendo el indice(RL) igual al numero de estados del AFD mínimo + el estado de error

Configuración de Sistemas Informáticos Practica 3. Control Remoto de Terminales

El objetivo de esta práctica es comprender y ver en la práctica el funcionamiento de las aplicaciones para el control remoto de equipos y visualizar el escritorio de otras máquinas. Para ello instalaremos un servidor VNC y repasaremos sus opciones de configuración. Posteriormente utilizaremos el visor de VNC para acceder a terminales que tengan instalado el servidor y comprobar su funcionamiento.

Cuestiones:

1. Especificar todas las opciones que tenemos a nuestra disposición cuando nos conectamos a un servidor VNC y explicar su efecto.

Opciones Clientes

  • Format and encoding
    • AutoSelect –> El cliente seleccionara las opciones automaticamente
    • Use 8-Bit colour –> Reduce la profundidad de color de las imágenes a enviar para reducir el ancho de banda necesario para el comportamiento fluido de la sesión
    • Algoritmos de compresion
      • ZRLE — Usa Run Length Enconding de la libreria zlib.
      • Hextile — separa rectangulos en grupos de 16×16 y los manda usando RLE.
      • CoRRE — Es una variante de RRE, usando rectangulos de 255×255 como máximo.
      • RRE — Rise and Run length encoding es una version 2D del RLE.
      • Raw — sin compresión.
  • Use CopyRect encoding — Es un algoritmo eficiente para cuando algo se mueve, los unicos datos que se envían es el movimiento de un rectángulo. También puede ser eficiente para un patrón repetido
  • Mouse:
    • Emulate 3 Buttons (with 2-buttion click): Emula el tercer botón del ratón
    • Swap mouse buttons 2 and 3 intercambia el 2 y 3 botón del ratón.
  • Display
    • View only (inputs ignored): No envia los eventos del teclado ni del ratón producidos por el cliente
    • Full-screen mode: Habilita el modo pantalla completa
    • Scale by : Nos que el cliente cree una ventana escalada de las imágenes que recibe del servidor
  • Miscelanea
    • Shared: No desconecta a otros clientes que esten conectados.
    • Deiconify on Bell: reproduce los mensajes de la campana del servidor en el cliente.
    • Disable clipboard transfer: inhabilita la interaccion de los portapapeles del cliente y del servidor.

2. Comentar los grupos y parámetros de los mismos en la configuración del servidor VNC.

  • Opciones servidorIncoming Conections:
    • Acept Socket Connection –> acepta conexiones a través de sockets (una ip, un protocolo y un puerto)
    • Password : la contraseña para autenticarse
    • Display Number: El numero de pantalla a mostrar.
    • Enable Java Viewer: Permite la posibilidad conectarse a través de un navegador usando un applet de Java
  • Connection Settings:
    • Disable Remote Keyboard & Pointer — Deshabilita teclado y ratón remoto
    • Disable Local Keyboard & Pointer — Deshabilitar el teclado y el ratón del servidor.
    • Remove Desktop Wallpaper — Cambia el color de fondo de escritorio por un fondo de un color liso para mejorar el rendimiento.
  • When last Client Disconnects: Opciones cuando el servidor queda sin clientes conectados
    • Do nothing: no hace nada.
    • Lock Workstation: bloquea el servidor solicitando la contraseña de usuario.
    • Logoff Workstation: el servidor cierra la sesión del usuario.
  • Update Handling — Manejo de las actualizaciones de pantalla
    • Poll Full Screen– Enviá la pantalla completa
    • Poll Foreground Window — Enviá la ventana seleccionada.
    • Poll Window Under Cursor — Enviá la ventana que esta bajo el cursor
    • Poll Console Windows Only– Con esta opción las únicas ventana que serán refrescadas son consolas de comandos.
    • Poll On, Event Received Only: Solo actualizara la pantalla inmediatamente después de que el cliente envié un evento de teclado o ratón.
  • Comandos Servidor:
    • Add New Client: permite crear una conexion con un cliente que este en modo escucha.
    • Register Vnc Server Service: crea un servicio en el ordenador servidor que arranca el servidor de VNC.
    • Run Service Helper: Crea el icono en la barra de tareas “en caso de arrancarlo como servicio”.
    • Show About Box: Muestra información sobre la versión actual de VNC.
    • Sow Default properties: Muestra las opciones predeterminadas del servidor.
    • Show User Properties: Muesta la información acerca de los usuarios conectados.
    • Unregister VNC Server Service: Elimina el servicio del servidor.

Practica 7 Conversiones Autómatas lenguajes regexp en JFlap

El enunciado de la practica aqui:Practica 7 TALF

1.-Encuentra el AFD mínimo que reconoce el lenguaje representado por la expresión regular (RegEx) siguiente (00+10*1+λ)*(1+00)

En JFlap escogemos la opción de expresión regular

1 1 expresion regularintroducimos la expresión regular en el cuadro de dialogo

1 2 expresion regular

seleccionamos la opción Convert to NFA del menu convert para convertir una expresión regular en un autómata finito no determinista lo que nos creara el siguiente AFND

1 3 autómata finito no deterministaConvertimos el AFND en un AFD usando  la opción “Convert to DFA” del menú Convert

1 4 automata finito deterministacomo ultimo paso debemos minimizar el autómata finito determinista la opción para realizar la minimización se encuentre en el menú Convert  en la opción minimize DFA

1 5 automata finito determinista minimo

2.-Encuentra el AFD mínimo que reconoce el lenguaje representado por la siguiente gramática, y comprueba si es equivalente al del ejercicio anterior

S → 0A
S → 1C
D → 1C
B → 0B
C → 1S
D → 0A
A → 0D
C → 0B
B → 1S
S →1
D→1
A→0

Introducimos la gramática en JFlap

1 Gramatica Introducida

Pinchamos en Convert –> Convert Right Lineal Grammar to FA nos aparece una ventana donde introducimos la siguiente secuencia Show all -> Done? –> Export

2 Conversion a FA

Aparece una nueva Ventana con el FA generado
3 FA Convertido

Seleccionamos el menu test -> compare equivalence –> seleccionamos el AFD minimo del apartado anterior

4 equivalencia

son equivalentes

3.-Encuentra una expresión regular y una gramática para el lenguaje reconocido por el autómata siguiente

1 automatapara convertir el autómata en una expresión regular seleccionamos la opción “convert FA to RE” del menú “convert” que nos obligara a añadir un estado final que no sea inicial quedando de la siguiente forma

autómata a expresión regular

pinchamos en el botón “Do It” hasta que realice todos los pasos necesarios para la conversión informándonos en este punto con un mensaje con el siguiente text “You’re done. Go away.”  momento en el que pincharemos en export que nos mostrara la expresión regular en una nueva ventana.

(b(ab)*+(a+b(ab)*(b+aa))(ba+(a+bb)(ab)*(b+aa))*(a+bb)(ab)*)*

(b(ab)*+(a+b(ab)*(b+aa))(ba+(a+bb)(ab)*(b+aa))*(a+bb)(ab)*)*

para convertir el autómata en una gramática en la ventana del autómata seleccionamos “Convert to Grammar” en el menú “Convert”   y presionamos repetidamente el botón “Hint” repetidas veces hasta que genere la gramática

conversión a gramática

una vez generada la gramática solo resta pulsar en el botón Export que abrirá una nueva ventana con la gramática

gramática

4.-Comprueba que el autómata anterior es equivalente a la siguiente Expresión Regular ((aa+b)(ba)*(a+bb+λ)+ab)*(aa+b)(ba)*+λ

JFlap no puede compara equivalencia entre expresiones regulares por lo tanto debemos transformar la expresión regular en un autómata para eso creamos una nueva expresión regular en JFlap

expresión regular

una vez insertada la expresión regular  seleccionamos la opción “Convert to NFA”  del menú “Convert”

regexp to AFN

Una vez generado el AFND solo necesitamos comprobar la equivalencia en el menú “Test” -> “Compare Equivalence” que nos dirá que son equivalentes, en este caso son equivalentes

AFN

Hoja 8 (20 de Abril de 2010)

P1: Sea C = {a,b,c,d,e,f,g,h} un conjunto (de letras), y sea R = {(a, d), (b, e), (c, a), (d, b), (e, c), (f, g), (g, h)} ⊂ C × C una relación sobre C.

  • Construye las relaciones Ri para todos los i = 0, . . . , ∞.
    • R0 ={(a,a),(b,b),(c,c),(d,d),(e,e),(f,f),(g,g),(h,h)}   (Las relaciones de todos los elementos consigo mismo)
    • R1={(a,d),(b,e),(c,a),(d,b),(e,c),(f,g),(g,h)} (La relación que nos dan)
      • (a,d) de R1  y (d,b) de R1 generan (a,b).
      • (b,e) de R1 y (e,c) de R1 generan (b,c).
      • (c,a) de R1 y (a,d) de R1 generan (c,d).
      • (d,b) de R1 y (b,e) de R1 generan (d,e).
      • (e,c) de R1 y (c,a) de R1 generan (e,a).
      • (f,g) de R1 y (g,h) de R1 generan (f,h).
      • (g,h) de R1 no genera nada.
    • R2={(a,b),(b,c),(c,d),(d,e),(e,a),(f,h)} <–( la unión de las relaciones generadas en R1)
      • (a,b) de R2 y (b,e) de R1  generan (a,e).
      • (b,c) de R2 y (c,a) de R1 generan (b,a).
      • (c,d) de R2 y (d,b) de R1 generan (c,b).
      • (d,e) de R2 y (e,c) de R1 generan (d,c).
      • (e,a) de R2 y (a,d) de R1 generan (e,d).
      • (f,h) de R2  no genera nada
    • R3={(a,e),(b,a),(c,b),(d,c),(e,d)} <– ( la unión de las relaciones generadas en R2)
      • (a,e) de R3 y (e,c) de R1 generan (a,c).
      • (b,a) de R3 y (a,d) de R1 generan (b,d).
      • (c,b) de R3 y (b,e) de R1 generan (c,e).
      • (d,c) de R3 y (c,a) de R1 generan (d,a).
      • (e,d) de R3 y (d,b) de R1 generan (e,b).
    • R4={(a,c),(b,d),(c,e),(d,a),(e,b)} <– (la unión de las relaciones generadas en R3)
      • (a,c) de R4 y (c,a) de R1 generan (a,a).
      • (b,d) de R4 y (d,b) de R1 generan (b,b).
      • (c,e) de R4 y (e,c) de R1 generan (c,c).
      • (d,a) de R4 y (a,d) de R1 generan (d,d).
      • (e,b) de R4 y (b,e) de R1 generan (e,e).
    • R5={(a,a),(b,b),(c,c),(d,d),(e,e)} <– (la unión de las relaciones generadas en R4)
      • (a,a) de R5 y (a,d) de R1 generan (a,d).
      • (b,b) de R5 y (b,e) de R1 generan (b,e).
      • (c,c) de R5 y (c,a) de R1 generan (c,a).
      • (d,d) de R5 y (d,b) de R1 generan (d,b).
      • (e,e) de R5 y (e,c) de R1 generan (e,c).
    • R6={(a,d),(b,e),(c,a),(d,b),(e,c)} <– (la unión de las relaciones generadas en R5)
      • (a,d) de R6  y (d,b) de R1 generan (a,b).
      • (b,e) de R6 y (e,c) de R1 generan (b,c).
      • (c,a) de R6 y (a,d) de R1 generan (c,d).
      • (d,b) de R6 y (b,e) de R1 generan (d,e).
      • (e,c) de R6 y (c,a) de R1 generan (e,a).
    • R7={(a,b),(b,c),(c,d),(d,e),(e,a)} <– (la unión de las relaciones generadas en R6)
      • (a,b) de R7 y (b,e) de R1  generan (a,e).
      • (b,c) de R7 y (c,a) de R1 generan (b,a).
      • (c,d) de R7 y (d,b) de R1 generan (c,b).
      • (d,e) de R7 y (e,c) de R1 generan (d,c).
      • (e,a) de R7 y (a,d) de R1 generan (e,d).
    • R8={(a,e),(b,a),(c,b),(d,c),(e,d)} ==R3 <– (la unión de las relaciones generadas en R7)
    • R9==R4
    • R10=R5
    • R11=R6
    • R12=R7
    • R13=R3
    • Rn=  R (n-3) mod 5+3
  • Construye la relación R∗.

Basta con unir todas las relaciones hasta R5 ( a partir de R7 el resto estarán repetidas y R5,R6 y R7 son subconjuntos)

R*={(a,a),(b,b),(c,c),(d,d),(e,e),(f,f),(g,g),(h,h),(a,d),(b,e),(c,a),(d,b),(e,c),(f,g),(g,h),(a,b),(b,c),(c,d),(d,e),(e,a),(f,h),(a,e),(b,a),(c,b),(d,c),(e,d),(a,c),(b,d),(c,e),(d,a),(e,b)}

  • Argumenta si R∗ es reflexiva, simétrica , y/o transitiva.
    • Reflexiva: Si porque todo elemento estan relacionados consigo mismo al pertenecer R0 a R*.
    • Simétrica:
      • (a,d) y (d,a) V
      • (b,e) y (e,b) V
      • (c,a) y (a,c) V
      • (d,b) y (b,d) V
      • (e,c) y (c,e) V
      • (f,g) no existe (g,f) F
      • (g,h) no existe (h,g) F
      • (a,b) y (b,a) V
      • (b,c) y (c,b) V
      • (c,d) y (d,c) V
      • (d,e) y (e,d) V
      • (e,a) y (a,e) V
      • (f,h) no existe (h,f) F
    • Transitiva: Si, porque hemos relacionado todas los pares entre si
  • ¿Cuál pareja (o parejas) deberíamos añadir a la relación R para que R∗ sea simétrica (si piensas que R∗ no es simétrica en el apartado anterior)?
    • (g,f), (h,g) y (h,f)

Hoja 7 (13 de Abril de 2010)

P1: Determina una expresión regular α que define el mismo lenguaje aceptado por el autómata de la Hoja 5, digamos M , es decir, se tiene que cumplir L(α) = L(M ). Documenta tu construcción suficientemente (tienes dos lados de una hoja).

partimos del autómata de la hoja 5

Automata Inicialpara transformar nuestro AFND en una expresión regular necesitamos crear un AFNDG que este cumpla una serie de caracteristicas:

  1. El estado inicial no puede tener transiciones entrantes.
  2. El estado inicial debe de contar con transiciones salientes a los otros estados.
  3. Solo puede existir un estado final.
  4. El estado final no puede tener transiciones salientes.
  5. El estado final tiene que recibir transiciones entrantes de los otros.
  6. Excepto los estados inicial y final, cada estado tiene una única transición a los otros estados.

Transformando un AFND a un AFNDG

  1. Añadimos un nuevo estado inicial s con una transición epsilon  al viejo estado inicial.
  2. Añadimos un nuevo estado final f con transiciones epsilon entrantes de los viejos estados finales.
  3. Si dos estados están conectados con múltiples transiciones, las reemplazamos por una única transición en la que su etiqueta es la unión de las etiquetas reemplazadas.
  4. Si dos estados no están conectados, añadimos una transición etiquetada con ∅ entre ellos (en ambas direcciones).
  • Las transiciones ∅ nunca serán usadas.

Empezamos la transformación.

Paso 1:

AFND a AFNDG paso 1Paso 2:

AFND a AFNDG paso 2

Paso 3:

No existen multiples transiciones que conecten 2 estados nuestro automata sigue como esta.

Paso 4:

Vamos a dejar las transiciones ∅ sin poner.

De AFNDG a Expresión Regular

Para convertir un AFNDG con k estados en una expresión regular:

  1. Si k=2, solo tenemos los estados f y s. La etiqueta de la transición de s a f es la expresión regular equivalente al AFNDG
  2. Si k>2 , entonces construimos un AFNDG con k-1 estados.
    1. a) Escogemos un estado distinto de s y f.
    2. b) Eliminamos el estado seleccionado del autómata
    3. c) Reconectamos las transiciones sueltas de forma apropiada.
      1. Para cada par de estados, qi y qj, cambiamos la etiqueta de la transición por una que pueda tomar el AFNDG desde qi a qj de forma directa o a través del estado que estamos seleccionado

Comenzamos eliminando el estado marcado como 1

  • no tiene transiciones consigo mismo
  • las transiciones entrantes provienen  del estado  {s}
  • las transiciones salientes se dirigen a los estados {2,6}

por lo tanto debemos crear los transiciones {s,2} y {s,6}

  • la transición {s,2} es ε
  • la transición {s,6} es a

las modelamos en el automata

Estado 1 eliminado

no tenemos transiciones que tengan el mismo origen y destino continuamos

Eliminamos el estado marcado como 2:

  • tiene transiciones consigo mismo.
  • las transiciones entrantes provienen del conjunto de estados {s}
  • las transiciones salientes se dirigen a los estados {3,f}

por lo tanto tenemos que generar las transiciones {s,3} y {s,f}, como hay transición consigo mismo debemos ingresar (b)* en el medio

  • la transición {s,3} es (b)*.a
  • la transición {s,f} es (b)*

tras la eliminación del estado 2 nuestro autómata toma la siguiente forma

no tenemos transiciones que tengan el mismo origen y destino continuamos

Eliminamos el estado marcado como 3

  • no tiene transiciones consigo mismo
  • las transiciones entrantes provienen de {s,4,5}
  • las transiciones salientes se dirigen a {4,6}

por lo tanto debemos generar las transiciones {s,4},{s,6},{4,4},{4,6},{5,4},{5,6}

  • la transición {s,4} genera (b)*.aa
  • la transición {s,6} genera (b)*.a
  • la transición {4,4} genera b.a
  • la transición {4,6} genera b
  • la transición {5,4} genera a.a
  • la transición {5,6} genera a

tras la eliminación del estado 3 nuestro autómata toma la siguiente forma.

Estado 3 eliminado

tenemos transiciones con mismo origen y destino, {s,6} las unimos y nuestro autómata toma la siguiente forma

Estado 3 eliminado y transiciones

Eliminamos el estado marcado como 4

  • tiene transiciones consigo mismo
  • las transiciones entrantes provienen de {s,5,6}
  • las transiciones salientes se dirigen a{5,6,f}

por lo tanto debemos generar las transiciones {s,5},{s,6},{s,f},{5,5},{5,6},{5,f},{6,5},{6,6},{6,f} como 4 tiene transición consigo mismo tenemos que insertar (ba)* en el medio

  • la transición {s,5} genera (b)*aa(ba)*b
  • la transición {s,6} genera (b)*aa(ba)*b
  • la transición {s,f} genera (b)*aa(ba)*
  • la transición {5,5} genera aa(ba)*b
  • la transición {5,6} genera aa(ba)*b
  • la transición {5,f} genera aa(ba)*
  • la transición {6,5} genera (ba)*b
  • la transición {6,6} genera (ba)*b
  • la transición {6,f} genera  (ba)*

tras la eliminación del estado 4 nuestro autómata toma la siguiente forma.

Estado 4 eliminado

tenemos transiciones con el mismo origen y destino las unimos y nuestro autómata queda así

Estado 4 eliminado y transiciones

Eliminamos el estado marcado como 5

  • tiene transiciones consigo mismo
  • las transiciones entrantes provienen de {s,6}
  • Las transiciones salientes se dirigen  a {f,6}

las transiciones que debemos de crear son {s,f},{s,6},{6,f},{6,6} como  tiene transiciones consigo mismo debemos insertar (aa(ba)*b)* en medio

  • la transición {s,f} genera  (b)*aa(ba)*b(aa(ba)*b)*aa(ba)*
  • la transición {s,6} genera (b)*aa(ba)*b(aa(ba)*b)* (a+(aa((ba)*b)))
  • la transición {6,f} genera  (b+((ba)*b))(aa(ba)*b)*aa(ba)*
  • la transición {6,6} genera (b+((ba)*b))(aa(ba)*b)*(a+(aa((ba)*b)))

tras la eliminación del estado 5 nuestro autómata toma la siguiente forma

Estado 5 eliminadotenemos transiciones con el mismo origen y destino así que las unimos

la transición {s,6} quedara ((b)*aa(ba)*b(aa(ba)*b)*(a+(aa((ba)*b)))+((a+((b)*a))+(b)*aa(ba)*b)) ==s6

la transición {s,f} quedara (((b)*aa(ba)*b(aa(ba)*b)*aa(ba)*)+((b)*+(b)*aa(ba)*)) == sf

la transicion {6,6} quedara (((b+((ba)*b))(aa(ba)*b)*(a+(aa((ba)*b))))+((ba)*b)) == 66

la transición {6,f} quedara (((b+((ba)*b))(aa(ba)*b)*aa(ba)*)+((ba)*)) == 6f

Eliminamos el estado marcado como 6

  • tiene transiciones consigo mismo.
  • las transiciones entrantes provienen de {s}
  • las transiciones salientes se dirigen a {f}

por lo tanto deberemos de generar las transiciones {s,f} teniendo el cuenta como existe transición consigo mismo tenemos que insertar (66)* en medio

la transición {s,f} genera (sf)+((s6)(66)*(6f))

tras la eliminación del estado 6 nuestro autómata ya es la expresión regular.

((((b)*aa(ba)*b(aa(ba)*b)*aa(ba)*)+((b)*+(b)*aa(ba)*)))+((((b)*aa(ba)*b(aa(ba)*b)*(a+(aa((ba)*b)))+((a+((b)*a))+(b)*aa(ba)*b)))((((b+((ba)*b))(aa(ba)*b)*(a+(aa((ba)*b))))+((ba)*b)))*((((b+((ba)*b))(aa(ba)*b)*aa(ba)*)+((ba)*))))

introducimos a expresión regular en JFlap la transformamos es un AFND y comparamos la equivalencia con el AFNDG y………………………

Good Luck bad nigth

vamos que esta bien 🙂 a la 2ª fue la vencida

Fuentes:

http://vega.icu.ac.kr/~jiae/Automata_spring2008/DFA2RE.pdf

Practica 2: FTP

El objetivo de esta práctica es comprender y ver en la práctica el funcionamiento de las aplicaciones para la transferencia de archivos. Para ello instalaremos un servidor FTP y repasaremos las opciones más importantes para habilitar este servicio en una máquina.
Posteriormente utilizaremos un cliente FTP para realizar una conexión desde otro equipo y comprobar todos los cambios que realizamos en las opciones, así como para poder ver los informes de actividad del servidor cuando se transfieren archivos.

El servidor FTP que utilizaremos para llevar a cabo esta práctica será Serv-U, y como clientes podremos utilizar SmartFTP, WS-FTP,…

Cuestiones básicas:

1. ¿como podemos activar el servidor FTP como un servicio? ¿qué significa?

Tenemos dos formas de activar el servidor FTP como servicio.

La primera es durante la instalación del software marcando la casilla “Install Serv-U as a system service” como se ve en la imagen

Activar como servicio durante la instalaciónLa otra opción en caso de no marcarlo durante la instalación es crearlo nosotros a mano usando Sc.exe siguiendo las instrucciones del articulo 251192 de Microsoft.

Ejecutar un programa como servicio significa que  este es cargado por el sistema operativo y se ejecuta en segundo plano (Background) .

2. ¿que es una cuenta de usuario anónima? ¿cómo la creamos?

La cuenta de usuario anónima es una cuenta en un servidor FTP que permite a cualquier usuario el acceso al mismo y obtener un conjunto de archivos previamente decidido por los administradores del servidor. La mayoria de los servidores no implementan cuentas anónimas pero algunos servidores que sirven ficheros que deberian estar disponibles para la descarga publica (parches o nuevas versiones) deberian de contar con una cuenta anonima para los usuarios.

Para crear esta cuenta debemos acceder a la consola de administración de Serv-U

Consola de gestión de Serv-Upinchamos en la opción “Users” o “Global Users”

Asistente creacion usuariosseleccionamos la opción “Wizard…” mostrara un asistente de 4 pasos para crear un nuevo usuario.

Asistente usuarios Serv-U paso 1 de 4como nombre de usuario introducimos Anonymous la contraseña la dejamos en blanco, seleccionamos el directorio deseado y los permisos que queremos otorgarle (se recomienda que los usuarios anónimos solo tengan permisos para leer y listar directorios).

3. ¿cuáles son los datos básicos cuando se crea una cuenta de usuario? comenta a nivel general las distintas opciones, permisos, ….

Cuando se crea un usuario se nos muestra un formulario dividido en siete pestañas

  • Formulario creación usuario Serv-UUser Information
    • User Name: Establece el nombre de usuario
    • Full Name: Almacena el nombre completo del usuario
    • Password: Define la contraseña para el usuario que estamos creando
    • Password Type: Define el algoritmo de encriptación para el paso de contraseñas
    • Administration Privilege:  Permite otorgar diferentes privilegios de administración
    • Home Directory:  Define el directorio donde los usuarios trabajaran por defecto
    • Account Type: permite define la volatilidad de la cuenta, pudiendo ser deshabilitada o eliminada en una fecha concreta
    • Default Web Client: Define el comportamiento del servidor para conexiones a través del protocolo http
    • Lock User in Home Directory: nos permite enjaular al usuario en su directorio home solo pudiendo acceder a este
    • Alwais Allow Login: Nos permite ignorar las restricciones del grupo, muy útil si se necesita acceder desde un entorno restringido
    • Enable account: Activa la cuenta
    • Description: Una pequeña descripción de la cuenta.
  • Groups
    • Nos permite añadir el usuario a distintos grupos
  • Welcome Message
    • Nos permite crear un mensaje cuando el usuario se autentifica, una advertencia, notas sobre el funcionamiento….
  • IP Access
    • Nos permite generar reglas para configurar un pequeño cortafuegos permitiendo o denegando conexiones desde ciertos rangos de ip o ip’s
  • Directory Access
    • especifica los directorios a los que tendrá acceso el usuario y las reglas de acceso que se le otorgaran al usuario.
  • Virtual Paths
    • Las rutas virtuales nos permiten crear enlaces simbólicos a directorios que se encuentran fuera de la carpeta home del usuario.
  • Limits & Settings
    • Nos permite aplicar un conjunto de restricciones a la cuenta de ese usuario y horarios de funcionamiento de estas, las restricciones se catalogan en 5 subgrupos
      • Connection: Restricciones para las conexiones que realice el usuario
      • Password: Restricciones para la contraseña del usuario
      • Directory Listing: Restricciones relativas a la navegación del usuario a lo largo del árbol de directorios del servidor
      • Data Transfer: Restricciones acerca de la velocidad de transferencia del usuario
      • Advanced: Restricciones avanzadas

4. ¿qué es el directorio de recepción o “home directory”?
Es el directorio dentro del árbol de directorios a donde se envía el usuario tras su identificación, generalmente en el directorio de recepción es donde el usuario puede subir sus archivos.

5. ¿cómo puedo realizar un acceso a un sitio FTP a través del navegador?

Depende de si lo soporta el navegador.

Si existe ese soporte bastaría con  que poner en la barra de direcciones:
ftp://usuario@ftp.servidor.es (se preguntará la contraseña)
o directamente:
ftp://usuario:passwd@ftp.servidor.es
o de forma anónima (siempre que el servidor lo permita):
ftp://ftp.servidor.es
donde usuario es el nombre de usuario de la cuenta, passwd es la contraseña y ftp.servidor.es es el servidor FTP.

6. ¿qué significa bloquear (“lock”) el directorio de recepción?

Esta opción enjaula al usuario dentro de su directorio de recepción impidiéndole acceder a cualquier otro directorio que este en un nivel igual o superior del directorio de recepción.

7. ¿qué privilegios podemos asignar a los usuarios?

Podemos asignar distintos tipos de privilegios a los usuarios:

Los privilegios administrativos (que nos permiten gestionar el servidor)

  • Sin privilegios:  El usuario no tiene privilegios
  • Administrador de Dominios: Permite administrar el dominio
  • Administrador de Sistema: Los permisos del usuario son de administrador
  • Inherentes: Hereda los permisos del grupo al que pertenece

Los privilegios de Acceso a archivos y directorios.

  • Read : Acceso de lectura a ficheros y directorios
  • Write: Acceso de escritura a ficheros y directorios
  • Rename: Permite renombrar alchivos
  • Delete: Permiso de borrado para ficheros y directorios
  • Execute: Permiso de ejecución para ficheros (Riesgo potencial)
  • Append: Permite añadir contenido al final del fichero

8. ¿a que hace referencia el “Max. No. Of Users” en la configuración de un “dominio FTP”? ¿y en la configuración del usuario?
Dominio FTP: Numero máximo de usuarios conectados simultaneamente

Usuario:  Numero máximo de conexiones concurrentes con ese nombre usuario

9. ¿qué son las reglas de acceso IP? ¿desde dónde las puedo establecer? Pon algún ejemplo.
Las reglas de acceso IP nos permite crear listas blancas y listas negras para gestionar las restricciones de acceso para el servidor.

Se pueden estableces en las opciones de configuración de usuarios, grupos de usuarios, usuarios globales , grupos globales, detalles del dominio y detalles del servidor.

Por ejemplo si nuestro servidor cuenta con dos interfaces de red conectadas a la red 10.0.0.0/24 la primera y a la red 172.16.0.0/16 la segunda podríamos impedir a un usuario determinado (genera una cantidad de trafico no soportada por la infraestructura de esa red) el acceso desde la red 10.0.0.0/24

10. ¿puedo configurar los mensajes del servidor? ¿cuáles? ¿dónde?

Se pueden configurar los mensajes de bienvenida para los usuarios o grupos en la pestaña de opciones del usuario o grupo de usuarios en la pestaña Wellcome Messagge.

11. Interpreta la salida que muestra la actividad del servidor

La actividad del servidor muestra tres pestañas.

  • Sessions: Muestra las sesiones que se están produciendo en el servidor ftp en tiempo real
  • Statistics: Muestra un histórico de la actividad del servidor
  • Log: Muestra errores , información del inicio de la ejecución y mensajes globales

12. ¿puedo desactivar a un usuario del servicio? Si existe una manera automática, ¿en qué parámetros de basa?

Si, simplemente desmarcando la checkbox “Enable account ” en la pestaña “User Information” en el formulario “user properties”.

Podemos automatizar esta acción en la sección de propiedades del usuario, en la opción “account type” estableciendo una fecha de caducidad para esa cuenta

Practica 6 Talf

El enunciado aquí Practica 6 Talf

1.-Minimiza el autómata A1 = ({0,1},{q0, q1, q2, q3, q4}, f, q0,{q1, q2}) en donde f se define como:

  • f(q0, 0) = q3
  • f(q0, 1) = q2
  • f(q1, 0) = q4
  • f(q1, 1) = q1
  • f(q2, 0) = q0
  • f(q2, 1) = q3
  • f(q3, 0) = q0
  • f(q3, 1) = q2
  • f(q4, 0) = q4
  • f(q4, 1) = q1

modelamos el autómata en JFlap

modelado automata ejercicio 1para minimizarlo vamos al menu “Convert”->”minimize DFA”

minimizando paso 1obviamente los estados q1 y q4 quedan fuera porque no están asociados al grafo del estado inicial.

Pinchamos en el botón “Finish”

minimizado paso 2pinchamos en “complete” y en “done?” por lo que se mostrara el autómata minimizado en una nueva ventana

afd minimo

2. Indica cuáles de los siguientes autómatas son equivalentes entre sí:

  • AF1={{a,b},{p,q,r,s,t,u}, f1, p, {q,r}}
  • AF2={{a,b},{p,q,r,s,t,u}, f2, p, {u}}
  • AF3={{a,b},{p,q,r,s,t,u}, f3, p, {s,t,u}}
  • AF4={{a,b},{p,q,r,s,t,u}, f4, p, {r,s}}
  • AF5={{a,b},{p,q,r,s,t}, f5, p, {r,s}}

Autómata 1

F1 a b
p q p
q r s
r q t
s t u
t s u
u q u

modelamos el autómata en JFlap

automata 1

autómata 2

F2 a b
p q u
q r t
r s t
s r t
t u s
u u q

modelamos el autómata en JFlap

automata 2

autómata 3

F3 a b
p u q
q t r
r s r
s t r
t u q
u s p

modelamos el autómata en JFlap

automata 3

autómata 4

F4 a b
p r q
q r q
r s t
s r t
t t q
u u p

modelamos el autómata en JFlap

automata 4

autómata 5

F5 a b
p q r
q q t
r s q
s r q
t r q

modelamos el autómata en JFlap

automata 5

En la ventana de JFlap donde esta contenido el aútomata pintamos en “Test -> Compare Equivalence” y nos dice si es equivalente o no.

de la comprobación sacamos la siguiente tabla

@ AF1 AF2 AF3 AF4 AF5
AF1 F F V F
AF2 F F V
AF3 F F
AF4 F
AF5

Por lo tanto los autómatas equivalentes son AF1 con AF4 y AF2 con AF5

Mi examen practico de TALF

Recién sacadito del horno.

1º Ejercicio:

Obtener las trazas para las siguientes palabras en este autómata :

automata examenLas palabras de las que se deben obtener las trazas son:

  • aabbaabb: Acepta la palabra, Genera 3 trazas.
  • aaabbbaaa: No acepta la palabra.

2º Ejercicio: Crea un AFND que acepte los números binarios en los que la tercera cifra por la derecha sea diferenta a la segunda por la izquierda.

Resuelto aquí con muchas mas soluciones de otros modelos de examen.

Que tengáis mucha suerte.

Informática Gráfica PRÁCTICA 4. Transformaciones geométricas.

EJERCICIOS

Inicialmente debes construir un nuevo proyecto (practica4). Una vez creado, copia en el directorio de trabajo los ficheros examinar.c, examinar.h y la librería creada en la práctica anterior glig.c con su fichero prototipo glig.h. Añádelos al proyecto (por supuesto, acuérdate de añadir también las librerías glu32.lib, glut.lib y opengl32.lib).

1. Para la realización de esta práctica vas a necesitar una nueva primitiva que dibuje un cono. Añádela a tu librería glig.c.

void igWireCone (int pu, int pv); /* s1= 2.0, s2= 1.0, uMax= 1.0, vMax= 0.5 */

2. Utiliza las primitivas de la librería glig.c, para construir un abeto como el de la figura, sin utilizar las funciones glPushMatrix() y glPopMatrix(). Para ello crea una display list como en el ejemplo e introduce en su definición el código necesario para dibujar el abeto:

void CreaAbeto (void)

{

abeto = glGenLists (1);

if (abeto != 0) /* Cero no es un identificador valido para una display list */

{

glNewList (abeto, GL_COMPILE);

/* Código para dibujar el abeto */

glEndList ();

}

}

Los pasos a seguir para dibujar el abeto son:

  1. Dibuja el primer cono con los siguientes factores de escala: Sx=0.75 Sy=1.0 Sz=0.75.
  2. A continuación, dibuja dos nuevos conos aplicando los mismos factores de escala y trasladándolos sobre el eje Y, Tx=0.0 Ty=0.25 Tz= 0.0.
  3. Finalmente, dibuja el tronco llamando a la función igWireRulo(int pu, int pv).

Desde la función principal (main) debes llamar una única vez a CreaAbeto(). Para dibujar el abeto como una display list, llama desde la función Dibuja() a:
glCallList (abeto);

3. Construye el mismo abeto pero mediante el uso de las funciones  glPushMatrix() y glPopMatrix(). Es decir, haz que cada primitiva tenga sus transformaciones propias y que estas no afecten a las otras primitivas. Declara una nueva display list (abetoPush) y crea la display list para dibujar el abeto con las funciones glPush() y glPop() y llámala CreaAbetoPush().Comprueba que los dos abetos son iguales dibujando uno sobre otro con distintos colores.

4. Utilizando las primitivas de la librería glig.c, construye una display list para una escalera de caracol (escalera). Introduce el código en la función CreaEscalera(). Los pasos son los siguientes:

  1. Dibuja una caja a modo de eje de la escalera de altura=2.0 y lado= 0.2
  2. Realiza un bucle para dibujar cada uno de los escalones. Los escalones están escalados con factores de escala, Sx=0.5 Sy= 0.05 Sz=0.1. La separación entre escalones es de 0.2.

5. Realiza la construcción de la figura (lo más parecida posible) de acuerdo con los siguientes pasos:

  1. En primer lugar define una función Arco() que construya un arco individual (con tres cajas)
  2. Utiliza ese elemento para realizar la construcción circular.

modelado abetomodelado abeto pushmodelado escaleramodelado patioexaminar.c


/*************************************************************************/
/*                                                                       */
/*   examinar.c                                                          */
/*   Rev. 2.0  01/01/2002   AUTORES: O. Belmonte, M. Chover, J. Ribelles */
/*                                                                       */
/*************************************************************************/

/***************** INCLUDES DE LAS LIBRERIAS NECESARIAS ******************/
#include &lt;GL/glut.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &quot;examinar.h&quot;
#include &quot;glig.h&quot;

/******************************************************************************************/
/* Establece el area visible y el tipo de proyeccion                                      */
/* Parametros: int ancho --&gt; Ancho del area visible                                       */
/*             int alto --&gt; Alto del area visible                                         */
/* Salida: Ninguna                                                                        */
/******************************************************************************************/
void TamanyoVentana (GLsizei ancho, GLsizei alto)
{
 /* Definicion del viewport */
 glViewport(0, 0, ancho, alto);

 /* Definicion de la vista */
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 glOrtho(-2.0, 2.0, -2.0*(GLfloat)alto/(GLfloat)ancho, 2.0*(GLdouble)alto/(GLfloat)ancho, -2.0, 2.0);
}

/******************************************************************************************/
/* Abre una ventana OpenGL                                                                */
/* Parametros: int numeroArgumentos --&gt; El numero de argumentos en la llamada al programa */
/*             char ** listaArgumentos --&gt; Vector de cadenas con cada argumento           */
/* Salida: Ninguna                                                                        */
/******************************************************************************************/
void AbreVentana (int numeroArgumentos, char ** listaArgumentos)
{
 glutInit(&amp;numeroArgumentos, listaArgumentos);
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
 glutInitWindowSize (VentanaAncho, VentanaAlto);
 glutInitWindowPosition (VentanaX, VentanaY);
 glutCreateWindow (listaArgumentos[0]);
 glutDisplayFunc (Dibuja);
 glutReshapeFunc (TamanyoVentana);
 glClearColor (0.0f, 0.0f, 0.0f, 0.0f); /* Establece el color de borrado */
 glClear (GL_COLOR_BUFFER_BIT); /* Borra el buffer de color */
 glColor3f (1.0f, 1.0f, 1.0f); /* Establece el color de dibujo */
}

/******************************************************************************************/
/* Define las acciones tras una pulsacion del teclado                                     */
/* Parametros: unsigned char key --&gt; Codigo de la tecla pulsada                           */
/*             int x --&gt; Coordenada x del cursor en el momento de pulsar la tecla         */
/*             int y --&gt; Coordenada y del cursor en el momento de pulsar la tecla         */
/* Salida: Ninguna                                                                        */
/******************************************************************************************/
void Teclado (unsigned char tecla, int x, int y)
{
 switch (tecla)
 {
 case 27 : /* Codigo de la tecla de Escape */
 exit(0);
 break;
 }
}

/******************************************************************************************/
/* Define las acciones tras una pulsacion del teclado ampliado                            */
/* Parametros: unsigned char key --&gt; Codigo de la tecla pulsada                           */
/*             int x --&gt; Coordenada x del cursor en el momento de pulsar la tecla         */
/*             int y --&gt; Coordenada y del cursor en el momento de pulsar la tecla         */
/* Salida: Ninguna                                                                        */
/******************************************************************************************/
void TecladoAmpliado (int tecla, int x, int y)
{
 switch (tecla)
 {
 case GLUT_KEY_UP : /* Pulsacion cursor arriba del teclado ampliado */
 beta = beta + 15.0;
 if (beta &gt; 360.0) beta = beta - 360.0;
 break;

 case GLUT_KEY_DOWN : /* Pulsacion cursor abajo del teclado ampliado */
 beta = beta - 15.0;
 if (beta &lt; 0.0) beta = beta + 360.0;
 break;

 case GLUT_KEY_RIGHT : /* Pulsacion cursor derecha del teclado ampliado */
 alfa = alfa + 15.0;
 if (alfa &gt; 360.0) alfa = alfa - 360.0;
 break;

 case GLUT_KEY_LEFT : /* Pulsacion cursor izquierda del teclado ampliado */
 alfa = alfa - 15.0;
 if (alfa &lt; 0.0) alfa = alfa + 360.0;
 break;
 }
 glutPostRedisplay ();
}

/* Rutina de definiciÛn de eventos */
/******************************************************************************************/
/* Inicia las funciones de callback                                                       */
/* Parametros: Ninguno                                                                    */
/* Salida: Ninguna                                                                        */
/******************************************************************************************/
void IniciaFuncionesCallback (void)
{
 glutKeyboardFunc (Teclado);
 glutSpecialFunc (TecladoAmpliado);
}

/******************************************************************************************/
/* Funcion de dibujado                                                                    */
/* Parametros: Ninguno                                                                    */
/* Salida: Ninguna                                                                        */
/******************************************************************************************/
void Dibuja (void)
{
 glClear (GL_COLOR_BUFFER_BIT);

 /* Transformacion de la camara */
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 glRotated (beta, 1.0,0.0,0.0);
 glRotated (-alfa, 0.0,1.0,0.0);

 glCallList (cuadrica);
 glCallList(abetoPush);
 glCallList (abeto);
 glCallList(escalera);
 glCallList(patio);

 /* Objetos */
 //glutWireTeapot(1.0);
 //glutWireIcosahedron();
 //glutWireTetrahedron();
 //glutWireOctahedron();
 //glutWireDodecahedron();
 //glutWireTorus(0.2,0.9,18,20);
 //glutWireCone(0.5, 2.0, 14, 14);
 //glutWireCube(1.0);
 //glutWireSphere(1, 20,50);

 //igCreateQuadricObject(50,80,0,0,1.0, 1, 1);
 //igWireSphere (50, 50);

 //igWireRulo (200, 200);
 //igWireDado (60, 60);
 //igWireSemiSphere (50, 50); // s1 y s2 a 1, uMax= 1, vMax= 0.5 */
 //igWireCubo();
 glFlush();
}

void IniciaCuadricas (void)
{
 cuadrica = glGenLists (1);
 escalera=glGenLists(1);
 abeto=glGenLists(1);
 abetoPush=glGenLists(1);
 patio=glGenLists(1);

 if (cuadrica != 0) /* Cero no es un identificador valido para una display list */
 {
 //glNewList (cuadrica, GL_COMPILE);
 //igCreateQuadricObject (20,20,0,0,1.0f, 1.0f, 1.0f);
 //igWireCubo();
 //igWireRulo(20, 20);
 //igWireCone(10,3);
 //igWireSphere(30, 30);
 //glEndList ();
 printf(&quot;Cuadratica\n&quot;);
 }
 if (escalera!=0)
 {
 //CreaEscalera();
 printf(&quot;Escalera\n&quot;);
 }
 if (abeto!=0)
 {
 //CreaAbeto();
 printf(&quot;Abeto\n&quot;);
 }
 if (abetoPush!=0)
 {
 glNewList(abetoPush, GL_COMPILE);
 //CreaAbetoPush();
 glEndList();
 printf(&quot;AbetoPush\n&quot;);
 }
 if (patio!=0)
 {

 CreaPatio();
 printf(&quot;patio\n&quot;);
 }

}

/******************************************************************************************/
/* Funcion principal                                                                      */
/* Parametros: int numeroArgumentos --&gt; El numero de argumentos en la llamada al programa */
/*             char ** listaArgumentos --&gt; Vector de cadenas con cada argumento           */
/* Salida: Un entero que se devuelve al sistema al acabar la ejecucion del programa       */
/******************************************************************************************/
int main(int numArgumentos, char ** listaArgumentos)
{

 /* CreaciÛn de la ventana de la aplicaciÛn */
 AbreVentana (numArgumentos, listaArgumentos);

 /* Rutinas para el control de eventos */
 IniciaFuncionesCallback ();
 IniciaCuadricas();
 /* A la espera de eventos.... */
 glutMainLoop();
 return (0);
}

glig.c


/*************************************************************************/
/*                                                                       */
/*                 glig.c LIBRERIA DE MODELADO GEOMETRICO                 */
/*                                                                       */
/*   Rev. 2.0  01/01/2002   AUTORES: O. Belmonte, M. Chover, J. Ribelles */
/*                                                                       */
/*************************************************************************/

/***************** INCLUDES DE LAS LIBRERIAS NECESARIAS ******************/
#include &lt;GL/glut.h&gt;
#include &lt;math.h&gt;
#include &lt;stdio.h&gt;
#include &quot;glig.h&quot;

#define PI 3.1415926535897932
#define ALFA (0.5-v)*PI
#define BETA 2*PI*u

/************************* FUNCIONES BASICAS **********************************************/
/******************************************************************************************/
/* Devuelve la coordenada x de un punto en R3 a partir de un punto (u,v)                  */
/*   de un espacio parametrico en R2                                                      */
/* Parametros: float u --&gt; Primera coordenada de un punto en R2                           */
/*             float v --&gt; Segunda coordenada de un punto en R2                           */
/*             float R --&gt; Radio de la esfera envolvente                                  */
/*             float s1 --&gt; Numero de divisiones en u                                     */
/*             float s2 --&gt; Numero de divisiones en v                                     */
/* Salida: La coordenada x de un punto en R3                                              */
/******************************************************************************************/
float xSuperQuadric (float u, float v, float R, float s1, float s2)
{
 float cosalfa, cosbeta, powcosalfa, powcosbeta;

 cosalfa = (float)cos(ALFA);
 cosbeta = (float)cos(BETA);

 if(cosalfa &gt; 0.0)
 powcosalfa = (float)pow(cosalfa,s1);
 else
 powcosalfa =(float) - pow(- cosalfa,s1);

 if(cosbeta &gt; 0.0)
 powcosbeta = (float)pow(cosbeta,s2);
 else
 powcosbeta = (float) - pow(- cosbeta,s2);

 return (R*powcosalfa*powcosbeta);

}

/******************************************************************************************/
/* Devuelve la coordenada y de un punto en R3 a partir de un punto (u,v)                  */
/*   de un espacio parametrico en R2                                                      */
/* Parametros: float u --&gt; Primera coordenada de un punto en R2                           */
/*             float v --&gt; Segunda coordenada de un punto en R2                           */
/*             float R --&gt; Radio de la esfera envolvente                                  */
/*             float s1 --&gt; Numero de divisiones en u                                     */
/*             float s2 --&gt; Numero de divisiones en v                                     */
/* Salida: La coordenada y de un punto en R3                                              */
/******************************************************************************************/
float ySuperQuadric (float u, float v, float R, float s1, float s2)
{
 float sinalfa, powsinalfa;

 sinalfa = (float)sin(ALFA);

 if(sinalfa &gt; 0.0)
 powsinalfa = (float)pow(sinalfa,s1);
 else
 powsinalfa = (float)- pow(- sinalfa,s1);

 return (R*powsinalfa);
}

/******************************************************************************************/
/* Devuelve la coordenada de un punto en R3 a partir de un punto (u,v)                    */
/*   de un espacio parametrico en R2                                                      */
/* Parametros: float u --&gt; Primera coordenada de un punto en R2                           */
/*             float v --&gt; Segunda coordenada de un punto en R2                           */
/*             float R --&gt; Radio de la esfera envolvente                                  */
/*             float s1 --&gt; Numero de divisiones en u                                     */
/*             float s2 --&gt; Numero de divisiones en v                                     */
/* Salida: La coordenada z de un punto en R3                                              */
/******************************************************************************************/
float zSuperQuadric(float u, float v, float R, float s1, float s2)
{
 float cosalfa, sinbeta, powcosalfa, powsinbeta;

 cosalfa = (float)cos(ALFA);
 sinbeta=(float)sin(BETA);

 if(cosalfa &gt; 0.0)
 powcosalfa = (float)pow(cosalfa,s1);
 else
 powcosalfa=(float) - pow(- cosalfa,s1);

 if(sinbeta &gt; 0.0)
 powsinbeta = (float)pow(sinbeta,s2);
 else
 powsinbeta = (float) - pow(- sinbeta,s2);

 return(R*powcosalfa*powsinbeta);
}

/********************** RUTINA DE DIBUJO *********************************/

void igCreateQuadricObject (int pu, int pv, float uMax, float vMax, float R, float s1, float s2)
{
 /* pu es el numero de divisiones en u */
 /* pv es el numero de divisiones en v*/
 float u, v;
 float iniu,iniv;
 float inc_u; //incremento de u
 float inc_v; //incremento de v
 float x, y, z; /*almanezaran las coordenadas en el espacio tridimensional*/
 int   i,j;/*contadores para los bucles for*/
 v= uMax;
 u =vMax;
 iniu=u;
 iniv=v;
 /*El maximo valor de u y v es 1 y el minimo es 0 por lo tanto debemos de distribuir
 las partes exigidas en la distancia establecida entre el valor de inicialización y
 el maximo valor*/
 inc_u= (1.0f-u)/pu;
 inc_v= (1.0f-v)/pv;

 //Dibujamos los paralelos de la esfera
 //tantas circunfencias como partes de v
 for (j=0;j&lt;pv;j++)
 {
 glBegin (GL_LINE_LOOP);//Indicamos a openGL el modo de dibujado
 //indicamos los puntos (partes de u) que formaran la circunferencia
 for (i= 0; i&lt;= pu; i++)
 {
 x= xSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada x del punto
 y= ySuperQuadric (u, v, R, s1, s2);//indicamos la coordenada y del punto
 z= zSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada z del punto
 glVertex3f (x, y, z); //pintamos el punto en el espacio tridimensional
 u= u+ inc_u;//avanzamos hasta el siguiente putno
 //printf(&quot;valor de v=%f valor de u=%f\n&quot;,v,u);
 if (u&gt;1){u=iniu;}
 }
 glEnd();//indicamos a openGL que hemos acabado de indicar los puntos de la circunferencia

 v+=inc_v;//avanzamos a la siguiente circunferencia paralela
 }

 u=iniu;
 v=iniv;
 //Dibujamos os meridianos de la esfera
 //tantos meridianos como partes de v
 for (j=0;j&lt;pu;j++)
 {
 glBegin(GL_LINE_STRIP);//Indicamos a OpenGL el modo de dibujado
 //Indicamos los puntos (partes de v) que formaran el meridiano
 v=iniv;
 for(i=0;i&lt;=pv;i++)
 {
 x= xSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada x del punto
 y= ySuperQuadric (u, v, R, s1, s2);//indicamos la coordenada y del punto
 z= zSuperQuadric (u, v, R, s1, s2);//indicamos la coordenada z del punto
 glVertex3f (x, y, z); //pintamos el punto en el espacio tridimensional
 v+=inc_v;//avanzamos hasta el siguiente punto

 //printf(&quot;valor de v=%f valor de u=%f\n&quot;,v,u);
 }
 //printf(&quot;Meridiano dibujado\n\n&quot;);
 glEnd();//Indicamos a openGL que ya hemos señalado los puntos del meridiano
 u+=inc_u;//avanzamos al siguiente meridiano

 }
}

void igWireSphere (int pu, int pv)
{
 /* s1 y s2 a 1 */
 igCreateQuadricObject(pu,pv,0,0,1.0, 1, 1);

}

void igWireRulo (int pu, int pv)
{
 /* s1= 0.5, s2= 1 */
 igCreateQuadricObject(pu,pv,0,0,1.0, 0.5, 1);

}

void igWireDado (int pu, int pv)
{
 /* s1= 0.5, s2 =0.5 */
 igCreateQuadricObject(pu,pv,0,0,1.0, 0.5, 0.5);

}
void igWireSemiSphere (int pu, int pv)
{

 /* s1 y s2 a 1, uMax= 1, vMax= 0.5 */
 igCreateQuadricObject(pu,pv,0,0.5,1.0, 1, 1);

}

void igWireCubo (void)
{
 //Centramos en el origen de las coordenadas
 //El radio es 1
 glBegin (GL_LINE_LOOP);
 //aristas traseras
 glVertex3f(-0.5,-0.5,-0.5);
 glVertex3f(0.5, -0.5, -0.5);
 glVertex3f(0.5,0.5,-0.5);
 glVertex3f(-0.5,0.5,-0.5);
 glVertex3f(-0.5,-0.5,-0.5);
 //parte delantera
 glVertex3f(-0.5,-0.5,0.5);
 glVertex3f(-0.5,0.5,0.5);
 glVertex3f(0.5,0.5,0.5);
 glVertex3f(0.5,-0.5,0.5);
 glVertex3f(-0.5,-0.5,0.5);
 //lado izquierdo
 glVertex3f(-0.5,-0.5,-0.5);
 glVertex3f(-0.5,-0.5,0.5);
 glVertex3f(-0.5,0.5,0.5);
 glVertex3f(-0.5,0.5,-0.5);
 glVertex3f(0.5,0.5,-0.5);
 glVertex3f(0.5,0.5,0.5);
 glVertex3f(0.5,-0.5,0.5);
 glVertex3f(0.5,-0.5,-0.5);
 glEnd ();
}

void igWireCone (int pu, int pv)
{
/* s1= 2.0, s2= 1.0, uMax= 1.0, vMax= 0.5 */
 igCreateQuadricObject(pu, pv, 0.5, 0, 1, 2.0, 1.0);
}

void CreaAbetoPush(void)
 {
 //abetoPush= glGenLists(1);
 if (abetoPush != 0)
 {
 glNewList( abetoPush, GL_COMPILE);
 glColor3f(1,0,0);

 glPushMatrix();
 glRotated(180,0,0,1);
 glScalef(0.75, 1, 0.75);
 igWireCone(20, 20);
 glPopMatrix();

 glPushMatrix();
 glTranslatef(0,0.25, 0);
 glRotated(180,0,0,1);
 glScalef(0.75, 1, 0.75);
 glScalef(0.75, 1, 0.75);
 igWireCone(20, 20);
 glPopMatrix();

 glPushMatrix();
 glTranslatef(0, 0.5, 0);
 glRotated(180,0,0,1);
 glScalef(0.75, 1, 0.75);
 glScalef(0.75, 1, 0.75);
 glScalef(0.75, 1, 0.75);
 igWireCone(20, 20);
 glPopMatrix();

 glPushMatrix();
 glRotated(180,0,0,1);
 glScalef(0.75, 1, 0.75);
 glScalef(0.75, 1, 0.75);
 glScalef(0.75, 1, 0.75);
 glScalef(0.5, 1, 0.5);
 igWireRulo(15, 5);
 glPopMatrix();

 glEndList();
 }
 else
 {
 printf(&quot;Error al crear abetoPush\n&quot;);
 }

 }

void CreaAbeto (void)
{
 //abeto = glGenLists (1);
 if (abeto != 0) /* Cero no es un identificador valido para una display list */
 {
 glNewList (abeto, GL_COMPILE);
 /* Código para dibujar el abeto */
 /*Sx=0.75 Sy=1.0 Sz=0.75*/
 glColor3f(0,1,0);
 glRotated(180,0,0,1);
 glScalef(0.75,1,0.75);
 igWireCone(20, 20);
 glScalef(0.75,1,0.75);
 glTranslatef(0,-0.25,0);
 igWireCone(20, 20);
 glScalef(0.75,1,0.75);
 glTranslatef(0,-0.25,0);
 igWireCone(20, 20);
 glTranslatef(0, 0.5, 0);
 glScalef(0.5, 1, 0.5);
 igWireRulo(15, 5);
 glEndList ();
 }
}
void CreaEscalera(void)
 {
 int x;
 glNewList(escalera, GL_COMPILE);
 printf(&quot;mierda\n&quot;);
 //# Dibuja una caja a modo de eje de la escalera de altura=2.0 y lado= 0.2
 escalon();
 for(x=0;x&lt;100;x++)
 {
 glPushMatrix();
 glRotated(90,1,0,0);
 //Sx=0.5 Sy= 0.05 Sz=0.1
 glScalef(0.5, 0.5, 0.1);

 glTranslatef(0,  0,-x*(0.2));
 glRotated((360/50)*x,0,0,1);
 escalon();
 glPopMatrix();
 }
 glEndList();

 }

void escalon(void)
 {
 glBegin (GL_LINE_LOOP);
 //base
 glVertex3f(-0.1,0,-0.1);
 glVertex3f(0.1,0,-0.1);
 glVertex3f(0.1,0,0.1);
 glVertex3f(-0.1,0,0.1);
 glVertex3f(-0.1,0,-0.1);
 //subimos
 glVertex3f(-0.1,2,-0.1);
 glVertex3f(0.1,2,-0.1);
 //bajamos y subimos
 glVertex3f(0.1,0,-0.1);
 glVertex3f(0.1,2,-0.1);
 glVertex3f(0.1,2,0.1);
 //bajamos y subimos
 glVertex3f(0.1,0,0.1);
 glVertex3f(0.1,2,0.1);
 glVertex3f(-0.1,2,0.1);
 //bajamos y subimos
 glVertex3f(-0.1,0,0.1);
 glVertex3f(-0.1,2,0.1);
 glVertex3f(-0.1,2,-0.1);
 glEnd();
 }

void CreaPatio(void)
 {
 int x;

 glNewList( patio , GL_COMPILE);
 for(x=0;x&lt;12;x++)
 {
 glPushMatrix();
 glScalef(0.2, 0.2, 0.2);
 glRotated(30*x, 0, 1, 0);
 glTranslatef(0, 0, -4);
 arco();
 glPopMatrix();
 }
 glEndList();
 }

void arco(void)
 {
 glPushMatrix();
 //glColor3f(1, 0, 0);//rojo
 glTranslatef(-0.75, 0, 0);
 columna();
 glPopMatrix();
 glPushMatrix();
 //glColor3f(0, 1, 0);//verde
 glTranslatef(0.75, 0, 0);
 columna();
 glPopMatrix();
 glPushMatrix();
 //glColor3f(0, 0, 1);//azul
 glRotated(270, 0, 0, 1);
 glTranslatef(-1.75, -1, 0);
 columna();
 glPopMatrix();
 }

void columna(void)
 {
 glBegin (GL_LINE_LOOP);
 //base
 glVertex3f(-0.25,0,-0.25);
 glVertex3f(0.25,0,-0.25);
 glVertex3f(0.25,0,0.25);
 glVertex3f(-0.25,0,0.25);
 glVertex3f(-0.25,0,-0.25);
 //subimos
 glVertex3f(-0.25,2,-0.25);
 glVertex3f(0.25,2,-0.25);
 //bajamos y subimos
 glVertex3f(0.25,0,-0.25);
 glVertex3f(0.25,2,-0.25);
 glVertex3f(0.25,2,0.25);
 //bajamos y subimos
 glVertex3f(0.25,0,0.25);
 glVertex3f(0.25,2,0.25);
 glVertex3f(-0.25,2,0.25);
 //bajamos y subimos
 glVertex3f(-0.25,0,0.25);
 glVertex3f(-0.25,2,0.25);
 glVertex3f(-0.25,2,-0.25);

 glEnd();
 }