public void Should_check_grammar_for_chomsky_normal_form()
        {
            var grammar = new ContextFreeGrammar("S");
            grammar.Produce("S", "t1", "t2", "t3");

            Assert.That(grammar.IsInChomskyNormalForm, Is.False);
        }
 public void Should_not_allow_creation_of_topdown_parser_with_invalid_grammar()
 {
     Assert.That(() =>
     {
         var grammar = new ContextFreeGrammar("S");
         grammar.Produce("S", "A", "B");
         new TopDownParser(grammar);
     }, Throws.ArgumentException);
 }
        public void Should_delete_all_occurrences_of_variable_if_it_produces_only_epsilon()
        {
            var grammar = new ContextFreeGrammar("S")
                .Produce("S", "vA", "t1")
                .Produce("A")
                .ToChomskyNormalForm();
            Debug.WriteLine(grammar);

            Assert.That(grammar.Variables, Has.None.EqualTo(new Variable("A")));
        }
 public void BeforeEveryTest()
 {
     _grammar = new ContextFreeGrammar("S");
     _grammar.Produce("S");
     _grammar.Produce("S", "t2");
     _grammar.Produce("S", "vA", "vT");
     _grammar.Produce("A", "t0");
     _grammar.Produce("A", "t1");
     _grammar.Produce("T", "vS", "vB");
     _grammar.Produce("B", "t1");
 }
        public void BeforeEveryTest()
        {
            var grammar = new ContextFreeGrammar('S');
            grammar.Produce("S", "t2");
            grammar.Produce("S", "vA", "vT");
            grammar.Produce("A", "t0");
            grammar.Produce("T", "vS", "vB");
            grammar.Produce("B", "t1");

            _parser = new TopDownParser(grammar);
        }
        public void Should_eliminate_all_epsilon_rules_when_converting_grammer_to_chomsky_normal_form()
        {
            var grammar = new ContextFreeGrammar("S");
            grammar.Produce("S", "vA", "vB");
            grammar.Produce("A", "t0");
            grammar.Produce("B");
            grammar.Produce("B", "t1");

            var cnf = grammar.ToChomskyNormalForm();
            var rules = cnf.GetRules("B");

            Assert.That(rules, Has.None.Empty);
        }
Example #7
0
        private static void CYKTest()
        {
            string[] nonterminals = new[] { "S" },
                    terminals = new[] { "0", "1" };
            string starting = "S";
            ProductionInfo[] rules = new[] { new ProductionInfo("S", new[] {"0", "S", "1"}),
                                             new ProductionInfo("S", new string[] {}) };

            var contextFreeGrammar = new ContextFreeGrammar(nonterminals, terminals, rules, starting);
            var normalForm = contextFreeGrammar.GetChomskyNormalForm();

            string[] sentence1 = new[] { "0", "1", "1", "0", "0", "0" },
                     sentence2 = new[] { "0", "0", "0", "1", "1", "1" };
            Debug.Assert(!normalForm.HasSentence(sentence1));
            Debug.Assert(normalForm.HasSentence(sentence2));
        }
Example #8
0
        private static void GrammarTest()
        {
            string[] nonterminals = new[] { "S" },
                    terminals = new[] { "0", "1" };
            string starting = "S";
            ProductionInfo[] rules = new[] { new ProductionInfo("S", new string[] {}),
                                        new ProductionInfo("S", new[] { "0", "S", "1"}),
                                        new ProductionInfo("S", new[] { "0", "S", "1"}) };

            try
            {
                var grammar = new ContextFreeGrammar(nonterminals, terminals, rules, starting);
            }
            catch (ArgumentException ex)
            {
                Debug.Assert(ex.Message == "Rules cannot contain duplicates.");
            }
        }
Example #9
0
        public static void Main()
        {
            var grammer = new ContextFreeGrammar("S")
                .Produce("S", "vA", "t1", "vA")
                .Produce("A")
                .Produce("A", "vS")
                .Produce("A", "vA", "t0", "vS")
                .Produce("A", "vS", "t0", "vA");

            Console.WriteLine(grammer);
            TopDownParser parser = grammer;

            Console.WriteLine(grammer.ToChomskyNormalForm().ToString());

            Measure.AndDisplayPerformance("comparison", () =>
            {
                Console.Write("Starting comparison.. ");

                var allWords1 = Permute.AllWordsOver(7, '0', '1').Where(w => w.Where(c => c == '0').Count() < w.Where(c => c == '1').Count()).ToArray();
                var allWords2 = parser.Language(7).ToArray();

                foreach (var word in allWords1)
                {
                    if (!allWords2.Contains(word))
                    {
                        Console.WriteLine("Word {0} not enumerated.", word);
                    }

                    if (!parser.Compute(word))
                    {
                        Console.WriteLine("Word {0} not accepted.", word);
                    }
                }

                Console.WriteLine("Finished.");
            });

            Console.ReadKey(true);

            var stopwatch = Stopwatch.StartNew();
            parser.Compute("001101110");
            Console.WriteLine("Computing '001101110' took {0} ms.", stopwatch.ElapsedMilliseconds);

            //Console.ReadKey(true);

            var performance = Measure.Performance(() => {
            foreach (var word in parser.Language(8))
            {
                var zeros = word.Where(c => c == '0').Count();
                var ones = word.Where(c => c == '1').Count();

                if (ones <= zeros)
                    throw new ArgumentException();

                Console.WriteLine(word);
            }});

            Console.WriteLine("Enumeration took {0} ms", performance.TotalMilliseconds);

            //Console.ReadKey(true);
        }
        public void Should_eliminate_all_unit_rules_when_converting_grammer_to_chomsky_normal_form()
        {
            var grammar = new ContextFreeGrammar("S");
            grammar.Produce("S", "vA", "vB");
            grammar.Produce("A", "vB");
            grammar.Produce("B", "t1");

            var cnf = grammar.ToChomskyNormalForm();
            var rules = cnf.GetRules("A");

            Debug.WriteLine(cnf);

            Assert.That(rules.Single().Single(), Is.Not.EqualTo(new Variable("B")));
        }
 public void Should_determine_wheter_grammar_does_not_accept_empty_word()
 {
     var grammar = new ContextFreeGrammar("S").Produce("S", "t1");
     Assert.That(grammar.AcceptsEmptyWord, Is.False);
 }
 public void Should_determine_wheter_grammar_accepts_empty_word()
 {
     var grammar = new ContextFreeGrammar("S").Produce("S");
     Assert.That(grammar.AcceptsEmptyWord, Is.True);
 }
 public void Should_not_allow_creation_of_recursive_unit_rules()
 {
     var grammar = new ContextFreeGrammar("S");
     Assert.That(() => grammar.Produce("S", "vS"), Throws.Exception);
 }
 public void Should_not_convert_grammar_to_chomsky_normal_form_if_it_is_already_in_chomsky_normal_form()
 {
     var grammar = new ContextFreeGrammar("S");
     Assert.That(grammar.IsInChomskyNormalForm, Is.True);
     Assert.That(grammar.ToChomskyNormalForm(), Is.SameAs(grammar));
 }
        public void Should_transform_all_rules_into_proper_form_when_converting_grammer_to_chomsky_normal_form()
        {
            var grammar = new ContextFreeGrammar("S");
            grammar.Produce("S", "t1", "t2", "t3");

            var cnf = grammar.ToChomskyNormalForm();
            var rules = cnf.GetRules("S");

            Assert.That(rules.Select(r => r.ToList()), Has.All.Count.LessThanOrEqualTo(2));
        }
        public void Should_replace_epsilon_rules_occurences_one_by_one()
        {
            var grammar = new ContextFreeGrammar("S")
                .Produce("S", "vA", "t1", "vA")
                .Produce("A")
                .Produce("A", "t1")
                .ToChomskyNormalForm();
            Debug.WriteLine(grammar);

            var any = grammar.GetRules(grammar.StartVariable).Any(r => r.First().Equals(new Variable("A")));
            Assert.That(any, Is.True);
        }
        public void Should_not_produce_unit_rules_when_transforming_grammar_to_chomsky_normal_form()
        {
            var grammar = new ContextFreeGrammar("S")
                .Produce("S", "vA")
                .Produce("A", "t1")
                .ToChomskyNormalForm();
            Debug.WriteLine(grammar);

            var existsUnitRules = grammar.GetRules(grammar.StartVariable).Any(r => r.Count() == 1 && r.Single() is Variable);
            Assert.That(existsUnitRules, Is.False);
        }