Esempio n. 1
0
        public void IsMorpheme()
        {
            Pattern pattern = EnglishPattern.Morpheme(EnglishAttributes.A);

            Assert.IsTrue(pattern.IsMorpheme);

            // Empty string rule causes it is not the morpheme pattern.
            pattern = new Pattern()
            {
                UpRule    = EnglishMorphemeRule.Is("", EnglishAttributes.A.Lexeme),
                LeftRule  = MorphemeRule.Nothing,
                RightRule = MorphemeRule.Nothing,
            };
            Assert.IsFalse(pattern.IsMorpheme);


            // Right and left rule is not Nothing - it is not the morpheme rule.
            pattern = new Pattern()
            {
                UpRule    = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.E.Lexeme),
                LeftRule  = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.I.Lexeme),
                RightRule = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.O.Lexeme),
            };
            Assert.IsFalse(pattern.IsMorpheme);
        }
Esempio n. 2
0
        public void IsPrimitiveTransference()
        {
            Pattern pattern = new Pattern()
            {
                UpRule    = EnglishMorphemeRule.Is("", EnglishAttributes.A.Lexeme),
                LeftRule  = MorphemeRule.Nothing,
                RightRule = EnglishMorphemeRule.O_Lexeme,
            };

            Assert.IsTrue(pattern.IsMonoTransference);

            pattern = new Pattern()
            {
                UpRule    = EnglishMorphemeRule.Is("", EnglishAttributes.A.Lexeme),
                LeftRule  = EnglishMorphemeRule.Is("s", EnglishAttributes.A.NonLexeme.Prefix),
                RightRule = EnglishMorphemeRule.O_Lexeme,
            };
            Assert.IsFalse(pattern.IsMonoTransference);

            pattern = new Pattern()
            {
                UpRule    = MorphemeRule.Epsilon,
                LeftRule  = EnglishMorphemeRule.A_Lexeme,
                RightRule = EnglishMorphemeRule.O_Lexeme,
            };
            Assert.IsFalse(pattern.IsMonoTransference);
        }
Esempio n. 3
0
 public static Pattern Morpheme(BigInteger attributes, string patternName, string description) => new Pattern(patternName)
 {
     Description = description,
     UpRule      = EnglishMorphemeRule.Is(MorphRules.Something, attributes),
     LeftRule    = MorphemeRule.Nothing,
     RightRule   = MorphemeRule.Nothing,
 };
Esempio n. 4
0
        public void IsEpsilonAdPosition()
        {
            Pattern pattern = EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A, EnglishAttributes.O);

            Assert.IsTrue(pattern.IsEpsilonAdPosition());


            pattern = new Pattern("A-U-A")
            {
                // Grammar character is not epsilon -> it is not epsilon adposition.
                UpRule    = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.U),
                LeftRule  = EnglishMorphemeRule.A_Lexeme,
                RightRule = EnglishMorphemeRule.A_Lexeme,
            };
            Assert.IsFalse(pattern.IsEpsilonAdPosition());


            pattern = new Pattern("A-O")
            {
                UpRule = MorphemeRule.Epsilon,
                // It is not epsilon adposition.
                LeftRule  = MorphemeRule.Nothing,
                RightRule = EnglishMorphemeRule.O_Lexeme,
            };
            Assert.IsFalse(pattern.IsEpsilonAdPosition());
        }
Esempio n. 5
0
        public void I_read()
        {
            List <Morpheme> morphemes = new List <Morpheme>()
            {
                new Morpheme(myAttributesModel, "i", EnglishAttributes.O.Lexeme.Pronoun),
                new Morpheme(myAttributesModel, "read", EnglishAttributes.I.Lexeme.Verb.Valency.Bivalent),
                new Morpheme(myAttributesModel, ".", EnglishAttributes.U.NonLexeme.PunctuationMark.Period)
            };

            List <Pattern> patterns = new List <Pattern>()
            {
                EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme),
                EnglishPattern.Morpheme(EnglishAttributes.I.Lexeme),

                EnglishPattern.O1_I.SetLeftFirst(),

                new Pattern(".")
                {
                    UpRule    = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.U.NonLexeme.PunctuationMark.Period),
                    LeftRule  = MorphemeRule.Anything,
                    RightRule = EnglishMorphemeRule.I_Lexeme,
                },
            };

            ConstructiveDictionary dictionary = new ConstructiveDictionary(myAttributesModel, morphemes, patterns);
            AdTreeCreator          creator    = new AdTreeCreator(dictionary);

            List <IAdTree> results = creator.Create("i", "read", ".");

            Assert.AreEqual(1, results.Count);
            Assert.IsTrue(results[0].Right.Left.Morpheme.Morph == "i" && results[0].Right.Left.Morpheme.GrammarCharacter == GrammarCharacter.O);
            Assert.IsTrue(results[0].Right.Right.Morpheme.Morph == "read" && results[0].Right.Right.Morpheme.GrammarCharacter == GrammarCharacter.I);
            Assert.IsTrue(results[0].Right.Morpheme.Morph == "" && results[0].Right.Morpheme.GrammarCharacter == GrammarCharacter.e);
            Assert.IsTrue(results[0].Morpheme.Morph == "." && results[0].Morpheme.GrammarCharacter == GrammarCharacter.U);
        }
Esempio n. 6
0
 public static Pattern MorphematicAdPosition(string patternName, string description, BigInteger morphemeAttributes, BigInteger leftAttributes, BigInteger rightAttributes)
 => new Pattern(patternName)
 {
     Description = description,
     UpRule      = EnglishMorphemeRule.Is(MorphRules.Something, morphemeAttributes),
     LeftRule    = EnglishMorphemeRule.Is(MorphRules.Something, leftAttributes),
     RightRule   = EnglishMorphemeRule.Is(MorphRules.Something, rightAttributes),
 };
Esempio n. 7
0
 public static Pattern MonoTransference(string patternName, BigInteger morphemeAttributes, BigInteger rightAttributes)
 => new Pattern(patternName)
 {
     Description = "Rule which changes grammar characters.",
     UpRule      = EnglishMorphemeRule.Is("", morphemeAttributes),
     LeftRule    = MorphemeRule.Nothing,
     RightRule   = EnglishMorphemeRule.Is(MorphRules.Something, rightAttributes),
 };
Esempio n. 8
0
 public static Pattern PairTransference(string patternName, string description, BigInteger morphemeAttributes, MorphemeRule leftRule, MorphemeRule rightRule)
 => new Pattern(patternName)
 {
     Description = description,
     UpRule      = EnglishMorphemeRule.Is("", morphemeAttributes),
     LeftRule    = leftRule,
     RightRule   = rightRule,
 };
Esempio n. 9
0
 public static Pattern PairTransference(string patternName, string description, BigInteger morphemeAttributes, BigInteger leftAttributes, BigInteger notLeftAttributes, BigInteger rightAttributes, BigInteger notRightAttributes)
 => new Pattern(patternName)
 {
     Description = description,
     UpRule      = EnglishMorphemeRule.Is("", morphemeAttributes),
     LeftRule    = EnglishMorphemeRule.Is(MorphRules.Something, leftAttributes, notLeftAttributes),
     RightRule   = EnglishMorphemeRule.Is(MorphRules.Something, rightAttributes, notRightAttributes),
 };
Esempio n. 10
0
        public void I_have_been_reading()
        {
            List <Morpheme> morphemes = new List <Morpheme>()
            {
                new Morpheme(myAttributesModel, "i", EnglishAttributes.O.Lexeme.Pronoun),
                new Morpheme(myAttributesModel, "have", EnglishAttributes.I.Lexeme.Verb),
                new Morpheme(myAttributesModel, "been", EnglishAttributes.I.Lexeme.Verb.Sememe.Tense.Past | EnglishAttributes.I.Lexeme.Verb.Form.PastParticiple),
                new Morpheme(myAttributesModel, "read", EnglishAttributes.I.Lexeme.Verb.Valency.Bivalent),
                new Morpheme(myAttributesModel, "ing", EnglishAttributes.I.NonLexeme.Suffix.Sememe.Aspect.Continuous),
            };

            List <Pattern> patterns = new List <Pattern>()
            {
                EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme),
                EnglishPattern.Morpheme(EnglishAttributes.I.Lexeme),

                EnglishPattern.O1_I.SetLeftFirst(),

                EnglishPattern.Morpheme(EnglishAttributes.I.NonLexeme.Suffix, "I+"),

                EnglishPattern.PairTransference("I>PresentPerfect", "",
                                                EnglishAttributes.I.Lexeme.Verb.Sememe.Tense.Present | EnglishAttributes.I.Lexeme.Verb.Sememe.Aspect.Perfect,
                                                EnglishMorphemeRule.Is(MorphRules.Is("have"), EnglishAttributes.I.Lexeme.Verb).SetSubstitution(SubstitutionRules.Nothing),
                                                EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.I.Lexeme.Verb.Form.PastParticiple))
                .SetLeftFirst(),

                EnglishPattern.PairTransference("been-I_ing", "",
                                                EnglishAttributes.I.Lexeme.Verb.Form.PastParticiple,
                                                EnglishMorphemeRule.Is("been", EnglishAttributes.I.Lexeme.Verb.Sememe.Tense.Past | EnglishAttributes.I.Lexeme.Verb.Form.PastParticiple).SetSubstitution(SubstitutionRules.Nothing),
                                                EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.I.Lexeme.Verb.Sememe.Aspect.Continuous))
                .SetLeftFirst(),

                EnglishPattern.PairTransference("I>I_ing", "",
                                                EnglishAttributes.I.Lexeme.Verb.Sememe.Aspect.Continuous,
                                                EnglishAttributes.I.NonLexeme.Suffix.Sememe.Aspect.Continuous, 0,
                                                EnglishAttributes.I.Lexeme.Verb, EnglishAttributes.I.Lexeme.Verb.Modal),
            };

            ConstructiveDictionary dictionary = new ConstructiveDictionary(myAttributesModel, morphemes, patterns);

            AdTreeCreator  creator = new AdTreeCreator(dictionary);
            List <IAdTree> results = creator.Create("i", "have", "been", "reading");

            Assert.AreEqual(1, results.Count);

            Assert.AreEqual("i", results[0].Left.Morpheme.Morph);
            Assert.AreEqual("have", results[0].Right.Left.Morpheme.Morph);
            Assert.AreEqual("been", results[0].Right.Right.Left.Morpheme.Morph);
            Assert.AreEqual("ing", results[0].Right.Right.Right.Left.Morpheme.Morph);
            Assert.AreEqual("read", results[0].Right.Right.Right.Right.Morpheme.Morph);
        }
Esempio n. 11
0
        public void The_world_as_you_know_ends()
        {
            List <Morpheme> morphemes = new List <Morpheme>()
            {
                // Lexemes.
                new Morpheme(myAttributesModel, "the", EnglishAttributes.A.Lexeme.Determiner),
                new Morpheme(myAttributesModel, "world", EnglishAttributes.O.Lexeme.Noun),
                new Morpheme(myAttributesModel, "as", EnglishAttributes.U.Lexeme.Conjunction),
                new Morpheme(myAttributesModel, "you", EnglishAttributes.O.Lexeme.Pronoun),
                new Morpheme(myAttributesModel, "know", EnglishAttributes.I.Lexeme.Verb.Valency.Bivalent),
                new Morpheme(myAttributesModel, "ends", EnglishAttributes.I.Lexeme.Verb.Valency.Monovalent),
            };

            List <Pattern> patterns = new List <Pattern>()
            {
                EnglishPattern.Morpheme(EnglishAttributes.O.Lexeme),
                EnglishPattern.Morpheme(EnglishAttributes.I.Lexeme),
                EnglishPattern.Morpheme(EnglishAttributes.A.Lexeme),

                EnglishPattern.O1_I.SetLeftFirst(),

                EnglishPattern.EpsilonAdPosition("A-O", "", EnglishAttributes.A.Lexeme, EnglishAttributes.O.Lexeme)
                .SetLeftFirst()
                .SetSubstitutionForRight(SubstitutionRules.Epsilon),

                new Pattern("I-U-O")
                {
                    UpRule    = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.U.Lexeme.Conjunction),
                    LeftRule  = EnglishMorphemeRule.I_Lexeme,
                    RightRule = EnglishMorphemeRule.O_Lexeme,
                },
            };

            ConstructiveDictionary dictionary = new ConstructiveDictionary(myAttributesModel, morphemes, patterns);

            AdTreeCreator  creator = new AdTreeCreator(dictionary);
            List <IAdTree> results = creator.Create("the", "world", "as", "you", "know", "ends");

            Assert.AreEqual(1, results.Count);
            Assert.AreEqual("the", results[0].Left.Right.Left.Morpheme.Morph);
            Assert.AreEqual("world", results[0].Left.Right.Right.Morpheme.Morph);
            Assert.AreEqual("as", results[0].Left.Morpheme.Morph);
            Assert.AreEqual("you", results[0].Left.Left.Left.Morpheme.Morph);
            Assert.AreEqual("know", results[0].Left.Left.Right.Morpheme.Morph);
            Assert.AreEqual("ends", results[0].Right.Morpheme.Morph);
        }
Esempio n. 12
0
        public void CanAttachToLeft_Substitution()
        {
            IAdTree adTree = new AdTree(Morpheme.Epsilon(myAttributesModel),
                                        new Pattern()
            {
                LeftRule = EnglishMorphemeRule.O_Lexeme,
            }
                                        );
            IAdTree adTreeElement = new AdTree(Morpheme.Epsilon(myAttributesModel),
                                               new Pattern()
            {
                UpRule = MorphemeRule.Epsilon, LeftRule = EnglishMorphemeRule.A_Lexeme, RightRule = EnglishMorphemeRule.O_Lexeme
            })
            {
                Right = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme),
                                   new Pattern()
                {
                    UpRule = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.O.Lexeme)
                }),
            };

            Assert.IsTrue(adTree.CanAttachToLeft(adTreeElement, myAttributesModel));


            // Substitution is not allowed.
            adTree = new AdTree(Morpheme.Epsilon(myAttributesModel),
                                new Pattern()
            {
                LeftRule = EnglishMorphemeRule.O_Lexeme,
            }.SetSubstitutionForLeft(SubstitutionRules.Nothing)
                                );
            adTreeElement = new AdTree(Morpheme.Epsilon(myAttributesModel),
                                       new Pattern()
            {
                UpRule = MorphemeRule.Epsilon, LeftRule = EnglishMorphemeRule.A_Lexeme, RightRule = EnglishMorphemeRule.O_Lexeme
            })
            {
                Right = new AdTree(new Morpheme(myAttributesModel, "car", EnglishAttributes.O.Lexeme),
                                   new Pattern()
                {
                    UpRule = EnglishMorphemeRule.Is(MorphRules.Something, EnglishAttributes.O.Lexeme)
                }),
            };
            Assert.IsFalse(adTree.CanAttachToLeft(adTreeElement, myAttributesModel));
        }