private void Simulacion_Tick(object sender, EventArgs e)
        {
            Nodo   nd = new Nodo();
            Arista a  = new Arista();

            if (contV < nodosV.Count)
            {
                if (autVerif.Count == contV)
                {
                    /*nd = new Nodo(nodosV[contV].name);
                     * nd.nivel = nodosV[contV].nivel;
                     * nd.centro = nodosV[contV].centro;
                     * nd.terminal = nodosV[contV].terminal;*/
                    autVerif.Add(nodosV[contV]);
                }
                else
                {
                    if (contV < AristasV.Count)
                    {
                        autVerif.Last().aristas.Add(AristasV[contV]);
                    }
                    contV++;
                }
            }
            else
            {
                foreach (Nodo n in nodosV)
                {
                    n.aristas.Clear();
                }
                foreach (Nodo n in autVerif)
                {
                    n.aristas.Clear();
                }
                autVerif.Clear();
                contV = 0;
            }
        }
Exemple #2
0
        public void GenerarArbol(string ER)
        {
            int contHojas = 1;

            this.Clear();
            Point       pos = new Point(0, 0);
            Nodo        nodo;
            Arista      a;
            List <Nodo> pila = new List <Nodo>();

            foreach (char c in ER)
            {
                if (char.IsLetter(c) || c == '#')
                {
                    nodo          = new Nodo(c.ToString());
                    pos.X        += 100;
                    nodo.centro   = pos;
                    nodo.anulable = false;
                    nodo.PrimeraPos.Add(contHojas);
                    nodo.UltimaPos.Add(contHojas);
                    contHojas++;
                    this.Add(nodo);
                    pila.Add(nodo);
                }
                else
                {
                    pos.Y -= 50;
                    if (c == '|' || c == '·')
                    {
                        nodo = new Nodo(c.ToString());

                        a         = new Arista();
                        a.destino = pila[pila.Count - 2];
                        nodo.aristas.Add(a);
                        pila.RemoveAt(pila.Count - 2);

                        a         = new Arista();
                        a.destino = pila[pila.Count - 1];
                        nodo.aristas.Add(a);
                        pila.RemoveAt(pila.Count - 1);
                        nodo.centro.X = (nodo.aristas[0].destino.centro.X + nodo.aristas[1].destino.centro.X) / 2;
                        nodo.centro.Y = pos.Y;
                        if (nodo.name == "|")
                        {
                            nodo.anulable = (nodo.aristas[0].destino.anulable || nodo.aristas[1].destino.anulable);
                            //Calculo de la primera y siguiente Posicion
                            nodo.PrimeraPos = nodo.aristas[0].destino.PrimeraPos.Union(nodo.aristas[1].destino.PrimeraPos).ToList();
                            nodo.UltimaPos  = nodo.aristas[0].destino.UltimaPos.Union(nodo.aristas[1].destino.UltimaPos).ToList();
                        }
                        else
                        {
                            nodo.anulable = (nodo.aristas[0].destino.anulable && nodo.aristas[1].destino.anulable);
                            //Calculo de la primera y siguiente Posicion
                            if (nodo.aristas[0].destino.anulable)
                            {
                                nodo.PrimeraPos = nodo.aristas[0].destino.PrimeraPos.Union(nodo.aristas[1].destino.PrimeraPos).ToList();
                            }
                            else
                            {
                                foreach (int i in nodo.aristas[0].destino.PrimeraPos)
                                {
                                    nodo.PrimeraPos.Add(i);
                                }
                            }

                            if (nodo.aristas[1].destino.anulable)
                            {
                                nodo.UltimaPos = nodo.aristas[0].destino.UltimaPos.Union(nodo.aristas[1].destino.UltimaPos).ToList();
                            }
                            else
                            {
                                foreach (int i in nodo.aristas[1].destino.UltimaPos)
                                {
                                    nodo.UltimaPos.Add(i);
                                }
                            }
                        }
                        pila.Add(nodo);
                        this.Add(nodo);
                    }
                    else
                    {
                        nodo      = new Nodo(c.ToString());
                        a         = new Arista();
                        a.destino = pila[pila.Count - 1];
                        nodo.aristas.Add(a);
                        pila.RemoveAt(pila.Count - 1);
                        nodo.centro.X = nodo.aristas[0].destino.centro.X;
                        nodo.centro.Y = pos.Y;

                        if (nodo.name == "+")
                        {
                            nodo.anulable = nodo.aristas[0].destino.anulable;
                        }
                        else
                        {
                            nodo.anulable = true;
                        }

                        //Calculo de la primera y siguiente Posicion
                        foreach (int i in nodo.aristas[0].destino.PrimeraPos)
                        {
                            nodo.PrimeraPos.Add(i);
                        }
                        foreach (int i in nodo.aristas[0].destino.UltimaPos)
                        {
                            nodo.UltimaPos.Add(i);
                        }

                        pila.Add(nodo);
                        this.Add(nodo);
                    }
                }
            }
            foreach (Nodo n in this)
            {
                n.centro.Y += Math.Abs(pos.Y - 40);
            }
        }
        private void Validar_Click(object sender, EventArgs e)
        {
            VerificaTick = false;
            foreach (Nodo n in nodosV)
            {
                n.aristas.Clear();
            }
            nodosV.Clear();
            AristasV.Clear();
            autVerif.Clear();
            contV = 0;
            Arista ar        = new Arista();
            Nodo   EdoActual = new Nodo();
            Nodo   nod       = new Nodo();
            bool   bandV     = true;

            EdoActual    = automata[0];
            nod          = new Nodo(EdoActual.name);
            nod.centro   = EdoActual.centro;
            nod.radio    = EdoActual.radio;
            nod.nivel    = EdoActual.nivel;
            nod.terminal = EdoActual.terminal;
            nodosV.Add(nod);
            string w = "";

            w = TextVer.Text;
            int contW = 0;

            if (w.Length > 0)
            {
                while (contW < w.Length && bandV)
                {
                    bandV = false;
                    foreach (Arista a in EdoActual.aristas)
                    {
                        if (a.nombre[0] == w[contW])
                        {
                            EdoActual    = a.destino;
                            nod          = new Nodo(EdoActual.name);
                            nod.centro   = EdoActual.centro;
                            nod.nivel    = EdoActual.nivel;
                            nod.terminal = EdoActual.terminal;
                            nod.radio    = EdoActual.radio;
                            ar           = new Arista();
                            ar.nombre    = a.nombre;
                            ar.destino   = nod;
                            AristasV.Add(ar);
                            nodosV.Add(nod);
                            contW++;
                            bandV = true;
                            break;
                        }
                    }
                }
                if (contW == w.Length && EdoActual.terminal)
                {
                    VerRes.Visible   = true;
                    VerRes.Text      = "Aceptada";
                    VerRes.BackColor = Color.Green;
                    wVerificada      = true;
                    Simular.Visible  = true;
                    Simular.Enabled  = true;
                }
                else
                {
                    VerRes.Visible   = true;
                    VerRes.Text      = "Error";
                    VerRes.BackColor = Color.Red;
                    wVerificada      = false;
                    Simular.Visible  = false;
                    Simular.Enabled  = false;
                }
            }
        }
        private void GeneraAutomata()
        {
            int term = 0;

            List <List <int> > posTerminales = new List <List <int> >();

            List <string> terminales = new List <string>();

            foreach (Nodo n in arbol)
            {
                if (n.name == "#")
                {
                    term = n.PrimeraPos[0];
                }
                if (char.IsLetter(n.name[0]))
                {
                    if (!terminales.Contains(n.name))
                    {
                        terminales.Add(n.name);
                    }
                }
            }

            Nodo dest   = new Nodo();
            char nombre = 'A';
            bool rep    = false;

            Nodo nodo = new Nodo(nombre.ToString());

            automata.Add(nodo);
            nombre++;
            foreach (int i in arbol.Last().PrimeraPos)
            {
                nodo.conjunto.Add(i);
            }
            if (nodo.conjunto.Contains(term))
            {
                nodo.terminal = true;
            }

            for (int i = 0; i < automata.Count; i++)
            {
                foreach (string s in terminales)
                {
                    rep = false;
                    estado.Clear();
                    foreach (int x in automata[i].conjunto)
                    {
                        PuedeLlegar(x, s);
                    }
                    if (estado.Count > 0)
                    {
                        foreach (Nodo nd in automata)
                        {
                            if (EstadoExistente(estado, nd.conjunto))
                            {
                                rep  = true;
                                dest = nd;
                                break;
                            }
                        }
                        if (rep)
                        {
                            Arista a = new Arista();
                            a.destino = dest;
                            a.nombre  = s;
                            automata[i].aristas.Add(a);
                        }
                        else
                        {
                            nodo = new Nodo(nombre.ToString());
                            nombre++;
                            foreach (int j in estado)
                            {
                                nodo.conjunto.Add(j);
                            }
                            if (nodo.conjunto.Contains(term))
                            {
                                nodo.terminal = true;
                            }
                            automata.Add(nodo);

                            Arista a = new Arista();
                            a.nombre  = s;
                            a.destino = nodo;
                            automata[i].aristas.Add(a);
                        }
                    }
                }
            }
        }