Beispiel #1
0
        //построить Delta-правила ДКА
        public void BuildDeltaDKAutomate(myAutomate ndka)
        {
            this.Sigma     = ndka.Sigma;
            this.DeltaList = ndka.DeltaList;
            ArrayList currState = EpsClosure(new ArrayList()
            {
                ndka.Q0
            });

            //Debug("step 1", currState);

            config.Add(SetName(currState));
            //Debug("name",SetName(currState));
            Dtran(currState);
            this.Q         = config;
            this.Q0        = this.Q[0].ToString();
            this.DeltaList = DeltaD;
            this.F         = getF(config, ndka.F);

            /*  this.Q = makeNames(config);
             *  this.Q0 = this.Q[0].ToString();
             *  this.DeltaList = NameRules(DeltaD);
             *  this.F = makeNames(getF(config, ndka.F));*/
        }
Beispiel #2
0
        //Lina Veltman course work
        public myAutomate Transform()
        {
            ArrayList Q = this.V;

            Q.Add("qf");
            string    q0 = this.S0;
            ArrayList F  = new ArrayList();

            //Конструируем множество заключительных состояний
            foreach (Prule p in this.Prules)
            {
                //Если начальный символ переходит в конечную цепочку,
                //то в множество F добавляется начальный символ S0 и состояние qf
                // F = {S0, qf}
                if (p.LeftNoTerm.Contains("S0") && p.RightChain.Contains("e"))
                {
                    F = new ArrayList {
                        p.LeftNoTerm, "qf"
                    };
                    break;
                }
                //Иначе F = {qf} множество F(конечных состояний) будет состоять из одного состояния qf
                else if (p.LeftNoTerm.Contains("S0"))
                {
                    F = new ArrayList {
                        "qf"
                    };
                    break;
                }
            }

            //Конструируем конечный автомат
            myAutomate KA   = new myAutomate(Q, this.T, F, q0);
            bool       flag = true;

            foreach (Prule p in this.Prules)
            {
                //Если существует правило порождения,
                //в котором из начального символа существует переход в пустую цепочку,
                //то создаем правило (S0, "e", "qf")
                if (flag && p.LeftNoTerm.Contains("S0") && p.RightChain.Contains("e"))
                {
                    KA.AddRule(p.LeftNoTerm, "e", "qf");
                    flag = false;
                }
                //Проходим по всем входным символам
                foreach (string t in this.T)
                {
                    //Если справа есть символ и этот символ терминал,
                    //то добавляем правило (Нетерминал -> (Терминал,  "qf"))
                    if (p.RightChain.Contains(t) && NoTermReturn(p.RightChain) == null)
                    {
                        KA.AddRule(p.LeftNoTerm, t, "qf");
                    }
                    //Если справа есть символ и этот символ нетерминал,
                    //то добавляем правило (Нетерминал -> (Терминал, Нетерминал))
                    else if (p.RightChain.Contains(t) && NoTermReturn(p.RightChain) != null)
                    {
                        KA.AddRule(p.LeftNoTerm, t, NoTerminal(p.RightChain));
                    }
                }
            }
            return(KA);
        }