/// <summary>
/// Evento click del boton para comparar la cadena. Recibe el String de la cadena ingresada y llama al metodo encargado de validar
/// si la cadena es de aceptación o no. Imprime el resultado en un label.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BtnValidar_Click(object sender, EventArgs e)
{
if (this.funcionesTransicionAutomata == null)
{
this.resultadoAF.Text = "";
//RangeValidator1.ErrorMessage = "Debe generar un AFD.";
}
else
{
String contenidoCadenaValidar = this.lenguaje.Text.Trim().Replace(@"\s", "");
TransicionAFD status = new TransicionAFD();
status = this.validarCadena(contenidoCadenaValidar, status);
if (status != null && nuevosEstadosAutomata.Where(s => s.estado == status.proximoEstado).FirstOrDefault().aceptacion)
{
//this.resultadoAF.ForeColor = System.Drawing.Color.Green;
this.resultadoAF.Text = "la cadena es correcta";
}
else if (status == null)
{
//this.resultadoAF.ForeColor = System.Drawing.Color.Red;
this.resultadoAF.Text = "la cadena es incorrecta";
}
else
{
//this.resultadoAF.ForeColor = System.Drawing.Color.Red;
this.resultadoAF.Text = "la cadena es incorrecta";
}
}
}
/// <summary>
/// Genera la nueva coleccion de estados que se obtiene al moverse desde la composición de un estado del
/// Automata Finito Determinista con cada uno de los simbolos del alfabeto.
/// </summary>
/// <param name="estadoAutomata">Estado que se evalua en ese momento</param>
/// <param name="simbolo">Simbolo del alfabeto con el cual se recorre el AFN</param>
/// <param name="listaFuncTransicionAutomataND">Listado de funciones de transicion del AFN</param>
/// <returns>Coleccion de estados resultante al moverse con un simbolo del alfabeto con la composicion de estados de un estado nuevo del AFD</returns>
public List <String> Mueve(TransicionAFD estadoAutomata, String simbolo, List <Transicion> listaFuncTransicionAutomataND)
{
// Por cada estado que contenga la composición de estados, por cada función de transición del AFN, verifica que el estado y simbolo sean iguales.
// De ser así, si el estado destino con esa combinación no existe en la lista de nuevos estados, la añade.
List <String> listaNuevosEstados = new List <String>();
foreach (String estado in estadoAutomata.componentes)
{
foreach (Transicion transicion in listaFuncTransicionAutomataND)
{
if (transicion.estado.Equals(estado) && transicion.simbolo.Equals(simbolo) && !listaNuevosEstados.Contains(transicion.proximoEstado))
{
listaNuevosEstados.Add(transicion.proximoEstado);
}
}
}
listaNuevosEstados.Sort();
return(listaNuevosEstados);
}
/// <summary>
/// Valida que la cadena ingresada sea de aceptación o no.
/// </summary>
/// <param name="cadenaValidar">Cadena a validar.</param>
/// <param name="status">Estado resultante al terminar de recorrer cada elemento de la cadena a validar.</param>
/// <param name="index">Indice del elemento de la cadena que se está evaluando.</param>
/// <returns></returns>
private TransicionAFD validarCadena(String cadenaValidar, TransicionAFD status)
{
// Se utiliza como flag para que el primer elemento de la cadena inicie su recorrido desde el primer estado el autómata.
int contador = 0;
// Si se recibe una cadena vacía (lambda) y el primer estado es de aceptación, retorna ese primer estado como estado resultante.
if (String.IsNullOrEmpty(cadenaValidar) && funcionesTransicionAutomata.Where(s => s.estado == estadoInicialAutomataFinitoDeterminista).FirstOrDefault().aceptacion)
{
status = funcionesTransicionAutomata.Where(s => s.estado == estadoInicialAutomataFinitoDeterminista).FirstOrDefault();
return(status);
}
else if (String.IsNullOrEmpty(cadenaValidar))
{
return(null);
}
// Recorre cada elemento de la cadena, posición por posición, y devuelve el estado resultante al terminar de recorrer la cadena.
foreach (Char elemento in cadenaValidar)
{
// Si el elemento que se evalúa no pertenece al alfabeto original, retorna un estado nulo y sale del método.
if (simbolosAutomataND.Contains(elemento.ToString()))
{
// Si es el primer elemento de la cadena, se posiciona en el estado inicial del autómata y parte de ese estado.
// De lo contrario, sigue recorriendo con el estado en el que se quedó.
if (contador == 0)
{
status = this.funcionesTransicionAutomata.Where(f => f.simbolo == elemento.ToString() && f.estado == this.estadoInicialAutomataFinitoDeterminista).FirstOrDefault();
}
else
{
status = this.funcionesTransicionAutomata.Where(f => f.estado == status.proximoEstado && f.simbolo == elemento.ToString()).FirstOrDefault();
}
}
else
{
return(null);
}
contador = 1;
}
return(status);
}
/// <summary>
/// Inicializa el proceso para generar el AFD a partir del AFN ó AFN-E.
/// </summary>
/// <param name="estadosAutomataND">Todos los estados que posee el AFN</param>
/// <param name="simbolosAutomataND">Alfabeto del AFN</param>
/// <param name="estadoInicialAutomataND">Estado inicial del AFN</param>
/// <param name="estadosAceptacionAutomataND">Estados de aceptación del AFN</param>
/// <param name="listaFuncTransicionAutomataND">Colección de objetos tipo Transición que contienen las funciones de transición</param>
public List <TransicionAFD> ConvertirAFNaAFD(List <String> estadosAutomataND, List <String> simbolosAutomataND, String estadoInicialAutomataND, List <String> estadosAceptacionAutomataND, List <Transicion> listaFuncTransicionAutomataND, ref List <TransicionAFD> funcionesTransicionAFD)
{
List <TransicionAFD> nuevosEstadosAutomata = new List <TransicionAFD>();
List <TransicionAFD> funcionesTransicionAutomata = new List <TransicionAFD>();
List <String> coleccionEstados = new List <String>();
TransicionAFD newTransicion = new TransicionAFD();
// Se agrega el estado inicial a la composición del nuevo primer estado, se manda a llamar la función CerraduraEpsilon
//para obtener el primer estado del AFD y se agrega a la nueva colección de estados del AFD como un estado no marcado.
coleccionEstados.Add(estadoInicialAutomataND);
coleccionEstados = this.CerraduraEpsilon(coleccionEstados, listaFuncTransicionAutomataND, coleccionEstados.Count, 0);
coleccionEstados.Sort();
newTransicion.componentes = coleccionEstados;
newTransicion.marca = false;
newTransicion.aceptacion = false;
foreach (String estado in newTransicion.componentes)
{
if (estadosAceptacionAutomataND.Contains(estado))
{
newTransicion.aceptacion = true;
break;
}
}
newTransicion.estado = STATUS_VALUES[STATUS_INDEX];
STATUS_INDEX++;
nuevosEstadosAutomata.Add(newTransicion);
List <String> listaEstados = new List <String>();
// Se inicializa el recorrido de los estados sin marcar de la tabla T.
//this.ObtenerEstadosAlfabeto(nuevosEstadosAutomata, simbolosAutomataND, listaFuncTransicionAutomataND, listaEstados, funcionesTransicionAutomata, nuevosEstadosAutomata.Count, 0, false);
IList <TransicionAFD> estadosSinMarcar = new List <TransicionAFD>();
do
{
TransicionAFD estadoActual = nuevosEstadosAutomata.Where(q => q.marca == false).FirstOrDefault();
estadoActual.marca = true;
foreach (String simbolo in simbolosAutomataND)
{
listaEstados = Mueve(estadoActual, simbolo, listaFuncTransicionAutomataND);
listaEstados = CerraduraEpsilon(listaEstados, listaFuncTransicionAutomataND, listaEstados.Count, 0);
if (listaEstados.Count == 0)
{
listaEstados.Add("-Vacio-");
}
// Se verifica si el posible nuevo estado encontrado existe en la tabla de nuevos estados del AFD
TransicionAFD newTrans;
bool flagExists = false;
TransicionAFD posibleNuevoEstado = nuevosEstadosAutomata.Where(q => q.componentes.SequenceEqual(listaEstados)).FirstOrDefault();
if (posibleNuevoEstado != null)
{
flagExists = true;
}
// Verifica si la lista de estados contiene al menos un estado de aceptación y guarda el resultado en un flag
bool aceptacion = false;
foreach (String estado in listaEstados)
{
if (estadosAceptacionAutomataND.Contains(estado))
{
aceptacion = true;
break;
}
}
// Si el nuevo estado generado no existe en la Tabla T, se crea el nuevo estado y se añade a la lista de
// nuevos estados del AFD, y luego, se añade la funcion de transicion a la lista correspondiente.
// De lo contrario, solo se añade la función de transición.
if (!flagExists)
{
// Se crea el nuevo estado generado y se agrega a la Tabla T de estados del AFD
newTrans = new TransicionAFD();
newTrans.estado = STATUS_VALUES[STATUS_INDEX];
STATUS_INDEX++;
newTrans.componentes = listaEstados;
newTrans.marca = false;
newTrans.aceptacion = aceptacion;
nuevosEstadosAutomata.Add(newTrans);
// Se añade la funcion de transición a la lista de funciones de transición del AFD
TransicionAFD newTrans2 = new TransicionAFD();
newTrans2.estado = estadoActual.estado;
newTrans2.simbolo = simbolo;
newTrans2.proximoEstado = newTrans.estado;
newTrans2.componentes = estadoActual.componentes;
newTrans2.aceptacion = estadoActual.aceptacion;
funcionesTransicionAutomata.Add(newTrans2);
}
else
{
// Se añade la funcion de transición a la lista de funciones de transición del AFD
newTrans = new TransicionAFD();
newTrans.estado = estadoActual.estado;
newTrans.simbolo = simbolo;
newTrans.proximoEstado = posibleNuevoEstado.estado;
newTrans.componentes = estadoActual.componentes;
newTrans.aceptacion = aceptacion;
funcionesTransicionAutomata.Add(newTrans);
}
}
estadosSinMarcar = nuevosEstadosAutomata.Where(q => q.marca == false).ToList();
} while (estadosSinMarcar.Count > 0);
funcionesTransicionAFD = nuevosEstadosAutomata;
return(funcionesTransicionAutomata);
}
