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);
        }
Example #2
0
        public HashSet <Estado> eClosure(Estado eClosureEstado)
        {
            Stack <Estado> pilaClosure = new Stack <Estado>();
            Estado         actual      = eClosureEstado;

            actual.getTransiciones();
            HashSet <Estado> resultado = new HashSet <Estado>();

            pilaClosure.Push(actual);
            while (pilaClosure.Count() != 0)
            {
                actual = pilaClosure.Pop();

                foreach (Transicion t in (List <Transicion>)actual.getTransiciones())
                {
                    if (t.getSimbolo().Equals(Form1.EPSILON) && !resultado.Contains(t.getFin()))
                    {
                        resultado.Add(t.getFin());
                        pilaClosure.Push(t.getFin());
                    }
                }
            }
            resultado.Add(eClosureEstado); //la operacion e-Closure debe tener el estado aplicado
            return(resultado);
        }
        public Automata cerraduraKleene(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);
        }
Example #4
0
        public String toString()
        {
            String res = "";

            res += "-------" + this.tipo + "---------\r\n";
            res += "Alfabeto " + this.alfabeto + "\r\n";
            res += "Estado inicial " + this.inicial + "\r\n";
            res += "Conjutos de estados de aceptacion " + this.aceptacion + "\r\n";
            res += "Conjunto de Estados " + this.estados.ToString() + "\r\n";
            res += "Conjunto de transiciones ";
            for (int i = 0; i < this.estados.Count(); i++)
            {
                Estado est = estados.ElementAt(i);
                res += est.getTransiciones() + "-";
            }
            res += "\r\n";
            res += "Lenguaje r: " + this.lenguajeR + "\r\n";
            res += "Cadena w ingresada: " + this.resultadoRegex[1] + "\r\n";
            res += "Resultado: " + this.resultadoRegex[2] + "\r\n";


            return(res);
        }
        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);
        }