Example #1
0
    private static SubrulesTokenChanges RemoveWorstPaths(ParsedSequence seq, int end, SubrulesTokenChanges parses, out TokenChanges comulativeMin)
    {
      var comulativeCost = new SubrulesTokenChanges();
      bool updated = true;
      while (updated)
      {
        updated = false;
        foreach (var parse in parses)
        {
          var subrule = parse.Key;
          TokenChanges oldCount;
          if (!comulativeCost.TryGetValue(subrule, out oldCount))
            updated = true;
          TokenChanges min;
          if (seq.StartPos == subrule.Begin && seq.ParsingSequence.StartStates.Contains(subrule.State))
            min = new TokenChanges();
          else
          {
            min = TokenChanges.Fail;
            TokenChanges prevCount;
            foreach (var prevSubrule in seq.GetPrevSubrules(subrule, parses.Keys))
              if (comulativeCost.TryGetValue(prevSubrule, out prevCount))
                min = TokenChanges.Min(min, prevCount);
          }
          var newCount = AddOrFail(min, parses[subrule]);
          comulativeCost[subrule] = newCount;
          updated = updated || oldCount != newCount;
        }
      }

      var toProcess = new SCG.Queue<ParsedSubrule>(seq.GetLastSubrules(parses.Keys, end));
      var comulativeMin2 = toProcess.Min(s => comulativeCost[s]);
      comulativeMin = comulativeMin2;
      toProcess = new SCG.Queue<ParsedSubrule>(toProcess.Where(s => comulativeCost[s] == comulativeMin2));
      var good = new SubrulesTokenChanges();
      while (toProcess.Count > 0)
      {
        var subrule = toProcess.Dequeue();
        if (good.ContainsKey(subrule))
          continue;
        good.Add(subrule, parses[subrule]);
        var prev = seq.GetPrevSubrules(subrule, parses.Keys).ToList();
        if (prev.Count > 0)
        {
          TokenChanges min;
          if (seq.StartPos == subrule.Begin && seq.ParsingSequence.StartStates.Contains(subrule.State))
            min = new TokenChanges();
          else
            min = prev.Min(s => comulativeCost[s]);
          foreach (var prevSubrule in prev)
            if (comulativeCost[prevSubrule] == min)
              toProcess.Enqueue(prevSubrule);
        }
      }
      return good;
    }
Example #2
0
        private static SubrulesTokenChanges RemoveWorstPaths(ParsedSequence seq, int end, SubrulesTokenChanges parses, out TokenChanges comulativeMin)
        {
            var  comulativeCost = new SubrulesTokenChanges();
            bool updated        = true;

            while (updated)
            {
                updated = false;
                foreach (var parse in parses)
                {
                    var          subrule = parse.Key;
                    TokenChanges oldCount;
                    if (!comulativeCost.TryGetValue(subrule, out oldCount))
                    {
                        updated = true;
                    }
                    TokenChanges min;
                    if (seq.StartPos == subrule.Begin && seq.ParsingSequence.StartStates.Contains(subrule.State))
                    {
                        min = new TokenChanges();
                    }
                    else
                    {
                        min = TokenChanges.Fail;
                        TokenChanges prevCount;
                        foreach (var prevSubrule in seq.GetPrevSubrules(subrule, parses.Keys))
                        {
                            if (comulativeCost.TryGetValue(prevSubrule, out prevCount))
                            {
                                min = TokenChanges.Min(min, prevCount);
                            }
                        }
                    }
                    var newCount = AddOrFail(min, parses[subrule]);
                    comulativeCost[subrule] = newCount;
                    updated = updated || oldCount != newCount;
                }
            }

            var toProcess      = new SCG.Queue <ParsedSubrule>(seq.GetLastSubrules(parses.Keys, end));
            var comulativeMin2 = toProcess.Min(s => comulativeCost[s]);

            comulativeMin = comulativeMin2;
            toProcess     = new SCG.Queue <ParsedSubrule>(toProcess.Where(s => comulativeCost[s] == comulativeMin2));
            var good = new SubrulesTokenChanges();

            while (toProcess.Count > 0)
            {
                var subrule = toProcess.Dequeue();
                if (good.ContainsKey(subrule))
                {
                    continue;
                }
                good.Add(subrule, parses[subrule]);
                var prev = seq.GetPrevSubrules(subrule, parses.Keys).ToList();
                if (prev.Count > 0)
                {
                    TokenChanges min;
                    if (seq.StartPos == subrule.Begin && seq.ParsingSequence.StartStates.Contains(subrule.State))
                    {
                        min = new TokenChanges();
                    }
                    else
                    {
                        min = prev.Min(s => comulativeCost[s]);
                    }
                    foreach (var prevSubrule in prev)
                    {
                        if (comulativeCost[prevSubrule] == min)
                        {
                            toProcess.Enqueue(prevSubrule);
                        }
                    }
                }
            }
            return(good);
        }