コード例 #1
0
        public Automata uninion(Automata afn1, Automata afn2)
        {
            Automata afn_union   = new Automata();
            Estado   nuevoinicio = new Estado(0);

            nuevoinicio.setTransiciones(new Transicion(nuevoinicio, afn2.getEstadoInicial(), Form1.EPSILON));
            afn_union.addEstados(nuevoinicio);
            afn_union.setEstadoInicial(nuevoinicio);
            int i = 0;

            for (i = 0; i < afn1.getEstados().Count; i++)
            {
                Estado tmp = (Estado)afn1.getEstados()[i];
                tmp.setId(i + 1);
                afn_union.addEstados(tmp);
            }
            for (int j = 0; j < afn2.getEstados().Count; j++)
            {
                Estado tmp = (Estado)afn2.getEstados()[j];
                tmp.setId(i + 1);
                afn_union.addEstados(tmp);
                i++;
            }

            Estado nuevoFin = new Estado(afn1.getEstados().Count + afn2.getEstados().Count + 1);

            afn_union.addEstados(nuevoFin);
            afn_union.addEstadosAceptacion(nuevoFin);

            Estado    anteriorInicio = afn1.getEstadoInicial();
            ArrayList anteriorFin    = afn1.getEstadosAceptacion();
            ArrayList anteriorFin2   = afn2.getEstadosAceptacion();

            nuevoinicio.getTransiciones().Add(new Transicion(nuevoinicio, anteriorInicio, Form1.EPSILON));
            //Console.Write(anteriorFin[0]);
            for (int k = 0; k < anteriorFin.Count; k++)
            {
                Estado aux = (Estado)anteriorFin[k];
                aux.getTransiciones().Add(new Transicion((Estado)anteriorFin[k], nuevoFin, Form1.EPSILON));
            }

            for (int k = 0; k < anteriorFin.Count; k++)
            {
                Estado aux = (Estado)anteriorFin2[k];
                aux.getTransiciones().Add(new Transicion((Estado)anteriorFin2[k], nuevoFin, Form1.EPSILON));
            }

            HashSet <string> alfabeto = new HashSet <string>(afn1.getAlfabeto());

            alfabeto.UnionWith(afn2.getAlfabeto());
            afn_union.setAlfabeto(alfabeto);
            afn_union.setLenguajeR(afn1.getLenguajeR() + " " + afn2.getLenguajeR());
            return(afn_union);
        }
コード例 #2
0
        public Automata Term(string simbolo)
        {
            Automata   afn        = new Automata();
            Estado     inicial    = new Estado(0);
            Estado     aceptacion = new Estado(1);
            Transicion tran       = new Transicion(inicial, aceptacion, simbolo);

            inicial.setTransiciones(tran);
            afn.addEstados(inicial);
            afn.addEstados(aceptacion);
            afn.setInicial(inicial);
            afn.addEstadosAceptacion(aceptacion);
            afn.setLenguajeR(simbolo + " ");
            return(afn);
        }
コード例 #3
0
        public Automata concatenacion(Automata afn1, Automata afn2)
        {
            Automata afn_concat = new Automata();
            int      i          = 0;

            for (i = 0; i < afn2.getEstados().Count; i++)
            {
                Estado temp = (Estado)afn2.getEstados()[i];
                temp.setId(i);
                if (i == 0)
                {
                    afn_concat.setEstadoInicial(temp);
                }
                if (i == afn2.getEstados().Count - 1)
                {
                    for (int k = 0; k < afn2.getEstadosAceptacion().Count; k++)
                    {
                        temp.setTransiciones(new Transicion((Estado)afn2.getEstadosAceptacion()[k], afn1.getEstadoInicial(), Form1.EPSILON));
                    }
                }
                afn_concat.addEstados(temp);
            }

            for (int j = 0; j < afn1.getEstados().Count; j++)
            {
                Estado tmp = (Estado)afn1.getEstados()[j];
                tmp.setId(i);

                //define el ultimo con estado de aceptacion
                if (afn1.getEstados().Count - 1 == j)
                {
                    afn_concat.addEstadosAceptacion(tmp);
                }
                afn_concat.addEstados(tmp);
                i++;
            }
            HashSet <string> alfabeto = new HashSet <string>(afn1.getAlfabeto());

            //alfabeto.Union(afn1.getAlfabeto());
            alfabeto.UnionWith(afn2.getAlfabeto());
            afn_concat.setAlfabeto(alfabeto);
            afn_concat.setLenguajeR(afn1.getLenguajeR() + " " + afn2.getLenguajeR());
            return(afn_concat);
        }
コード例 #4
0
        public void makeAFD()
        {
            Automata automata = new Automata();
            Queue <HashSet <Estado> > cola = new Queue <HashSet <Estado> > ();
            Estado inicial = new Estado(0);

            automata.setInicial(inicial);
            automata.addEstados(inicial);
            HashSet <Estado> arrayInicial = cerradura.metodoCerradura(this.AFN.getEstadoInicial());

            foreach (Estado item in this.AFN.getEstadosAceptacion())
            {
                foreach (Estado estado in arrayInicial)
                {
                    //Console.WriteLine("La primer cerradura es: " + estado.id);
                    if (estado.id.Equals(item.id))
                    {
                        automata.addEstadosAceptacion(inicial);
                    }
                }
            }

            cola.Enqueue(arrayInicial);
            ArrayList temp  = new ArrayList();
            int       index = 0;

            while (cola.Count != 0)
            {
                HashSet <Estado> aux = cola.Dequeue();

                foreach (string item in this.AFN.getAlfabeto())
                {
                    HashSet <Estado> moveresponse = cerradura.mover(aux, item);
                    HashSet <Estado> result       = new HashSet <Estado>();
                    foreach (Estado est in moveresponse)
                    {
                        result.UnionWith(cerradura.metodoCerradura(est));
                    }
                    Estado prev                = (Estado)automata.getEstados()[index];
                    string auxstring           = "";
                    IEnumerable <Estado> query = result.OrderBy(results => results.id);
                    foreach (Estado auxestado in query)
                    {
                        //auxarraestado.Add(auxestado.id.ToString());
                        auxstring += auxestado.id.ToString();
                    }
                    if (result.Count != 0)
                    {
                        if (temp.Contains(auxstring))
                        {
                            //Console.WriteLine("if dentro del primer if");
                            ArrayList prevarray = automata.getEstados();
                            Estado    oldstate  = prev;
                            Estado    nextstate = (Estado)prevarray[temp.IndexOf(auxstring) + 1];
                            //Console.WriteLine(temp.IndexOf(auxstring)+"de if");
                            oldstate.setTransiciones(new Transicion(oldstate, nextstate, item));
                        }
                        else
                        {
                            //Console.WriteLine("if con el eslse adentro");
                            temp.Add(auxstring);
                            cola.Enqueue(result);
                            Estado nuevo = new Estado(temp.IndexOf(auxstring) + 1);
                            //Console.WriteLine(temp.IndexOf(auxstring) + "del else");
                            prev.setTransiciones(new Transicion(prev, nuevo, item));
                            automata.addEstados(nuevo);
                            foreach (Estado aceptacion in this.AFN.getEstadosAceptacion())
                            {
                                foreach (Estado es in result)
                                {
                                    //Console.WriteLine(aceptacion.id + " del afd "+es.id);
                                    if (es.id.Equals(aceptacion.id))
                                    {
                                        automata.addEstadosAceptacion(nuevo);
                                    }
                                }
                            }
                        }
                    }
                }
                index++;
            }
            this.AFD = automata;
            this.AFD.setAlfabeto(this.AFN.getAlfabeto());
            this.AFD.setTipo("AFD");
        }