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 void generarDOT(string nombreArchivo, Automata automataFinito)
        {
            string texto = "digraph automata_finito {\n";

            texto += "\trankdir=LR;" + "\n";

            texto += "\tgraph [label=\"" + nombre + "\", labelloc=t, fontsize=20]; \n";
            texto += "\tnode [shape=doublecircle, style = filled,color = mediumseagreen];";
            //listar estados de aceptación
            for (int i = 0; i < automataFinito.getEstadosAceptacion().Count(); i++)
            {
                texto += " \"" + automataFinito.getEstadosAceptacion().ElementAt(i).id + "\"";
            }
            //
            texto += ";" + "\n";
            texto += "\tnode [shape=circle];" + "\n";
            texto += "\tnode [color=midnightblue,fontcolor=white];\n" + "	edge [color=red];"+ "\n";

            texto += "\tsecret_node [style=invis];\n" + "	secret_node -> \""+ automataFinito.getEstadoInicial().id + "\" [label=\"inicio\"];" + "\n";
            //transiciones
            for (int i = 0; i < automataFinito.getEstados().Count(); i++)
            {
                List <Transicion> t = automataFinito.getEstados().ElementAt(i).getTransiciones();
                for (int j = 0; j < t.Count(); j++)
                {
                    texto += "\t" + t.ElementAt(j).DOT_String() + "\n";
                }
            }
            texto += "}";



            FileStream   archivo = new FileStream(nombre + ".dot", FileMode.Create, FileAccess.Write);
            StreamWriter TextOut;

            try
            {
                TextOut = new StreamWriter(archivo);
                TextOut.WriteLine(texto);

                TextOut.Close();
            }
            catch (IOException ex)
            {
                MessageBox.Show(ex.ToString());
            }

            generarArchivo();
        }
        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);
        }
        public void construct()
        {
            string reg = "";
            String sim = "";

            try
            {
                Stack pilaafd = new Stack();
                //Crea un automata por cada operacion
                for (
                    int i = 0; i < regex.Count(); i++)
                {
                    reg += regex.ElementAt(i);
                    string c = regex.ElementAt(i);
                    switch (c)
                    {
                    case "*":
                        Automata kleene = cerraduraKleene((Automata)pilaafd.Pop(), sim);
                        pilaafd.Push(kleene);
                        this.afd = kleene;
                        break;

                    case "+":
                        Automata repeat = UnoaMuchos((Automata)pilaafd.Pop(), sim);
                        pilaafd.Push(repeat);
                        this.afd = repeat;
                        break;

                    case "?":
                        Automata exclude = Omision((Automata)pilaafd.Pop(), sim);
                        pilaafd.Push(exclude);
                        this.afd = exclude;
                        break;

                    case ".":
                        Automata concat_param1 = (Automata)pilaafd.Pop();
                        Automata concat_param2 = (Automata)pilaafd.Pop();
                        Automata concat_result = concatenacion(concat_param1, concat_param2, sim);

                        pilaafd.Push(concat_result);
                        this.afd = concat_result;
                        break;

                    case "|":
                        Automata union_param1 = (Automata)pilaafd.Pop();
                        Automata union_param2 = (Automata)pilaafd.Pop();
                        Automata union_result = union(union_param1, union_param2, sim);
                        pilaafd.Push(union_result);

                        this.afd = union_result;
                        break;

                    default:
                        //crear un automata con cada simbolo
                        Automata simple = afdSimple((c));
                        //crea un nuevo string con el ultimo simbolo que se ingrese que no sea de los operadores
                        sim = c;
                        pilaafd.Push(simple);
                        this.afd = simple;
                        break;
                    }
                }
                this.afd.createAlfabeto(regex);
                this.afd.setTipo("afd");
            }
            catch (System.Exception e)
            {
                MessageBox.Show("Expresión mal ingresada");
            }
            try
            {
                generarDOT(reg, this.afd);
            }
            catch (System.Exception ex)
            {
                MessageBox.Show("no se pudo generar el dot");
            }
        }
        public void construct()
        {
            string reg = "";

            try
            {
                Stack pilaAFN = new Stack();
                //Crea un automata por cada operacion
                for (
                    int i = 0; i < regex.Count(); i++)
                {
                    reg += regex.ElementAt(i);
                    string c = regex.ElementAt(i);
                    switch (c)
                    {
                    case "*":
                        Automata kleene = cerraduraKleene((Automata)pilaAFN.Pop());
                        pilaAFN.Push(kleene);
                        this.afn = kleene;
                        break;

                    case "+":
                        Automata repeat = UnoaMuchos((Automata)pilaAFN.Pop());
                        pilaAFN.Push(repeat);
                        this.afn = repeat;
                        break;

                    case "?":
                        Automata exclude = Omision((Automata)pilaAFN.Pop());
                        pilaAFN.Push(exclude);
                        this.afn = exclude;
                        break;

                    case ".":
                        Automata concat_param1 = (Automata)pilaAFN.Pop();
                        Automata concat_param2 = (Automata)pilaAFN.Pop();
                        Automata concat_result = concatenacion(concat_param1, concat_param2);

                        pilaAFN.Push(concat_result);
                        this.afn = concat_result;
                        break;

                    case "|":
                        Automata union_param1 = (Automata)pilaAFN.Pop();
                        Automata union_param2 = (Automata)pilaAFN.Pop();
                        Automata union_result = union(union_param1, union_param2);
                        pilaAFN.Push(union_result);

                        this.afn = union_result;
                        break;

                    default:
                        //crear un automata con cada simbolo
                        Automata simple = afnSimple((c));
                        pilaAFN.Push(simple);
                        this.afn = simple;
                        break;
                    }
                }
                this.afn.createAlfabeto(regex);
                this.afn.setTipo("AFN");
            }
            catch (System.Exception e)
            {
                MessageBox.Show("Expresión mal ingresada");
            }
            try
            {
                generarDOT(reg, this.afn);
            }
            catch (System.Exception ex)
            {
                MessageBox.Show("no se pudo generar el dot");
            }
            try
            {
                //AFDConstructor afd = new AFDConstructor();
                //afd.conversionAFN(this.afn);
                AFNaAFD cons = new AFNaAFD(this.regex, this.nombre + pnombre);
                pnombre++;
                cons.construct();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }
示例#9
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());
            }
        }
示例#10
0
 public AFDConstructor()
 {
     this.resultadoFollowPos = new java.util.HashMap();
     //simulador = new AFNaAFD();
     afd = new Automata();
 }