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 afdSimple(string simboloRegex)
{
Automata automatafd = new Automata();
//definir los nuevos estados
Estado inicial = new Estado(0);
//Estado aceptacion = new Estado(0);
//crear una transicion unica con el simbolo
//Transicion tran = new Transicion(inicial, aceptacion, simboloRegex);
//inicial.setTransiciones(tran);
//agrega los estados creados
automatafd.addEstados(inicial);
//automatafd.addEstados(aceptacion);
//colocar los estados iniciales y de aceptacion
automatafd.setEstadoInicial(inicial);
//automatafd.addEstadosAceptacion(aceptacion);
automatafd.setLenguajeR(simboloRegex + "");
return(automatafd);
}
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());
}
}