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 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); }
/** * 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()); } }