/////VOY A CREAR EL METODO PARA HACER UN NODO SIMPLE O UN TOKEN DEL ALFABETO A AGREGAR A THOMPSON
public Automata Simple(String simbolosimple)
{
Automata AFN_SIMPLE = new Automata();
//definir los nuevos estados
Estado inicial = new Estado(0);
Estado aceptacion = new Estado(1);
//crear una transicion unica con el simbolo
Trancisiones tran = new Trancisiones();
tran.Transicion(inicial, aceptacion, simbolosimple);
inicial.setTransiciones(tran);
//agrega los estados creados
AFN_SIMPLE.addEstados(inicial);
AFN_SIMPLE.addEstados(aceptacion);
//colocar los estados iniciales y de acpetacion
AFN_SIMPLE.setEstadoInicial(inicial);
AFN_SIMPLE.addEstadosAceptacion(aceptacion);
AFN_SIMPLE.setLenguajeR(simbolosimple + "");
//Console.WriteLine(tran.DOT_String());
return(AFN_SIMPLE);
}
/// <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);
}
/////////////////////////////////////////////////////// OR///////////////////////////////////////////////////////////////
public Automata Disyuncion(Automata AFN1, Automata AFN2)
{
Automata AFN_DISYUNCION = new Automata();
//se crea un nuevo estado inicial
Estado nuevoInicio = new Estado(0);
//se crea una transicion del nuevo estado inicial al primer automata
Trancisiones tran = new Trancisiones();
tran.Transicion(nuevoInicio, AFN2.getEstadoInicial(), AnalizadorTexto.AnalizadorTexto.EPSILON);
nuevoInicio.setTransiciones(tran);
AFN_DISYUNCION.addEstados(nuevoInicio);
AFN_DISYUNCION.setEstadoInicial(nuevoInicio);
int i = 0; //llevar el contador del identificador de estados
//se agrega los estados del primer automata
for (i = 0; i < AFN1.getEstados().Count(); i++)
{
Estado tmp = (Estado)AFN1.getEstados().ElementAt(i);
tmp.setId(i + 1);
AFN_DISYUNCION.addEstados(tmp);
}
if (AFN1.getEstados().Count() == 3)
{
for (int h = 0; h < AFN1.getEstados().Count(); h++)
{
Estado tmp = (Estado)AFN1.getEstados().ElementAt(h);
foreach (Trancisiones tra in tmp.getTransiciones())
{
int final = tra.getFin().getId();
if (tra.getInicio().getId() + 2 != final + 1)
{
tra.getFin().setId(tra.getInicio().getId() + 1);
}
}
}
}
//se agrega los estados del segundo automata
for (int j = 0; j < AFN2.getEstados().Count(); j++)
{
Estado tmp = (Estado)AFN2.getEstados().ElementAt(j);
tmp.setId(i + 1);
AFN_DISYUNCION.addEstados(tmp);
i++;
}
if (AFN2.getEstados().Count() == 3)
{
for (int h = 0; h < AFN2.getEstados().Count(); h++)
{
Estado tmp = (Estado)AFN2.getEstados().ElementAt(h);
foreach (Trancisiones tra in tmp.getTransiciones())
{
int final = tra.getFin().getId();
if (tra.getInicio().getId() + 2 != final + 1)
{
tra.getFin().setId(tra.getInicio().getId() + 1);
}
}
}
}
//se crea un nuevo estado final
Estado nuevoFin = new Estado(AFN1.getEstados().Count() + AFN2.getEstados().Count() + 1);
AFN_DISYUNCION.addEstados(nuevoFin);
AFN_DISYUNCION.addEstadosAceptacion(nuevoFin);
Estado anteriorInicio = AFN1.getEstadoInicial();
LinkedList <Estado> anteriorFin = AFN1.getEstadosAceptacion();
LinkedList <Estado> anteriorFin2 = AFN2.getEstadosAceptacion();
// se agrega transicion del nuevo estado inicial
Trancisiones tran1 = new Trancisiones();
tran1.Transicion(nuevoInicio, anteriorInicio, AnalizadorTexto.AnalizadorTexto.EPSILON);
nuevoInicio.getTransiciones().AddLast(tran1);
// se agregan transicion del anterior AFN al estado final
for (int k = 0; k < anteriorFin.Count(); k++)
{
Trancisiones tran2 = new Trancisiones();
tran2.Transicion(anteriorFin.ElementAt(k), nuevoFin, AnalizadorTexto.AnalizadorTexto.EPSILON);
anteriorFin.ElementAt(k).getTransiciones().AddLast(tran2);
}
// se agrega transicion del anterior AFN de abajo al estado final
for (int k = 0; k < anteriorFin.Count(); k++)
{
Trancisiones tran2 = new Trancisiones();
tran2.Transicion(anteriorFin2.ElementAt(k), nuevoFin, AnalizadorTexto.AnalizadorTexto.EPSILON);
anteriorFin2.ElementAt(k).getTransiciones().AddLast(tran2);
}
Hashtable alfabeto = new Hashtable();
alfabeto.Add(AFN1.getAlfabeto(), 13);
alfabeto.Add(AFN2.getAlfabeto(), 23);
AFN_DISYUNCION.setAlfabeto(alfabeto);
AFN_DISYUNCION.setLenguajeR(AFN1.getLenguajeR() + " " + AFN2.getLenguajeR());
return(AFN_DISYUNCION);
}
////////////////////////////////////////////////CERRADURA DE KLEENE////////////////////////////////////////////////////
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);
//Console.WriteLine("CANTIDAD DE ESTADOS EN UNO "+automataFN.getEstados().Count());
//agregar todos los estados intermedio
for (int i = 0; i < automataFN.getEstados().Count(); i++)
{
Estado tmp = (Estado)automataFN.getEstados().ElementAt(i);
//Console.WriteLine("id " + tmp.getId());
tmp.setId(i + 1);
AFN_KLEENE.addEstados(tmp);
}
for (int h = 0; h < automataFN.getEstados().Count(); h++)
{
Estado tmp = (Estado)automataFN.getEstados().ElementAt(h);
foreach (Trancisiones tra in tmp.getTransiciones())
{
int final = tra.getFin().getId();
if (tra.getInicio().getId() == final)
{
tra.getFin().setId(tra.getInicio().getId() + 1);
}
}
}
//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();
LinkedList <Estado> anteriorFin = automataFN.getEstadosAceptacion();
// agregar transiciones desde el nuevo estado inicial
Trancisiones tran = new Trancisiones();
tran.Transicion(nuevoInicio, anteriorInicio, AnalizadorTexto.AnalizadorTexto.EPSILON);
nuevoInicio.getTransiciones().AddLast(tran);
Trancisiones tran2 = new Trancisiones();
tran2.Transicion(nuevoInicio, nuevoFin, AnalizadorTexto.AnalizadorTexto.EPSILON);
nuevoInicio.getTransiciones().AddLast(tran2);
// agregar transiciones desde el anterior estado final
for (int i = 0; i < anteriorFin.Count(); i++)
{
Trancisiones tran3 = new Trancisiones();
tran3.Transicion(anteriorFin.ElementAt(i), anteriorInicio, AnalizadorTexto.AnalizadorTexto.EPSILON);
Trancisiones tran4 = new Trancisiones();
tran4.Transicion(anteriorFin.ElementAt(i), nuevoFin, AnalizadorTexto.AnalizadorTexto.EPSILON);
anteriorFin.ElementAt(i).getTransiciones().AddLast(tran3);
anteriorFin.ElementAt(i).getTransiciones().AddLast(tran4);
}
AFN_KLEENE.setAlfabeto(automataFN.getAlfabeto());
AFN_KLEENE.setLenguajeR(automataFN.getLenguajeR());
return(AFN_KLEENE);
}
///// 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);
}
/**
* Agregar transiciones al estado
* @param tran transicion
*/
public void setTransiciones(Trancisiones tran)
{
this.transiciones.AddLast(tran);
}
