Realiza un recorrido del autómata a partir de un Estado inicial y pasando por todas las Transiciones que

coincidan con determinado símbolo. inicios El Conjunto Estados a partir de los cuales
se realiza el recorrido. alcanzados Conjunto donde se guardan los Estados alcanzados.
símbolo Buscado Símbolo que debe seguirse en las Transición

//Automata.java
package afndaunafd.modelo;

import java.util.*;

public class Automata {

private String Nombre;

private int numEstados;
private int EstadoInicial;
private int EstadoActual;
private TreeSet<String> Alfabeto;
private TreeSet<Integer> estadoFinal;
private TreeSet<Integer>[][] TablaTransiciones;

public Automata() {
super();
Alfabeto = new TreeSet<String>();
estadoFinal = new TreeSet<Integer>();

public Automata(String nombre, int nEstados, TreeSet<String> alfabeto, int q0,

TreeSet<Integer> qend, TreeSet<Integer>[][] tablaTransiciones) {
super();
Nombre = nombre;
this.numEstados = nEstados;
Alfabeto = alfabeto;
this.EstadoInicial = q0;
estadoFinal = qend;
TablaTransiciones = tablaTransiciones;
}

public String getNombre() {

return Nombre;
}

public void setNombre(String nombre) {

Nombre = nombre;
}

public int getnumEstados() {

return numEstados;
}

public void setnumEstados(int nEstados) {

 this.numEstados = nEstados;
}

public TreeSet<String> getAlfabeto() {

return Alfabeto;
}

public void setAlfabeto(TreeSet<String> alfabeto) {

Alfabeto = alfabeto;
}

public int getEstadoInicial() {

return EstadoInicial;
}

public void setEstadoInicial(int q0) {

this.EstadoInicial = q0;
}

public TreeSet<Integer> getestadoFinal() {

return estadoFinal;
}

public void setestadoFinal(TreeSet<Integer> qend) {

estadoFinal = qend;
}

public TreeSet<Integer>[][] getTablaTransiciones() {

return TablaTransiciones;
}

public void setTablaTransiciones(TreeSet<Integer>[][] tablaTransiciones) {

TablaTransiciones = tablaTransiciones;
}

public void addEstadoFinal(int q) {

estadoFinal.add(q);
}

public int getEstadoActual() {

return EstadoActual;
}

@SuppressWarnings("unchecked")
public void addLetraAlfabeto(String letra) {
Alfabeto.add(letra);
TablaTransiciones = new TreeSet[numEstados][Alfabeto.size()];
iniciarTablaTransiciones();
}

private void iniciarTablaTransiciones() {

for (int x = 0; x < numEstados; x++) {
 for (int y = 0; y < Alfabeto.size(); y++) {
TablaTransiciones[x][y] = new TreeSet<Integer>();
}
}
}

public void addTransicion(int q0, String e, int q1) {

Vector<String> a = new Vector<String>();
a.addAll(Alfabeto);
TablaTransiciones[q0][a.indexOf(e)].add(q1);
}

public boolean analizarPalabra(String palabra) {

EstadoActual = EstadoInicial;
String[] letras = palabra.split("");

for (String l : letras) {

if (!l.equals("")) {
EstadoActual = funcion(EstadoActual, l);
if (EstadoActual == -1) {
return false;
}
}
}
if (estadoFinal.contains(EstadoActual)) {
return true;
}

return false;
}

private int funcion(int estadoActual, String e) {

Vector<String> a = new Vector<String>();
a.addAll(Alfabeto);
if (TablaTransiciones[estadoActual][a.indexOf(e)].isEmpty()) {
return -1;
} else {
return TablaTransiciones[estadoActual][a.indexOf(e)].first();
}

}
}
//Transformador.java
package afndaunafd.modelo;

import java.util.Stack;
import java.util.TreeSet;
import java.util.Vector;

import javax.swing.JOptionPane;

//Esta clase implementa las clases para implementar las conversiones de afnd a afd

public class Transformador {

private String nombre;

private int numestados;
private int estadoInicial;
private TreeSet<String> alfabeto;
private TreeSet<Integer> estadoFinal;
private TreeSet<Integer>[][] tabtrans;

/* Implementación de código fuente para verificar las transiciones vacías, quitadas. Tambien
para verificar si el autómata ya es determinista*/

public Automata minimizar(Automata automata) {

nombre = automata.getNombre();
numestados = automata.getnumEstados();
alfabeto = automata.getAlfabeto();
estadoInicial = automata.getEstadoInicial();
estadoFinal = automata.getestadoFinal();
tabtrans = automata.getTablaTransiciones();

if (alfabeto.contains("E")) {
JOptionPane.showMessageDialog(null, "Quitando tranciciones vacias");

quitarTansicionesVacias();
JOptionPane.showMessageDialog(null, "tranciciones vacias quitadas");

} else {
JOptionPane.showMessageDialog(null, "no tiene tranciciones vacias");

}
if (noEsDeterminista()) {
JOptionPane.showMessageDialog(null, "Quitando indeterminismo");

quitarIndeterminismo();
 JOptionPane.showMessageDialog(null, "Indeterminismo quitado");

} else {
JOptionPane.showMessageDialog(null, "Ya es determinista");

while (!verificarMinimo()) {
minimizar();
}
JOptionPane.showMessageDialog(null, "Es minimo");

return new Automata(nombre, numestados, alfabeto, estadoInicial, estadoFinal,

tabtrans);

/*Conversion de determinista a determinista*/

private void quitarIndeterminismo() {

Vector<TreeSet> nuevosEstados = new Vector<TreeSet>();

TreeSet<Integer> ts;
TreeSet<Integer> ts2;

TreeSet<Integer> c = new TreeSet<Integer>();

c.add(0);
nuevosEstados.add(c);

for (String s : alfabeto) {

for (int cont = 0; cont < numestados; cont++) {
ts = obtenerTransicion(cont, s);
if (ts.size() != 0 && !nuevosEstados.contains(ts)) {
nuevosEstados.add(ts);
}
}
}
Vector<TreeSet> temporal = (Vector<TreeSet>) nuevosEstados.clone();

for (TreeSet<Integer> t : temporal) {

ts2 = new TreeSet<Integer>();
for (String s : alfabeto) {
for (Integer i : t) {
ts2.addAll(obtenerTransicion(i, s));
}
if (ts2.size() != 0 && !nuevosEstados.contains(ts2)) {
nuevosEstados.add(ts2);
}
}
}

TreeSet<Integer>[][] tablaaux = new TreeSet[nuevosEstados.size()][alfabeto.size()];

 TreeSet<Integer> tranO, tran;
for (String s : alfabeto) {
for (TreeSet<Integer> t : nuevosEstados) {
tranO = new TreeSet<Integer>();
tran = new TreeSet<Integer>();
for (Integer i : t) {
tranO.addAll(obtenerTransicion(i, s));
}

///-nuevo
if (nuevosEstados.indexOf(tranO) != -1) {
tran.add(nuevosEstados.indexOf(tranO));
}

Vector<String> a = new Vector<String>();

a.addAll(alfabeto);
tablaaux[nuevosEstados.indexOf(t)][a.indexOf(s)] = tran;
}
}

TreeSet<Integer> finales = new TreeSet<Integer>();

for (TreeSet<Integer> t : nuevosEstados) {

for (Integer i : estadoFinal) {
if (t.contains(i)) {
finales.add(nuevosEstados.indexOf(t));
}
}
}

numestados = nuevosEstados.size();
estadoFinal = finales;
tabtrans = tablaaux;
System.out.println();
}
/* Verifica si la expression es determinista*/
private boolean noEsDeterminista() {
boolean b = false;
TreeSet<Integer> ts = new TreeSet<Integer>();
for (String s : alfabeto) {
for (int cont = 0; cont < numestados; cont++) {
ts = obtenerTransicion(cont, s);
if (ts != null && ts.size() > 1) {
b = true;
}
}
}
return b;
}
/*Implementa la operación Cerradura Épsilon sobre un Conjunto de Estados parámetros
estados Conjunto de Estados sobre el cual aplicar operación retorna El Conjunto de estados
alcanzados y cerrando todas las vacias
*/

private void quitarTansicionesVacias() {

TreeSet<Integer> tran;
TreeSet<Integer> clau;
TreeSet<Integer> clau2;

TreeSet<String> alfabetoTemp = (TreeSet<String>) alfabeto.clone();

alfabetoTemp.remove("E");
TreeSet<Integer>[][] tablatransicionesTemp = new TreeSet[numestados]
[alfabetoTemp.size()];

for (int a = 0; a < alfabetoTemp.size(); a++) {

for (int q = 0; q < numestados; q++) {
tablatransicionesTemp[q][a] = new TreeSet<Integer>();
}

for (String s : alfabeto) {

if (!s.equals("E")) {
for (int cont = 0; cont < numestados; cont++) {
//System.out.print(cont + " "+s+" -");

tran = new TreeSet<Integer>();

clau = cerrarVacias(cont);
clau2 = new TreeSet<Integer>();
for (Integer i : clau) {
tran.addAll(obtenerTransicion(i.intValue(), s));
}
for (Integer i : tran) {
clau2.addAll(cerrarVacias(i.intValue()));

Vector<String> a = new Vector<String>();

a.addAll(alfabetoTemp);
tablatransicionesTemp[cont][a.indexOf(s)].addAll(clau2);
}
}
}
}

TreeSet<Integer> f = cerrarVacias(estadoInicial);
boolean cq0F = false;

for (Integer i : estadoFinal) {

if (f.contains(i)) {
cq0F = true;
}
}
 if (cq0F) {
estadoFinal.add(estadoInicial);
}
alfabeto = alfabetoTemp;
tabtrans = tablatransicionesTemp;

System.out.println();
}

private TreeSet<Integer> cerrarVacias(int q) {

TreeSet<Integer> cierre = new TreeSet<Integer>();
TreeSet<Integer> ts = new TreeSet<Integer>();
Stack<TreeSet<Integer>> pila = new Stack<TreeSet<Integer>>();
pila.push(obtenerTransicion(q, "E"));
cierre.add(q);

while (!pila.isEmpty()) {
ts = pila.pop();

for (Integer i : ts) {

if (!cierre.contains(i.intValue())) {
pila.push(obtenerTransicion(i.intValue(), "E"));
}
}
cierre.addAll(ts);
}
return cierre;
}

/* Buscar transiciones por cada símbolo */

private TreeSet<Integer> obtenerTransicion(int q0, String e) {

Vector<String> a = new Vector<String>();
a.addAll(alfabeto);
return tabtrans[q0][a.indexOf(e)];
}

/*Verifica el minimo de el numero de estados desde el final hasta el inicial del alfabeto
ingresado

private boolean verificarMinimo() {

boolean f = true;

int[][] estados = new int[numestados][numestados];

TreeSet<Integer> r;
TreeSet<Integer> t;
int y;
int x;
int tamaño = 0;
for (int cont = 1; cont < numestados; cont++) {
 for (int cont2 = 0; cont2 < cont; cont2++) {
if ((estadoFinal.contains(cont) && !estadoFinal.contains(cont2)) ||
(estadoFinal.contains(cont2) && !estadoFinal.contains(cont))) {
estados[cont][cont2] = 1;
}
tamaño = 0;
for (String s : alfabeto) {
r = obtenerTransicion(cont, s);
t = obtenerTransicion(cont2, s);
if (r.size() > 0 && t.size() > 0) {
tamaño++;
y = r.first().intValue();
x = t.first().intValue();

if (x < y) {
if (estados[y][x] == 1) {
estados[cont][cont2] = 1;
}
} else {
if (estados[x][y] == 1) {
estados[cont][cont2] = 1;
}
}
if (y != x) {
estados[cont][cont2] = 1;
}
}
}
if (tamaño != alfabeto.size()) {
estados[cont][cont2] = 1;
}
}
}

for (int cont = 1; cont < numestados; cont++) {

for (int cont2 = 0; cont2 < cont; cont2++) {
if (estados[cont][cont2] == 0) {
f = false;
}
}
}

return f;

/**Realiza un recorrido del autómata a partir de un Estado inicial y pasando por todas las
Transiciones que coincidan con determinado símbolo Este algoritmo corresponde a una
generalización del algoritmo de que el mismo pueda utilizarse para las dos operaciones de
Cerradura**/

private void minimizar() {

 int[][] estados = new int[numestados][numestados];
TreeSet<Integer> r;
TreeSet<Integer> t;
int x;
int y;
int tamaño = 0;
for (int cont = 1; cont < numestados; cont++) {
for (int cont2 = 0; cont2 < cont; cont2++) {
if ((estadoFinal.contains(cont) && !estadoFinal.contains(cont2)) ||
(estadoFinal.contains(cont2) && !estadoFinal.contains(cont))) {
estados[cont][cont2] = 1;
}
tamaño = 0;
for (String s : alfabeto) {
r = obtenerTransicion(cont, s);
t = obtenerTransicion(cont2, s);
if (r.size() > 0 && t.size() > 0) {
tamaño++;
x = r.first().intValue();
y = t.first().intValue();

if (y < x) {
if (estados[x][y] == 1) {
estados[cont][cont2] = 1;
}
} else {
if (estados[y][x] == 1) {
estados[cont][cont2] = 1;
}
}
if (x != y) {
estados[cont][cont2] = 1;
}
}
}
if (tamaño != alfabeto.size()) {
estados[cont][cont2] = 1;
}
}
}
Vector<TreeSet> vector = new Vector<TreeSet>();
TreeSet<Integer> ts;
boolean f;

for (int cont = 1; cont < numestados; cont++) {

for (int cont2 = 0; cont2 < cont; cont2++) {
if (estados[cont][cont2] == 0) {
ts = new TreeSet<Integer>();
f = true;

ts.add(cont);
 ts.add(cont2);

for (TreeSet<Integer> tsmod : vector) {

if (tsmod.contains(cont) || tsmod.contains(cont)) {
tsmod.addAll(ts);
f = false;
}
}
if (f) {
vector.add(ts);
}
}
}
}

f = true;

for (int cont = 0; cont < numestados; cont++) {

f = true;
for (TreeSet<Integer> tsmod : vector) {
if (tsmod.contains(cont)) {
f = false;
}
}
if (f) {
ts = new TreeSet<Integer>();
ts.add(cont);
vector.add(ts);
}
}

TreeSet<Integer>[][] tablaTemp = new TreeSet[vector.size()][alfabeto.size()];

TreeSet<Integer> tran;
int t0;
TreeSet<Integer> t1;
for (String s : alfabeto) {
for (TreeSet<Integer> tsi : vector) {
tran = new TreeSet<Integer>();
for (Integer i : tsi) {
tran.addAll(obtenerTransicion(i, s));
}

t0 = vector.indexOf(tsi);
t1 = new TreeSet<Integer>();
for (TreeSet<Integer> tsi2 : vector) {
if (tran.size() > 0 && tsi2.containsAll(tran)) {
t1.add(vector.indexOf(tsi2));
}
}

Vector<String> a = new Vector<String>();

 a.addAll(alfabeto);
tablaTemp[t0][a.indexOf(s)] = t1;

}
}

TreeSet<Integer> finales = new TreeSet<Integer>();

int q00 = estadoInicial;

for (TreeSet<Integer> i : vector) {

if (i.contains(estadoInicial)) {
q00 = vector.indexOf(i);
}

for (Integer ii : estadoFinal) {

if (i.contains(ii)) {
finales.add(vector.indexOf(i));
}
}
}

estadoInicial = q00;
numestados = vector.size();
estadoFinal = finales;
tabtrans = tablaTemp;

System.out.println();

}
}