/// <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);
}
public Object minimizar(Automata automata)
{
numestados = automata.getEstados().Count();
alfabeto = automata.getAlfabeto();
estadoInicial = automata.getEstadoInicial().getId();
estadoFinal = automata.getEstadosAceptacion();
int fila = 0, columna = 0;
int contadorparatablanoString = 0;
foreach (Object key in alfabeto.Keys)
{
if (key is System.Collections.Hashtable)
{
contadorparatablanoString++;
}
else
{
Console.WriteLine(key);
}
}
tabtrans = new LinkedList <int> [numestados, alfabeto.Keys.Count - contadorparatablanoString];
foreach (Estado state in automata.getEstados())
{
foreach (Object key in alfabeto.Keys)
{
if (key is System.Collections.Hashtable)
{
contadorparatablanoString++;
}
else
{
LinkedList <int> auxiliar = new LinkedList <int>();
foreach (Trancisiones tran in state.getTransiciones())
{
if (tran.getSimbolo().Equals(key))
{
auxiliar.AddLast(tran.getFin().getId());
}
}
tabtrans[columna, fila] = auxiliar;
fila++;
}
}
fila = 0;
columna++;
}
quitarTansicionesVacias(automata);
//quitarIndeterminismo();
/*while (!verificarMinimo())
* {
* minimizar();
* }*/
//tabtrans = automata.get();
Automata MINIMIZADO = new Automata();
int contador = 0;
/*foreach (Estado state in automata.getEstados())
* {
* Estado nuevoestado = state;
*
* foreach (Trancisiones tran in state.getTransiciones())
* {
* nuevoestado.setTransiciones(tran);
* }
* MINIMIZADO.addEstados(nuevoestado);
* }*/
MINIMIZADO.addEstadosAceptacion(automata.getEstadosAceptacion().ElementAt(0));
MINIMIZADO.setEstadoInicial(automata.getEstados().ElementAt(0));
MINIMIZADO.setInicial(automata.getEstados().ElementAt(0));
MINIMIZADO.setLenguajeR(automata.getLenguajeR());
MINIMIZADO.setAlfabeto(alfabeto);
return(new AFD_GRAFICA(MINIMIZADO, tabtrans));
}
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);
}
