コード例 #1
0
ファイル: RuleTests.cs プロジェクト: bbriggs/machine
        public void Apply()
        {
            var pattern = Pattern<AnnotatedStringData, int>.New()
                .Group("leftEnv", leftEnv => leftEnv
                    .Annotation(FeatureStruct.New(PhoneticFeatSys)
                        .Symbol(Seg)
                        .Symbol("cons+")
                        .Feature("voice").EqualToVariable("a").Value))
                .Group("target", target => target
                    .Annotation(FeatureStruct.New(PhoneticFeatSys)
                        .Symbol(Seg)
                        .Symbol("cons-")
                        .Symbol("low+").Value))
                .Group("rightEnv", rightEnv => rightEnv
                    .Annotation(FeatureStruct.New(PhoneticFeatSys)
                        .Symbol(Seg)
                        .Symbol("cons+")
                        .Feature("voice").Not.EqualToVariable("a").Value)).Value;

            var ruleSpec = new DefaultPatternRuleSpec<AnnotatedStringData, int>(pattern, (PatternRule<AnnotatedStringData, int> r, Match<AnnotatedStringData, int> match, out AnnotatedStringData output) =>
                                              	{
                                                    GroupCapture<int> target = match.GroupCaptures["target"];
                                              		foreach (Annotation<int> ann in match.Input.Annotations.GetNodes(target.Span))
                                              			ann.FeatureStruct.PriorityUnion(FeatureStruct.New(PhoneticFeatSys).Symbol("low-").Value);
                                              		output = match.Input;
                                              		return target.Span.End;
                                              	});

            var rule = new PatternRule<AnnotatedStringData, int>(SpanFactory, ruleSpec);
            AnnotatedStringData inputWord = CreateStringData("fazk");
            Assert.IsTrue(rule.Apply(inputWord).Any());
        }
コード例 #2
0
ファイル: RuleTest.cs プロジェクト: FieldDB/machine
        public void Apply()
        {
            var pattern = Pattern <StringData, int> .New()
                          .Group("leftEnv", leftEnv => leftEnv
                                 .Annotation(FeatureStruct.New(PhoneticFeatSys)
                                             .Symbol(Seg)
                                             .Symbol("cons+")
                                             .Feature("voice").EqualToVariable("a").Value))
                          .Group("target", target => target
                                 .Annotation(FeatureStruct.New(PhoneticFeatSys)
                                             .Symbol(Seg)
                                             .Symbol("cons-")
                                             .Symbol("low+").Value))
                          .Group("rightEnv", rightEnv => rightEnv
                                 .Annotation(FeatureStruct.New(PhoneticFeatSys)
                                             .Symbol(Seg)
                                             .Symbol("cons+")
                                             .Feature("voice").Not.EqualToVariable("a").Value)).Value;

            var ruleSpec = new DefaultPatternRuleSpec <StringData, int>(pattern, (PatternRule <StringData, int> r, Match <StringData, int> match, out StringData output) =>
            {
                GroupCapture <int> target = match.GroupCaptures["target"];
                foreach (Annotation <int> ann in match.Input.Annotations.GetNodes(target.Span))
                {
                    ann.FeatureStruct.PriorityUnion(FeatureStruct.New(PhoneticFeatSys).Symbol("low-").Value);
                }
                output = match.Input;
                return(target.Span.End);
            });

            var        rule      = new PatternRule <StringData, int>(SpanFactory, ruleSpec);
            StringData inputWord = CreateStringData("fazk");

            Assert.IsTrue(rule.Apply(inputWord).Any());
        }
コード例 #3
0
        public void Batch()
        {
            var pattern = Pattern <AnnotatedStringData, int> .New()
                          .Group("leftEnv", leftEnv => leftEnv
                                 .Annotation(FeatureStruct.New(PhoneticFeatSys)
                                             .Symbol(Seg)
                                             .Symbol("cons+")
                                             .Feature("voice").EqualToVariable("a").Value))
                          .Group("target", target => target
                                 .Annotation(FeatureStruct.New(PhoneticFeatSys)
                                             .Symbol(Seg)
                                             .Symbol("cons-")
                                             .Symbol("low+").Value))
                          .Group("rightEnv", rightEnv => rightEnv
                                 .Annotation(FeatureStruct.New(PhoneticFeatSys)
                                             .Symbol(Seg)
                                             .Symbol("cons+")
                                             .Feature("voice").Not.EqualToVariable("a").Value)).Value;

            var ruleSpec1 = new DefaultPatternRuleSpec <AnnotatedStringData, int>(pattern, (r, match) =>
            {
                GroupCapture <int> target = match.GroupCaptures["target"];
                foreach (Annotation <int> ann in match.Input.Annotations.GetNodes(target.Span))
                {
                    ann.FeatureStruct.PriorityUnion(FeatureStruct.New(PhoneticFeatSys)
                                                    .Symbol("low-")
                                                    .Symbol("mid-").Value);
                }
                return(match.Input);
            },
                                                                                  input => input.Annotations.Single(ann => ((FeatureSymbol)ann.FeatureStruct.GetValue(Type)) == Word)
                                                                                  .FeatureStruct.IsUnifiable(FeatureStruct.New(WordFeatSys).Symbol("verb").Value));

            var ruleSpec2 = new DefaultPatternRuleSpec <AnnotatedStringData, int>(pattern, (r, match) =>
            {
                GroupCapture <int> target = match.GroupCaptures["target"];
                foreach (Annotation <int> ann in match.Input.Annotations.GetNodes(target.Span))
                {
                    ann.FeatureStruct.PriorityUnion(FeatureStruct.New(PhoneticFeatSys)
                                                    .Symbol("low-")
                                                    .Symbol("mid+").Value);
                }
                return(match.Input);
            });

            var batchSpec = new BatchPatternRuleSpec <AnnotatedStringData, int>(new[] { ruleSpec1, ruleSpec2 });
            var rule      = new PatternRule <AnnotatedStringData, int>(SpanFactory, batchSpec);
            AnnotatedStringData inputWord = CreateStringData("fazk");

            inputWord.Annotations.Add(inputWord.Span, FeatureStruct.New(WordFeatSys).Symbol(Word).Symbol("noun").Value);
            Assert.IsTrue(rule.Apply(inputWord).Any());
        }
コード例 #4
0
ファイル: RuleTests.cs プロジェクト: sillsdev/machine
        public void Batch()
        {
            var pattern = Pattern<AnnotatedStringData, int>.New()
                .Group("leftEnv", leftEnv => leftEnv
                    .Annotation(FeatureStruct.New(PhoneticFeatSys)
                        .Symbol(Seg)
                        .Symbol("cons+")
                        .Feature("voice").EqualToVariable("a").Value))
                .Group("target", target => target
                    .Annotation(FeatureStruct.New(PhoneticFeatSys)
                        .Symbol(Seg)
                        .Symbol("cons-")
                        .Symbol("low+").Value))
                .Group("rightEnv", rightEnv => rightEnv
                    .Annotation(FeatureStruct.New(PhoneticFeatSys)
                        .Symbol(Seg)
                        .Symbol("cons+")
                        .Feature("voice").Not.EqualToVariable("a").Value)).Value;

            var ruleSpec1 = new DefaultPatternRuleSpec<AnnotatedStringData, int>(pattern, (r, match) =>
                {
                    GroupCapture<int> target = match.GroupCaptures["target"];
                    foreach (Annotation<int> ann in match.Input.Annotations.GetNodes(target.Span))
                        ann.FeatureStruct.PriorityUnion(FeatureStruct.New(PhoneticFeatSys)
                            .Symbol("low-")
                            .Symbol("mid-").Value);
                    return match.Input;
                },
                input => input.Annotations.Single(ann => ((FeatureSymbol) ann.FeatureStruct.GetValue(Type)) == Word)
                    .FeatureStruct.IsUnifiable(FeatureStruct.New(WordFeatSys).Symbol("verb").Value));

            var ruleSpec2 = new DefaultPatternRuleSpec<AnnotatedStringData, int>(pattern, (r, match) =>
                {
                    GroupCapture<int> target = match.GroupCaptures["target"];
                    foreach (Annotation<int> ann in match.Input.Annotations.GetNodes(target.Span))
                        ann.FeatureStruct.PriorityUnion(FeatureStruct.New(PhoneticFeatSys)
                            .Symbol("low-")
                            .Symbol("mid+").Value);
                    return match.Input;
                });

            var batchSpec = new BatchPatternRuleSpec<AnnotatedStringData, int>(new[] {ruleSpec1, ruleSpec2});
            var rule = new PatternRule<AnnotatedStringData, int>(SpanFactory, batchSpec);
            AnnotatedStringData inputWord = CreateStringData("fazk");
            inputWord.Annotations.Add(inputWord.Span, FeatureStruct.New(WordFeatSys).Symbol(Word).Symbol("noun").Value);
            Assert.IsTrue(rule.Apply(inputWord).Any());
        }