Tag: universidade

Posted on

TALF Hoja 4 (16 de Marzo de 2010)

P1: Convierte el AFND de la hoja anterior en un autómata finito determinista. Incluye en tu solución la tabla de conversión tal como lo vimos en clase, la quintupla del AFD obtenido finalmente, y su grafo.

Partimos del siguiente AFND.

AFND BaseAñadimos el estado de Error.

AFND Base con estado de error

Comenzamos a crear la tabla de conversión

partimos del estado inicial {a}. con 0 vamos a {a} y con 1 a {a,b}

Tabla AFND AFD paso 1{a} ya pertenece al conjunto de estados, pero {a,b} no por lo tanto añadimos el estado {a,b}.

Tabla AFND AFD paso 2en el conjunto {a,b} con valor 0  a nos lleva a {a} y b nos lleva a {c,d} por lo tanto {a,b} con 0 nos lleva a {a,c,d} como {a,c,d} no esta en el conjunto de estados lo añadimos y añadimos las transiciones.

Tabla AFND AFD paso 3repetimos el procedimiento hasta que no se creen mas elementos para el conjunto de estados. quedándonos la siguiente tabla (a menos que me haya equivocado)

Tabla AFND AFD paso final

ahora pasamos la tabla a un grafo.

AFD sin estados finales ni inicialesLos primeros estados iniciales de nuestro AFND “con los que empezamos la tabla” son nuestros estados iniciales, en esta caso A.

AFD sin estados finales pero con inicialesTodo estado del AFD donde exista un estado final del AFND es final (en este caso todos donde este d)

AFD convertidoFinalmente la quintupla queda definida por:
M=(∑,Q,δ,q0,F)

siendo

  • ∑   El alfabeto
  • Q   Conjunto finito de estados
  • δ    la función de transición
  • q0 conjunto de estados iniciales
  • F    conjunto de estados finales
por lo tanto para este AFD la quintupla sera:
  • ∑   {0,1}
  • Q    [{a},{a,b},{a,c,d},{a,b,c},{a,d,error},{a,b,d,error},{a,b,c,d},{a,error},{a,b,error},{a,c,d,error},{a,b,c,error},{a,b,c,d,error}]
  • δ    es la tabla de transiciones
  • q0 {a}
  • F     [{a,c,d},{a,d,error},{a,b,d,error},{a,b,c,d},{a,c,d,error},{a,b,c,d,error}]
Posted on

Practica 1 Informática Gráfica ultimo ejercicio

El codigo aqui:

/*
* File:   main.c
* Author: luzem
*
* Created on 17 de marzo de 2010, 1:08
*/

#include <stdio.h>
#include <stdlib.h>
#include "GL/freeglut.h" //Alternativa a Glut.h
/******************************************************************/
/* Funcion de dibujado                                            */
/* Parametros: Ninguno                                            */
/* Salida: Ninguna                                                */
/******************************************************************/
void Dibuja(void) {
float altura = 1;
float base = -0.5f;
/* Establece el color de borrado */
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

/* Borra el buffer de color */
glClear(GL_COLOR_BUFFER_BIT);

/* Establece el color de dibujo */
glColor3f(1.0f, 1.0f, 1.0f);

/* Crea un poligono 2D (cuadrado) */
glBegin(GL_POLYGON);
glVertex2f(-0.5f, -0.5f);
glVertex2f(-0.5f, 0.5f);
glVertex2f(0.5f, 0.5f);
glVertex2f(0.5f, -0.5f);
glEnd();
int x;
for (x = 0; x < 5; x++) {
if (x % 2 == 0) {
//cuadrado par pintamos de negro
glColor3f(0, 0, 1);
} else {
//cuadrado impar pintamos de verde
glColor3f(0, 1, 0);
}
glBegin(GL_POLYGON);
glVertex2f(base, base);
glVertex2f(base, base + altura);
glVertex2f(base + altura, base + altura);
glVertex2f(base + altura, base);
glEnd();
altura = altura - 0.2;
base = base - 0.02;
}

/* Se asegura de que se ejecutan todas las ordenes */
glFlush();
}

/******************************************************************************************/
/* Establece el area visible                                                              */
/* Parametros: int ancho --> Ancho del area visible                                       */
/*             int alto --> Alto del area visible                                         */
/* Salida: Ninguna                                                                        */

/******************************************************************************************/
void TamanyoVentana(int ancho, int alto) {
glViewport(0, 0, ancho, alto);
}

/******************************************************************************************/
/* Inicia las propiedades de la vista                                                     */
/* Parametros: Ninguno                                                                    */
/* Salida: Ninguna                                                                        */

/******************************************************************************************/
void IniciaVista(void) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}

/******************************************************************************************/
/* Abre una ventana OpenGL                                                                */
/* Parametros: int numeroArgumentos --> El numero de argumentos en la llamada al programa */
/*             char ** listaArgumentos --> Vector de cadenas con cada argumento           */
/* Salida: Ninguna                                                                        */

/******************************************************************************************/
void AbreVentana(int numeroArgumentos, char ** listaArgumentos) {
glutInit(&numeroArgumentos, listaArgumentos);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
glutCreateWindow(listaArgumentos[0]);
glutDisplayFunc(Dibuja);
glutReshapeFunc(TamanyoVentana);
IniciaVista();
}

/******************************************************************************************/
/* Funcion principal                                                                      */
/* Parametros: int numeroArgumentos --> El numero de argumentos en la llamada al programa */
/*             char ** listaArgumentos --> 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) {
/* Crea la ventana de la aplicaci¢n */
AbreVentana(numArgumentos, listaArgumentos);

/* Establece el bucle principal de control de OpenGL */
glutMainLoop();

return (0);
}

El resto de la película en libreta de notas enjoy.

Posted on

Examen Calculo Esei Febrero 2006

Examen B Calculo

Escola Superior de

Enxeñeria Informatica Ourense (ESEI)

Profesor: Rosario Pereira

  1. Regla de L’Hopital: enunciado, demostración, comentarios.

  2. Comprobar que la ecuación examen calculo preg 2 tiene una raiz entre 1 y 2. Calcular el valor aprximado de esa raiz con error menos de 0,25.

  3. En la ecuación examen_calculo_febrero_esei_3, substituir la funcion arctan por una aproximación polinomica adecuada de grado 3 y resolver.

  4. Hallar las asintotas y ramas parabolicas de la curva dada por examen_calculo_febrero_esei_4

  5. Calcular si es posible

    a) examen_calculo_febrero_esei_5a

    b) examen_calculo_febrero_esei_5b

    c) examen_calculo_febrero_esei_5c

  6. Estudiar la convergencia de las series

    a)examen_calculo_febrero_esei_6a

    b)examen_calculo_febrero_esei_6b

    c)examen_calculo_febrero_esei_6c