Esempio n. 1
0
        static void Main()
        {
            /*Application.EnableVisualStyles();
             * Application.SetCompatibleTextRenderingDefault(false);
             * Application.Run(new Form1());
             */


            Automata nuevo = new Automata();
            Estado   S0    = new Estado(0);
            Estado   S1    = new Estado(1);
            Estado   S2    = new Estado(2);
            ////
            Trancisiones S0a = new Trancisiones();

            S0a.setInicio(S0);
            S0a.setFin(S1);
            S0a.setSimbolo("a");
            S0.setTransiciones(S0a);
            Trancisiones S0b = new Trancisiones();

            S0b.setInicio(S0);
            S0b.setFin(S0);
            S0b.setSimbolo("a");
            S0.setTransiciones(S0b);
            Trancisiones S0c = new Trancisiones();

            S0c.setInicio(S0);
            S0c.setFin(S1);
            S0c.setSimbolo("b");
            S0.setTransiciones(S0c);
            nuevo.addEstados(S0);
            /////
            Trancisiones S1a = new Trancisiones();

            S1a.setInicio(S1);
            S1a.setFin(S2);
            S1a.setSimbolo("a");
            S1.setTransiciones(S1a);
            Trancisiones S1b = new Trancisiones();

            S1b.setInicio(S1);
            S1b.setFin(S1);
            S1b.setSimbolo("b");
            S1.setTransiciones(S1b);
            Trancisiones S1c = new Trancisiones();

            S1c.setInicio(S1);
            S1c.setFin(S2);
            S1c.setSimbolo("b");
            S1.setTransiciones(S1c);
            nuevo.addEstados(S1);
            ///
            Trancisiones S2a = new Trancisiones();

            S2a.setInicio(S2);
            S2a.setFin(S1);
            S2a.setSimbolo("a");
            S2.setTransiciones(S2a);
            Trancisiones S2b = new Trancisiones();

            S2b.setInicio(S2);
            S2b.setFin(S0);
            S2b.setSimbolo("a");
            S2.setTransiciones(S2b);
            Trancisiones S2c = new Trancisiones();

            S2c.setInicio(S2);
            S2c.setFin(S2);
            S2c.setSimbolo("b");
            S2.setTransiciones(S2c);
            Trancisiones S2d = new Trancisiones();

            S2d.setInicio(S2);
            S2d.setFin(S1);
            S2d.setSimbolo(AnalizadorTexto.AnalizadorTexto.EPSILON);
            S2.setTransiciones(S2d);
            nuevo.addEstados(S2);
            ///
            nuevo.setEstadoInicial(S0);
            nuevo.addEstadosAceptacion(S2);
            Hashtable alfabeto = new Hashtable();

            alfabeto.Add("a", 13);
            alfabeto.Add("b", 22);
            alfabeto.Add(AnalizadorTexto.AnalizadorTexto.EPSILON, 18);
            nuevo.setAlfabeto(alfabeto);
            Transformador AFD      = new Transformador();
            AFD_GRAFICA   automata = (AFD_GRAFICA)AFD.minimizar(nuevo);

            automata.CreandoTabla();
            String tabla2 = "";


            ///er1 -> . {letra} *|{letra} |  {digito} "_";

            /*Thompson a = new Thompson();
             * LinkedList<DatoExpresion> n = new LinkedList<DatoExpresion>();
             * n.AddLast(new DatoExpresion("+", DatoExpresion.TipoExpresion.OPERADOR, "punto" + 1));
             * n.AddLast(new DatoExpresion("letra", DatoExpresion.TipoExpresion.CONJUNTOS, "letra" + 1));*/
            //n.AddLast(new DatoExpresion("digito", DatoExpresion.TipoExpresion.CONJUNTOS, "digito" + 1));

            /*n.AddLast(new DatoExpresion("|", DatoExpresion.TipoExpresion.OPERADOR, "or" + 1));
             * n.AddLast(new DatoExpresion("letra", DatoExpresion.TipoExpresion.CONJUNTOS, "letra" + 2));
             * n.AddLast(new DatoExpresion("|", DatoExpresion.TipoExpresion.OPERADOR, "or" + 2));
             * n.AddLast(new DatoExpresion("digito", DatoExpresion.TipoExpresion.CONJUNTOS, "digito" + 1));
             * n.AddLast(new DatoExpresion("_", DatoExpresion.TipoExpresion.CADENA, "cad" + 1));*/
            //a.Analizarentrada(n);
        }
Esempio n. 2
0
        /**
         * Conversion de un automata AFN a uno AFD por el
         * metodo de subconjuntos
         * @param afn AFN
         */
        public void conversionAFN(Automata afn)
        {
            //se crea una estructura vacia
            Automata automata = new Automata();
            //se utiliza una cola como la estructura para guardar los subconjuntos a analizar
            Queue <HashSet <Estado> > cola = new Queue <HashSet <Estado> >();
            //se crea un nuevo estado inicial
            Estado inicial = new Estado(0);

            automata.setEstadoInicial(inicial);
            automata.addEstados(inicial);


            //el algoritmo empieza con el e-Closure del estado inicial del AFN
            HashSet <Estado> array_inicial = simulador.eClosure(afn.getEstadoInicial());

            //si el primer e-closure contiene estados de aceptacion hay que agregarlo
            foreach (Estado aceptacion in afn.getEstadosAceptacion())
            {
                if (array_inicial.Contains(aceptacion))
                {
                    automata.addEstadosAceptacion(inicial);
                }
            }

            //lo agregamos a la pila
            cola.Enqueue(array_inicial);
            //variable temporal para guardar el resultado todos los subconjuntos creados
            LinkedList <HashSet <Estado> > temporal = new LinkedList <HashSet <Estado> >();
            //se utilizan esetos indices para saber el estado actuales y anterior
            int indexEstadoInicio = 0;

            while (!cola.Any())
            {
                //actual subconjunto
                HashSet <Estado> actual = cola.Dequeue();
                //se recorre el subconjunto con cada simbolo del alfabeto del AFN
                foreach (String simbolo in afn.getAlfabeto())
                {
                    //se realiza el move con el subconjunto
                    HashSet <Estado> move_result = simulador.move(actual, (String)simbolo);

                    HashSet <Estado> resultado = new HashSet <Estado>();
                    //e-Closure con cada estado del resultado del move y
                    //se guarda en un solo array (merge)
                    foreach (Estado e in move_result)
                    {
                        //resultado.Add(simulador.eClosure(e));
                    }

                    Estado anterior = (Estado)automata.getEstados().ElementAt(indexEstadoInicio);

                    /*Si el subconjunto ya fue creado una vez, solo se agregan
                     * transiciones al automata*/
                    if (temporal.Contains(resultado))
                    {
                        LinkedList <Estado> array_viejo = automata.getEstados();
                        Estado estado_viejo             = anterior;
                        //se busca el estado correspondiente y se le suma el offset
                        Estado       estado_siguiente = array_viejo.ElementAt(temporal.ElementAt(resultado.Count()).Count() + 1);
                        Trancisiones trancision       = new Trancisiones();
                        trancision.Transicion(estado_viejo, estado_siguiente, simbolo);
                        estado_viejo.setTransiciones(trancision);
                    }
                    //si el subconjunto no existe, se crea un nuevo estado
                    else
                    {
                        temporal.AddLast(resultado);
                        cola.Enqueue(resultado);

                        Estado       nuevo      = new Estado(temporal.ElementAt(resultado.Count()).Count() + 1);
                        Trancisiones transicion = new Trancisiones();
                        transicion.Transicion(anterior, nuevo, simbolo);
                        anterior.setTransiciones(transicion);
                        automata.addEstados(nuevo);
                        //se verifica si el estado tiene que ser de aceptacion
                        foreach (Estado aceptacion in afn.getEstadosAceptacion())
                        {
                            if (resultado.Contains(aceptacion))
                            {
                                automata.addEstadosAceptacion(nuevo);
                            }
                        }
                    }
                }
                indexEstadoInicio++;
            }

            this.afd = automata;
            //metodo para definir el alfabeto, se copia el del afn
            //definirAlfabeto(afn);
            this.afd.setTipo("AFD");
            Console.WriteLine(afd);
        }