C# Column.AddState方法代码示例

        private void Complete(Column col, State state)
        {
            if (state.Rule.Name.NonTerminal == GammaRule)
            {
                col.GammaStates.Add(state);
                return;
            }

            foreach (var st in state.StartColumn)
            {
                var term = st.NextProductionTerm();
                NonTerminalStack intersection;
                if (IsCompletedTermConsistentWithNextTerm(state.Rule.Name, term, out intersection))
                {
                    if (state.Node.LogProbability < 0)
                    {
                        throw new LogException(
                            string.Format(
                                "trrrr! NODE log probability lower than 0: {0}, reductor state: {1}, predecessor state {2}",
                                state.Node.LogProbability, state, st));
                    }
                    var y = State.MakeNode(st, state.EndColumn.Index, state.Node);
                    var newState = new State(st.Rule, st.DotIndex + 1, st.StartColumn, y);
                    newState.Rule.Production[st.DotIndex].Stack = intersection;

                    col.AddState(newState, ParsingOperation.Complete);
                    if (Debug)
                        Console.WriteLine("{0} & {1} & {2} & Completed from States {3} and {4}\\\\",
                            newState.StateNumber,
                            newState, col.Index, st.StateNumber, state.StateNumber);
                }
            }
        }

        private void Predict(Column col, List<Rule> ruleList, State state, NonTerminalObject currObject)
        {
            if (generator)
            {
                var rule = Grammar.GetRandomRuleForAGivenLHS(currObject.NonTerminal, true);
                ruleList = new List<Rule> {rule};
            }

            foreach (var rule in ruleList)
            {
                //TODO: change later to skip -all- rules whose derivation leads to the empty string.
                //I.e,  A-> B.C , C -> D E. D -> epsilon, E -> epsilon. C itself is not an epsilon rule.
                if (rule.IsEpsilonRule() && Grammar.nullableProductions.ContainsKey(currObject))
                {
                    //states that are the result of a spontenous dot shift (due to nullable production) 
                    //have already been added to the agendas in Column.Add()
                    continue;
                }


                //if current stack is empty but predicted stack is not, mismatch - do not predict this rule.
                if (currObject.IsStackEmpty() && !rule.IsInitialOrDotStack()) continue;


                //prepare new rule based on the stack information contained in the current state
                //and based on the predicted rule.
                var createdRule = new Rule(rule);


                //if the rule is not a stack manipulating rule, 
                if (rule.IsInitialRule())
                {
                    var complementPositionObject = createdRule.Production[createdRule.ComplementPosition];

                    //if current stack is not empty, but the complement position does not allow for stacks (POS),
                    //mismatch - do not predict this rule.
                    if (!currObject.IsStackEmpty() && Grammar.IsPOS(complementPositionObject.NonTerminal)) continue;

                    //the stack of the LHS of the created rule is the stack of the current object:
                    createdRule.Name = currObject;

                    //copy the stack to the complement position.
                    complementPositionObject.Stack = currObject.Stack;
                }
                else
                {
                    if (createdRule.Name.Stack.Peek() != "." && currObject.Stack.Top != Grammar.Epsilon &&
                        currObject.Stack.Top != createdRule.Name.Stack.Peek())
                        continue;
                    //if tops of the stacks do not match, continue. e.g created rule PP[PP] -> epsilon, current object: PP[NP].

                    //create left hand side of new rule.
                    createdRule.Name.Stack = currObject.Stack;
                    createdRule.Name.NonTerminal = currObject.NonTerminal;

                    //create right hand side of new rule.
                    NonTerminalStack contentOfDot;
                    if (rule.Name.Stack.Peek() == ".")
                        contentOfDot = currObject.Stack; //e.g. A[..]
                    else
                        contentOfDot = currObject.Stack.GetPrefixListStackObjectOfGivenTop(rule.Name.Stack.Peek());
                            //e.g A[..X]

                    for (var i = 0; i < rule.Production.Length; i++)
                    {
                        var s = rule.Production[i].Stack;

                        if (s != null)
                        {
                            if (s.Peek() == ".")
                                createdRule.Production[i].Stack = contentOfDot; // e.g, A[..] pop rule.
                            else if (s.PrefixList == null)
                                createdRule.Production[i].Stack = s; //e.g. A[X] //secondary constituent.
                            else
                                createdRule.Production[i].Stack = new NonTerminalStack(s.Peek(), contentOfDot);
                            //e.g. A[..X] - push rule.

                            //calculate the new weight of the top of the stack from the weights of its sons.
                            //if (createdRule.Production[i].Stack != null)
                            //    createdRule.Production[i].Stack.Weight = createdRule.Production[i].Stack.PrefixList != null ? createdRule.Production[i].Stack.PrefixList.Sum(x => x.Weight) : 1;
                        }
                    }
                }


                var newState = new State(createdRule, 0, col, null) {LogProbability = ruleLogProbabilities[rule.Number]};

                if (newState.LogProbability < 0)
                    throw new Exception("wrong probability");

                var added = col.AddState(newState, ParsingOperation.Predict);

                if (Debug)
                    Console.WriteLine("{0} & {1} & {2} & Predicted from State {3}, added: {4}\\\\", newState.StateNumber,
                        newState,
                        col.Index, state.StateNumber, added);
            }
        }

        private void Scan(Column col, State state, string term, string token)
        {
            //if there is nonempty stack arriving to this part of speech term, stop here - the derivation is wrong.
            //SEFI - note: this is a restriction on the form of your grammar.
            //consider removing it to see the conequences.

            //if (Grammar.isPOS(term))
            {
                if (!state.NextProductionTerm().IsStackEmpty()) return;
            }

            var v = new Node(term, col.Index - 1, col.Index)
            {
                AssociatedTerminal = token,
                LogProbability = 0.0f,
                Bits = 1
            };
            var y = State.MakeNode(state, col.Index, v);
            var newState = new State(state.Rule, state.DotIndex + 1, state.StartColumn, y);

            col.AddState(newState, ParsingOperation.Scan);
            if (Debug)
                Console.WriteLine("{0} & {1} & {2} & Scanned from State {3}, word: {4}\\\\", newState.StateNumber,
                    newState, col.Index,
                    state.StateNumber, token);

            if (newState.Node.LogProbability < 0)
            {
                throw new LogException(string.Format("scanarrrr! NODE log probability lower than 0: {0}, state: {1}",
                    newState.Node.LogProbability, newState));
            }
        }