public Automata Omision(Automata automatafd, String simbolo)
        {
            Automata afd_kleene = new Automata();

            //se crea un nuevo estado inicial
            Estado nuevoInicio = automatafd.getEstadoInicial();

            afd_kleene.addEstados(nuevoInicio);
            afd_kleene.setEstadoInicial(nuevoInicio);

            //Se crea un nuevo estado de aceptacion
            Estado nuevoFin = new Estado(automatafd.getEstados().Count() + 1);

            afd_kleene.addEstados(nuevoFin);
            afd_kleene.addEstadosAceptacion(nuevoFin);

            //definir estados clave para realizar la cerraduras
            Estado anteriorInicio = automatafd.getEstadoInicial();

            List <Estado> anteriorFin = automatafd.getEstadosAceptacion();

            // agregar transiciones desde el nuevo estado inicial
            nuevoInicio.getTransiciones().Add(new Transicion(nuevoInicio, anteriorInicio, simbolo));
            nuevoInicio.getTransiciones().Add(new Transicion(nuevoInicio, nuevoFin, simbolo));

            // agregar transiciones desde el anterior estado final
            for (int i = 0; i < anteriorFin.Count(); i++)
            {
                //anteriorFin.ElementAt(i).getTransiciones().Add(new Transicion(anteriorFin.ElementAt(i), anteriorInicio, Form1.EPSILON));
                anteriorFin.ElementAt(i).getTransiciones().Add(new Transicion(anteriorFin.ElementAt(i), nuevoFin, simbolo));
            }
            afd_kleene.setAlfabeto(automatafd.getAlfabeto());
            afd_kleene.setLenguajeR(automatafd.getLenguajeR());
            return(afd_kleene);
        }
        public Automata concatenacion(Automata afd1, Automata afd2, String simbolo)
        {
            Automata afd_concat = new Automata();

            //se utiliza como contador para los estados del nuevo automata
            int i = 0;

            //agregar los estados del primer automata
            for (i = 0; i < afd2.getEstados().Count(); i++)
            {
                Estado tmp = (Estado)afd2.getEstados().ElementAt(i);
                tmp.setId(i);
                //se define el estado inicial
                if (i == 0)
                {
                    afd_concat.setEstadoInicial(tmp);
                }
                //cuando llega al último, concatena el ultimo con el primero del otro automata con un epsilon
                if (i == afd2.getEstados().Count() - 1)
                {
                    //se utiliza un ciclo porque los estados de aceptacion son un array
                    for (int k = 0; k < afd2.getEstadosAceptacion().Count(); k++)
                    {
                        tmp.setTransiciones(new Transicion((Estado)afd2.getEstadosAceptacion().ElementAt(k), afd1.getEstadoInicial(), simbolo));
                    }
                }
                afd_concat.addEstados(tmp);
            }
            //termina de agregar los estados y transiciones del segundo automata
            for (int j = 0; j < afd1.getEstados().Count(); j++)
            {
                Estado tmp = (Estado)afd1.getEstados().ElementAt(j);
                tmp.setId(i);

                //define el ultimo con estado de aceptacion
                if (afd1.getEstados().Count() - 1 == j)
                {
                    afd_concat.addEstadosAceptacion(tmp);
                }
                afd_concat.addEstados(tmp);
                i++;
            }

            HashSet <object> alfabeto = new HashSet <object>();

            alfabeto.Add(afd1.getAlfabeto());
            alfabeto.Add(afd2.getAlfabeto());
            afd_concat.setAlfabeto(alfabeto);
            afd_concat.setLenguajeR(afd1.getLenguajeR() + " " + afd2.getLenguajeR());

            return(afd_concat);
        }
        public Automata afdSimple(string simboloRegex)
        {
            Automata automatafd = new Automata();
            //definir los nuevos estados
            Estado inicial = new Estado(0);

            //Estado aceptacion = new Estado(0);
            //crear una transicion unica con el simbolo
            //Transicion tran = new Transicion(inicial, aceptacion, simboloRegex);
            //inicial.setTransiciones(tran);
            //agrega los estados creados
            automatafd.addEstados(inicial);
            //automatafd.addEstados(aceptacion);
            //colocar los estados iniciales y de aceptacion
            automatafd.setEstadoInicial(inicial);
            //automatafd.addEstadosAceptacion(aceptacion);
            automatafd.setLenguajeR(simboloRegex + "");
            return(automatafd);
        }
        public Automata UnoaMuchos(Automata automataFN)
        {
            Automata afn_kleene = new Automata();

            //se crea un nuevo estado inicial
            Estado nuevoInicio = new Estado(0);

            afn_kleene.addEstados(nuevoInicio);
            afn_kleene.setEstadoInicial(nuevoInicio);

            //agregar todos los estados intermedio
            for (int i = 0; i < automataFN.getEstados().Count(); i++)
            {
                Estado tmp = (Estado)automataFN.getEstados().ElementAt(i);
                tmp.setId(i + 1);
                afn_kleene.addEstados(tmp);
            }

            //Se crea un nuevo estado de aceptacion
            Estado nuevoFin = new Estado(automataFN.getEstados().Count() + 1);

            afn_kleene.addEstados(nuevoFin);
            afn_kleene.addEstadosAceptacion(nuevoFin);

            //definir estados clave para realizar la cerraduras
            Estado anteriorInicio = automataFN.getEstadoInicial();

            List <Estado> anteriorFin = automataFN.getEstadosAceptacion();

            // agregar transiciones desde el nuevo estado inicial
            nuevoInicio.getTransiciones().Add(new Transicion(nuevoInicio, anteriorInicio, Form1.EPSILON));
            //nuevoInicio.getTransiciones().Add(new Transicion(nuevoInicio, nuevoFin, Form1.EPSILON));

            // agregar transiciones desde el anterior estado final
            for (int i = 0; i < anteriorFin.Count(); i++)
            {
                anteriorFin.ElementAt(i).getTransiciones().Add(new Transicion(anteriorFin.ElementAt(i), anteriorInicio, Form1.EPSILON));
                anteriorFin.ElementAt(i).getTransiciones().Add(new Transicion(anteriorFin.ElementAt(i), nuevoFin, Form1.EPSILON));
            }
            afn_kleene.setAlfabeto(automataFN.getAlfabeto());
            afn_kleene.setLenguajeR(automataFN.getLenguajeR());
            return(afn_kleene);
        }
        public Automata union(Automata afd1, Automata afd2, String Simbolo)
        {
            Automata afd_union = new Automata();
            //se crea un nuevo estado inicial
            Estado nuevoInicio = new Estado(0);

            //se crea una transicion del nuevo estado inicial al primer automata
            nuevoInicio.setTransiciones(new Transicion(nuevoInicio, afd2.getEstadoInicial(), Simbolo));

            afd_union.addEstados(nuevoInicio);
            afd_union.setEstadoInicial(nuevoInicio);
            int i = 0;//llevar el contador del identificador de estados

            //agregar los estados del segundo automata
            for (i = 0; i < afd1.getEstados().Count(); i++)
            {
                Estado tmp = (Estado)afd1.getEstados().ElementAt(i);
                tmp.setId(i + 1);
                afd_union.addEstados(tmp);
            }
            //agregar los estados del primer automata
            for (int j = 0; j < afd2.getEstados().Count(); j++)
            {
                Estado tmp = (Estado)afd2.getEstados().ElementAt(j);
                tmp.setId(i + 1);
                afd_union.addEstados(tmp);
                i++;
            }

            //se crea un nuevo estado final
            Estado nuevoFin = new Estado(afd1.getEstados().Count() + afd2.getEstados().Count() + 1);

            afd_union.addEstados(nuevoFin);
            afd_union.addEstadosAceptacion(nuevoFin);


            Estado        anteriorInicio = afd1.getEstadoInicial();
            List <Estado> anteriorFin    = afd1.getEstadosAceptacion();
            List <Estado> anteriorFin2   = afd2.getEstadosAceptacion();

            // agregar transiciones desde el nuevo estado inicial
            nuevoInicio.getTransiciones().Add(new Transicion(nuevoInicio, anteriorInicio, Simbolo));

            // agregar transiciones desde el anterior afd 1 al estado final
            for (int k = 0; k < anteriorFin.Count(); k++)
            {
                anteriorFin.ElementAt(k).getTransiciones().Add(new Transicion(anteriorFin.ElementAt(k), nuevoFin, Simbolo));
            }
            // agregar transiciones desde el anterior afd 2 al estado final
            for (int k = 0; k < anteriorFin.Count(); k++)
            {
                anteriorFin2.ElementAt(k).getTransiciones().Add(new Transicion(anteriorFin2.ElementAt(k), nuevoFin, Simbolo));
            }

            HashSet <object> alfabeto = new HashSet <object>();

            alfabeto.Add(afd1.getAlfabeto());
            alfabeto.Add(afd2.getAlfabeto());
            afd_union.setAlfabeto(alfabeto);
            afd_union.setLenguajeR(afd1.getLenguajeR() + " " + afd2.getLenguajeR());
            return(afd_union);
        }
示例#6
0
        /**
         * Conversion de un automata AFN a uno AFD por el
         * metodo de subconjuntos
         * @param afn AFN
         */
        public void conversionAFN(Automata afn)
        {
            try
            {
                //se crea una estructura vacia
                Automata automata = new Automata();
                //se utiliza una cola como la estructura para guardar los subconjuntos a analizar
                List <HashSet <Estado> > cola = new List <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 = 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.Add(array_inicial);
                //variable temporal para guardar el resultado todos los subconjuntos creados
                List <HashSet <Estado> > temporal = new List <HashSet <Estado> >();
                //se utilizan esetos indices para saber el estado actuales y anterior
                int indexEstadoInicio = 0;
                int counter           = 0;
                while (counter < cola.Count())
                {
                    //actual subconjunto
                    HashSet <Estado> actual = cola.ElementAt(counter);
                    //se recorre el subconjunto con cada simbolo del alfabeto del AFN
                    HashSet <Object> simbolo = new HashSet <Object>();
                    simbolo = (afn.getAlfabeto());
                    for (int i = 2; i < simbolo.Count(); i++)
                    {
                        //se realiza el move con el subconjunto
                        HashSet <Estado> move_result = move(actual, simbolo.ElementAt(i).ToString());

                        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 = (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))
                        {
                            List <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.IndexOf(resultado) + 1);
                            estado_viejo.setTransiciones(new Transicion(estado_viejo, estado_siguiente, simbolo.ElementAt(i).ToString()));
                        }
                        //si el subconjunto no existe, se crea un nuevo estado
                        else
                        {
                            temporal.Add(resultado);
                            cola.Add(resultado);

                            Estado nuevo = new Estado(temporal.IndexOf(resultado) + 1);
                            anterior.setTransiciones(new Transicion(anterior, nuevo, simbolo.ElementAt(i).ToString()));
                            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++;
                    counter++;
                }

                this.afd = automata;
                this.afd.setTipo("AFD");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }