public override Word ApplyRhs(PatternRule <Word, ShapeNode> rule, Match <Word, ShapeNode> match)
{
Word output = match.Input.Clone();
GenerateShape(_allomorph.Lhs, output.Shape, match);
return(output);
}
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());
}
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());
}
public Word ApplyRhs(PatternRule <Word, ShapeNode> rule, Match <Word, ShapeNode> match)
{
Word output = match.Input.DeepClone();
output.Shape.Clear();
var existingMorphNodes = new Dictionary <Annotation <ShapeNode>, List <ShapeNode> >();
var newMorphNodes = new List <ShapeNode>();
foreach (MorphologicalOutputAction outputAction in _allomorph.Rhs)
{
foreach (Tuple <ShapeNode, ShapeNode> mapping in outputAction.Apply(match, output))
{
if (mapping.Item1 != null && _nonAllomorphActions.Contains(outputAction))
{
if (mapping.Item1.Annotation.Parent != null)
{
Annotation <ShapeNode> morph = mapping.Item1.Annotation.Parent;
existingMorphNodes.GetValue(morph, () => new List <ShapeNode>()).Add(mapping.Item2);
}
}
else
{
newMorphNodes.Add(mapping.Item2);
}
}
}
Annotation <ShapeNode> outputNewMorph = MarkMorphs(newMorphNodes, output, _allomorph);
var markedAllomorphs = new HashSet <Allomorph>();
foreach (Annotation <ShapeNode> inputMorph in match.Input.Morphs)
{
Allomorph allomorph = match.Input.GetAllomorph(inputMorph);
List <ShapeNode> nodes;
if (existingMorphNodes.TryGetValue(inputMorph, out nodes))
{
Annotation <ShapeNode> outputMorph = MarkMorphs(nodes, output, allomorph);
MarkSubsumedMorphs(match.Input, output, inputMorph, outputMorph);
}
else if (inputMorph.Parent == null && !markedAllomorphs.Contains(allomorph))
{
// an existing morph has been completely subsumed by the new morph
// mark the subsumed morph so we don't lose track of it
// this is only necessary if the allomorph hasn't already been marked elsewhere
Annotation <ShapeNode> outputMorph = output.MarkSubsumedMorph(outputNewMorph, allomorph);
MarkSubsumedMorphs(match.Input, output, inputMorph, outputMorph);
}
markedAllomorphs.Add(allomorph);
}
output.MprFeatures.AddOutput(_allomorph.OutMprFeatures);
return(output);
}
public override Word ApplyRhs(PatternRule <Word, ShapeNode> rule, Match <Word, ShapeNode> match)
{
Word output = match.Input.DeepClone();
GenerateShape(_subrule.HeadLhs, output.Shape, match);
var nonHeadShape = new Shape(rule.SpanFactory, begin => new ShapeNode(rule.SpanFactory, begin ? HCFeatureSystem.LeftSideAnchor : HCFeatureSystem.RightSideAnchor));
GenerateShape(_subrule.NonHeadLhs, nonHeadShape, match);
output.NonHeadUnapplied(new Word(output.Stratum, nonHeadShape));
return(output);
}
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());
}
public Word ApplyRhs(PatternRule <Word, ShapeNode> rule, Match <Word, ShapeNode> match)
{
Word output = match.Input.Clone();
output.Shape.Clear();
var existingMorphNodes = new Dictionary <Allomorph, List <ShapeNode> >();
var newMorphNodes = new List <ShapeNode>();
foreach (MorphologicalOutputAction outputAction in _allomorph.Rhs)
{
foreach (Tuple <ShapeNode, ShapeNode> mapping in outputAction.Apply(match, output))
{
if (mapping.Item1 != null && _nonAllomorphActions.Contains(outputAction))
{
if (mapping.Item1.Annotation.Parent != null)
{
Allomorph allomorph = match.Input.GetAllomorph(mapping.Item1.Annotation.Parent);
existingMorphNodes.GetOrCreate(allomorph, () => new List <ShapeNode>()).Add(mapping.Item2);
}
}
else
{
newMorphNodes.Add(mapping.Item2);
}
}
}
Annotation <ShapeNode> outputNewMorph = output.MarkMorph(newMorphNodes, _allomorph);
foreach (Annotation <ShapeNode> inputMorph in match.Input.Morphs)
{
Allomorph allomorph = match.Input.GetAllomorph(inputMorph);
List <ShapeNode> nodes;
if (existingMorphNodes.TryGetValue(allomorph, out nodes))
{
Annotation <ShapeNode> outputMorph = output.MarkMorph(nodes, allomorph);
MarkSubsumedMorphs(match.Input, output, inputMorph, outputMorph);
}
else if (inputMorph.Parent == null)
{
Annotation <ShapeNode> outputMorph = output.MarkSubsumedMorph(outputNewMorph, allomorph);
MarkSubsumedMorphs(match.Input, output, inputMorph, outputMorph);
}
}
output.MprFeatures.AddOutput(_allomorph.OutMprFeatures);
return(output);
}
private Word MarkStem(PatternRule <Word, ShapeNode> rule, Match <Word, ShapeNode> match)
{
Word output = match.Input;
Annotation <ShapeNode> stemAnn = output.Stem;
int index = 0;
foreach (ShapeNode node in output.Shape)
{
int len = node.OriginalStrRep().Length;
bool finished = false;
switch (rule.Matcher.Direction)
{
case Direction.LeftToRight:
if (node == match.Range.End.Next)
{
output.StemIndex = index;
}
if (node == stemAnn.Range.End)
{
output.StemLength = index + len - output.StemIndex;
finished = true;
}
break;
case Direction.RightToLeft:
if (node == stemAnn.Range.Start)
{
output.StemIndex = index;
}
if (node == match.Range.Start.Prev)
{
output.StemLength = index + len - output.StemIndex;
finished = true;
}
break;
}
if (finished)
{
break;
}
index += len;
}
_segmenter.Segment(output);
return(output);
}
private void StemWords(Direction dir, IEnumerable <Word> words, IEnumerable <Affix> affixes)
{
var ruleSpec = new BatchPatternRuleSpec <Word, ShapeNode>();
foreach (Affix affix in affixes)
{
var pattern = new Pattern <Word, ShapeNode> {
Acceptable = CheckStemWholeWord
};
if (dir == Direction.LeftToRight)
{
pattern.Children.Add(new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.AnchorType).Value));
}
foreach (ShapeNode node in affix.Shape)
{
pattern.Children.Add(new Quantifier <Word, ShapeNode>(0, 1, new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.BoundaryType).Value)));
pattern.Children.Add(new Constraint <Word, ShapeNode>(node.Annotation.FeatureStruct.Clone()));
pattern.Children.Add(new Quantifier <Word, ShapeNode>(0, 1, new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.ToneLetterType).Value)));
}
if (dir == Direction.RightToLeft)
{
pattern.Children.Add(new Constraint <Word, ShapeNode>(FeatureStruct.New().Symbol(CogFeatureSystem.AnchorType).Value));
}
string category = affix.Category;
ruleSpec.RuleSpecs.Add(new DefaultPatternRuleSpec <Word, ShapeNode>(pattern, MarkStem, word => category == null || word.Meaning.Category == category));
}
var matcherSettings = new MatcherSettings <ShapeNode>
{
Direction = dir,
Filter = ann => ann.Type().IsOneOf(CogFeatureSystem.ConsonantType, CogFeatureSystem.VowelType, CogFeatureSystem.AnchorType,
CogFeatureSystem.ToneLetterType, CogFeatureSystem.BoundaryType)
};
var rule = new PatternRule <Word, ShapeNode>(ruleSpec, matcherSettings);
foreach (Word word in words.Where(w => w.Shape.Count > 0))
{
rule.Apply(word);
}
}
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());
}
public abstract Word ApplyRhs(PatternRule <Word, ShapeNode> rule, Match <Word, ShapeNode> match);
public override Word ApplyRhs(PatternRule<Word, ShapeNode> rule, Match<Word, ShapeNode> match)
{
Word output = match.Input.DeepClone();
GenerateShape(_allomorph.Lhs, output.Shape, match);
return output;
}
