public Automata Analizarentrada(LinkedList <DatoExpresion> Pila) { //// VAMOS A GUARDAR EL AFN EN UNA PILA Stack pilaAFN = new Stack(); for (int i = Pila.Count() - 1; i >= 0; i--) { //Console.WriteLine(Pila.ElementAt(i).getLexema() + " " + Pila.ElementAt(i).getTipo() + " " + Pila.ElementAt(i).getIdgrafica()); if (Pila.ElementAt(i).getLexema().Equals(".") && Pila.ElementAt(i).getTipo() == DatoExpresion.TipoExpresion.OPERADOR) { Automata concat_izq = (Automata)pilaAFN.Pop(); Automata concat_der = (Automata)pilaAFN.Pop(); Automata concat_resultado = Concatenacion(concat_izq, concat_der); pilaAFN.Push(concat_resultado); this.afn = concat_resultado; } else if (Pila.ElementAt(i).getLexema().Equals("*") && Pila.ElementAt(i).getTipo() == DatoExpresion.TipoExpresion.OPERADOR) { Automata kleene = CerraduraKleene((Automata)pilaAFN.Pop()); pilaAFN.Push(kleene); this.afn = kleene; } else if (Pila.ElementAt(i).getLexema().Equals("?") && Pila.ElementAt(i).getTipo() == DatoExpresion.TipoExpresion.OPERADOR) { Automata uno_epsilon = Uno_epsilon((Automata)pilaAFN.Pop()); pilaAFN.Push(uno_epsilon); this.afn = uno_epsilon; } else if (Pila.ElementAt(i).getLexema().Equals("|") && Pila.ElementAt(i).getTipo() == DatoExpresion.TipoExpresion.OPERADOR) { Automata union_izq = (Automata)pilaAFN.Pop(); Automata union_der = (Automata)pilaAFN.Pop(); Automata union_resultado = Disyuncion(union_izq, union_der); pilaAFN.Push(union_resultado); this.afn = union_resultado; } else if (Pila.ElementAt(i).getLexema().Equals("+") && Pila.ElementAt(i).getTipo() == DatoExpresion.TipoExpresion.OPERADOR) { Automata elementosacado = (Automata)pilaAFN.Pop(); pilaAFN.Push(elementosacado); Automata t = new Automata(); ///////////////////////////CLONAMOS NUESTRA VARIABLE PARA HACER EL DE KLEENE Y LA CONCATENACION foreach (Estado sta in elementosacado.getEstados()) { t.addEstados((Estado)sta.Clone()); } foreach (Estado sta in elementosacado.getEstadosAceptacion()) { t.addEstadosAceptacion((Estado)sta.Clone()); } int a = 0; t.setAlfabeto(elementosacado.getAlfabeto()); t.setLenguajeR((String)elementosacado.getLenguajeR().Clone()); t.setInicial((Estado)elementosacado.getInicial().Clone()); t.setEstadoInicial((Estado)elementosacado.getEstadoInicial().Clone()); ////////////////SE COMIENZA LA ACCION Automata uno_mas = Uno_mas((Automata)pilaAFN.Pop(), t); pilaAFN.Push(uno_mas); this.afn = uno_mas; } else { Automata simple = Simple(Pila.ElementAt(i).getLexema()); pilaAFN.Push(simple); this.afn = simple; } } this.afn.createAlfabeto(Pila); this.afn.setTipo("AFN"); Console.WriteLine(this.afn.DOT_THOMPSON(this.afn)); return(afn); }
/// <summary> /// ////////////////////////////////////////UNO O MAS .a*a ////////////////////////////////////////////////// /// </summary> /// <param name="AFN1"></param> /// <returns></returns> public Automata Uno_mas(Automata AFN1, Automata AFN2) { Automata AFN_UNOMAS = new Automata(); //// .a*a ///se crea un nuevo estado inicial /// se crea un automata para la cerradura de kleene int i = 0; for (i = 0; i < AFN1.getEstados().Count(); i++) { Estado tmp = (Estado)AFN1.getEstados().ElementAt(i); tmp.setId(i); if (i == 0) { AFN_UNOMAS.setEstadoInicial(tmp); } if (i == AFN1.getEstados().Count() - 1) // el ultimo estado se concatena con el de kleene { // creando trancision de estado inicial kleeene y estado aceptacion de afn1 for (int k = 0; k < AFN1.getEstadosAceptacion().Count(); k++) { Trancisiones tran = new Trancisiones(); tran.Transicion((Estado)AFN1.getEstadosAceptacion().ElementAt(k), AFN2.getEstadoInicial(), AnalizadorTexto.AnalizadorTexto.EPSILON); tmp.setTransiciones(tran); } Estado nuevoInicio = tmp; //agregar todos los estados intermedio for (int j = 0; j < AFN2.getEstados().Count(); j++) { Estado tmpi = (Estado)AFN2.getEstados().ElementAt(j); tmpi.setId(i + 1); AFN_UNOMAS.addEstados(tmpi); if (j == 0) { AFN2.getEstadoInicial().setId(i + 1); } if (AFN2.getEstados().Count() - 1 == j) { AFN2.getEstadosAceptacion().Clear(); Console.WriteLine(AFN2.getEstadosAceptacion().Count()); tmpi.getTransiciones().Clear(); AFN2.addEstadosAceptacion(tmpi); } i++; } //Se crea un nuevo estado de aceptacion Estado nuevoFin = new Estado(i + 1); AFN_UNOMAS.addEstados(nuevoFin); AFN_UNOMAS.addEstadosAceptacion(nuevoFin); //definir estados clave para realizar la cerraduras Estado anteriorInicio = AFN2.getEstadoInicial(); Trancisiones rem = anteriorInicio.getTransiciones().ElementAt(0); LinkedList <Estado> anteriorFin = AFN2.getEstadosAceptacion(); //Se agrega el dato de trancisiones de anteriorinicio y anteriorfin String simbolos = rem.getSimbolo(); Trancisiones unionafinal = new Trancisiones(); unionafinal.Transicion(AFN2.getInicial(), anteriorFin.ElementAt(AFN2.getEstadosAceptacion().Count() - 1), simbolos); anteriorInicio.setTransiciones(unionafinal); // agregar transiciones desde el nuevo estado inicial Trancisiones tran1 = new Trancisiones(); tran1.Transicion(nuevoInicio, anteriorInicio, AnalizadorTexto.AnalizadorTexto.EPSILON); nuevoInicio.getTransiciones().AddLast(tran1); Trancisiones tran21 = new Trancisiones(); tran21.Transicion(nuevoInicio, nuevoFin, AnalizadorTexto.AnalizadorTexto.EPSILON); nuevoInicio.getTransiciones().AddLast(tran21); // agregar transiciones desde el anterior estado final for (int k = 0; k < anteriorFin.Count(); k++) { Trancisiones tran3 = new Trancisiones(); tran3.Transicion(anteriorFin.ElementAt(k), anteriorInicio, AnalizadorTexto.AnalizadorTexto.EPSILON); anteriorFin.ElementAt(k).getTransiciones().AddLast(tran3); Trancisiones tran4 = new Trancisiones(); tran4.Transicion(anteriorFin.ElementAt(k), nuevoFin, AnalizadorTexto.AnalizadorTexto.EPSILON); anteriorFin.ElementAt(k).getTransiciones().AddLast(tran4); } } AFN_UNOMAS.addEstados(tmp); } AFN_UNOMAS.setAlfabeto(AFN1.getAlfabeto()); AFN_UNOMAS.setLenguajeR(AFN1.getLenguajeR()); Hashtable temporal = new Hashtable(); LinkedList <Trancisiones> te = new LinkedList <Trancisiones>(); Automata NUEVOCAMBIO = new Automata(); int auxiliares = 0; foreach (Estado estados in AFN_UNOMAS.getEstados()) { Estado nuevos = new Estado(auxiliares); Console.WriteLine("idEstado " + estados.getId() + " cantidad de trancisiones " + estados.getTransiciones().Count()); NUEVOCAMBIO.addEstados(nuevos); auxiliares++; } foreach (Estado estados in AFN_UNOMAS.getEstados()) { foreach (Trancisiones trancision in estados.getTransiciones()) { try { temporal.Add(trancision.getFin().getId() + "" + trancision.getInicio().getId(), estados.getId()); te.AddLast(trancision); Console.WriteLine(trancision.getInicio().getId() + " ============ " + trancision.getFin().getId()); foreach (Estado state in NUEVOCAMBIO.getEstados()) { if (trancision.getInicio().getId() == state.getId()) { Trancisiones transi = new Trancisiones(); Estado iniciotran = new Estado(trancision.getInicio().getId()); Estado fintran = new Estado(trancision.getFin().getId()); String simbolotran = trancision.getSimbolo(); transi.Transicion(iniciotran, fintran, simbolotran); state.getTransiciones().AddLast(transi); } } } catch (Exception e) { Console.WriteLine("SE REPITE " + trancision.getInicio().getId() + " " + trancision.getFin().getId()); } } } Automata AFN_UNOOMAS = new Automata(); /*foreach(Trancisiones auxiliar in te) * { * Estado aux = new Estado(auxiliar.getInicio().getId()); * aux.setTransiciones(auxiliar); * AFN_UNOOMAS.addEstados(aux); * } * ////borramos todas las trancisiones * AFN_UNOOMAS.addEstadosAceptacion(AFN_UNOMAS.getEstadosAceptacion().ElementAt(0)); * AFN_UNOOMAS.setEstadoInicial(AFN_UNOMAS.getEstadoInicial()); * AFN_UNOOMAS.setInicial(AFN_UNOMAS.getInicial()); * AFN_UNOOMAS.setLenguajeR(AFN_UNOMAS.getLenguajeR()); * AFN_UNOOMAS.setAlfabeto(AFN_UNOMAS.getAlfabeto()); * * Automata TEMPORALES = new Automata(); * int repetidos = 0; * foreach (Estado auxiliar in AFN_UNOMAS.getEstados()) * { * Estado anteriores = auxiliar; * Estado nuevos = new Estado(anteriores.getId()); * TEMPORALES.addEstados(nuevos); * * } * foreach (Estado auxiliar in AFN_UNOOMAS.getEstados()) * { * foreach (Trancisiones transi in auxiliar.getTransiciones()) * { * foreach (Estado entry in TEMPORALES.getEstados()) * { * if (auxiliar.getId() == entry.getId()) * { * entry.setTransiciones(transi); * foreach(Trancisiones agregando in entry.getTransiciones()) * { * agregando.setInicio(transi.getInicio()); * agregando.setFin(transi.getFin()); * agregando.setSimbolo(transi.getSimbolo()); * } * * } * repetidos++; * } * } * } * * */ NUEVOCAMBIO.setTipo("AFN_UNOMAS"); NUEVOCAMBIO.addEstadosAceptacion(AFN_UNOMAS.getEstadosAceptacion().ElementAt(0)); NUEVOCAMBIO.setEstadoInicial(NUEVOCAMBIO.getEstados().ElementAt(0)); NUEVOCAMBIO.setInicial(NUEVOCAMBIO.getEstados().ElementAt(0)); NUEVOCAMBIO.setLenguajeR(AFN_UNOMAS.getLenguajeR()); NUEVOCAMBIO.setAlfabeto(AFN_UNOMAS.getAlfabeto()); return(NUEVOCAMBIO); }
///// METODO QUE ES PARA LA CONCATENACION public Automata Concatenacion(Automata AFN1, Automata AFN2) { Automata AFN_CONCATENACION = new Automata(); if (AFN2.getTipo() != null) { int i = 0; Trancisiones tran = null; for (i = 0; i < AFN1.getEstados().Count(); i++) { Estado tmp = (Estado)AFN1.getEstados().ElementAt(i); tmp.setId(i); /// ahorita se define el estado inicial if (i == 0) { AFN_CONCATENACION.setEstadoInicial(tmp); } ///cuando llega al último, concatena el ultimo con el primero del otro automata con un epsilon if (i == AFN1.getEstados().Count() - 1) { //se utiliza un ciclo porque los estados de aceptacion son un array //se coloca un estado de epsilon por si acaso es para hacer la separacion de los nodos /*for (int k = 0; k < AFN1.getEstadosAceptacion().Count(); k++) * { * tran = new Trancisiones(); * * tran.Transicion((Estado)AFN1.getEstadosAceptacion().ElementAt(k), AFN2.getEstadoInicial(), AnalizadorTexto.AnalizadorTexto.EPSILON); * tmp.setTransiciones(tran); * }*/ foreach (Estado es in AFN1.getEstadosAceptacion()) { int idestadfin = AFN1.getEstadosAceptacion().ElementAt(0).getId(); tmp.setId(idestadfin); foreach (Trancisiones a in AFN2.getEstadoInicial().getTransiciones()) { Trancisiones b = new Trancisiones(); int contadorespacios = 0; int inicio = a.getInicio().getId(); int fin = a.getFin().getId(); if (inicio > fin) { contadorespacios = inicio - fin; } else { contadorespacios = fin - inicio; } Estado inicios = new Estado(idestadfin); b.setInicio(inicios); Estado finales = new Estado(idestadfin + contadorespacios); b.setFin(finales); b.setSimbolo(a.getSimbolo()); tmp.setTransiciones(b); } } } AFN_CONCATENACION.addEstados(tmp); } int inicial = i--; //// SE PROCEDE A EJECUTAR LO DEL LADO DERECHO for (int j = 0; j < AFN2.getEstados().Count(); j++) { Estado tmp = new Estado(i); tmp.setId(i); //define el ultimo con estado de aceptacion if (AFN2.getEstados().Count() - 1 == j) { AFN_CONCATENACION.addEstadosAceptacion(tmp); } else { foreach (Trancisiones a in AFN2.getEstados().ElementAt(j).getTransiciones()) { Trancisiones b = new Trancisiones(); int contadorespacios = 0; int inicio = a.getInicio().getId(); int fin = a.getFin().getId(); if (inicio > fin) { contadorespacios = inicio - fin; } else { contadorespacios = fin - inicio; } Estado inicios = new Estado(i); b.setInicio(inicios); Estado finales = new Estado(i + contadorespacios); b.setFin(finales); b.setSimbolo(a.getSimbolo()); tmp.setTransiciones(b); } } if (j == 0) { } else { AFN_CONCATENACION.addEstados(tmp); } i++; } Hashtable alfabeto = new Hashtable(); alfabeto.Add(AFN1.getAlfabeto(), AFN_CONCATENACION.getInicial().getId()); alfabeto.Add(AFN2.getAlfabeto(), AFN_CONCATENACION.getEstadosAceptacion().ElementAt(0).getId()); AFN_CONCATENACION.setTipo(null); AFN_CONCATENACION.setAlfabeto(alfabeto); AFN_CONCATENACION.setLenguajeR(AFN1.getLenguajeR() + " " + AFN2.getLenguajeR()); //Console.WriteLine(tran.toString()); } else { int i = 0; //se agragaran los estados de cada uno de los automatas del lado derecho e izquierdo para luego unirlos por se de // concatencion ///////////////SE PROCEDE A EJECUTAR LOS DEL LADO IZQUIERDO Trancisiones tran = null; for (i = 0; i < AFN1.getEstados().Count(); i++) { Estado tmp = (Estado)AFN1.getEstados().ElementAt(i); tmp.setId(i); /// ahorita se define el estado inicial if (i == 0) { AFN_CONCATENACION.setEstadoInicial(tmp); } ///cuando llega al último, concatena el ultimo con el primero del otro automata con un epsilon if (i == AFN1.getEstados().Count() - 1) { //se utiliza un ciclo porque los estados de aceptacion son un array //se coloca un estado de epsilon por si acaso es para hacer la separacion de los nodos /*for (int k = 0; k < AFN1.getEstadosAceptacion().Count(); k++) * { * tran = new Trancisiones(); * tran.Transicion((Estado)AFN1.getEstadosAceptacion().ElementAt(k), AFN2.getEstadoInicial(), AnalizadorTexto.AnalizadorTexto.EPSILON); * tmp.setTransiciones(tran); * }*/ foreach (Estado es in AFN1.getEstadosAceptacion()) { tmp = AFN2.getEstadoInicial(); int idestadfin = AFN1.getEstadosAceptacion().ElementAt(0).getId(); tmp.setId(idestadfin); int a = 0; } } AFN_CONCATENACION.addEstados(tmp); } i--; //// SE PROCEDE A EJECUTAR LO DEL LADO DERECHO for (int j = 0; j < AFN2.getEstados().Count(); j++) { Estado tmp = (Estado)AFN2.getEstados().ElementAt(j); tmp.setId(i); //define el ultimo con estado de aceptacion if (AFN2.getEstados().Count() - 1 == j) { AFN_CONCATENACION.addEstadosAceptacion(tmp); } if (j == 0) { } else { AFN_CONCATENACION.addEstados(tmp); } i++; } Hashtable alfabeto = new Hashtable(); alfabeto.Add(AFN1.getAlfabeto(), AFN_CONCATENACION.getInicial().getId()); alfabeto.Add(AFN2.getAlfabeto(), AFN_CONCATENACION.getEstadosAceptacion().ElementAt(0).getId()); AFN_CONCATENACION.setAlfabeto(alfabeto); AFN_CONCATENACION.setLenguajeR(AFN1.getLenguajeR() + " " + AFN2.getLenguajeR()); //Console.WriteLine(tran.toString()); } return(AFN_CONCATENACION); }