/// <summary> /// Unapplies this affix template to specified input word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="output">The output word analyses.</param> /// <returns>The resulting word analyses.</returns> public bool Unapply(WordAnalysis input, out IEnumerable <WordAnalysis> output, string[] selectTraceMorphs) { Set <WordAnalysis> results = new Set <WordAnalysis>(); if (Morpher.TraceTemplatesAnalysis) { // create the template analysis trace input record TemplateAnalysisTrace tempTrace = new TemplateAnalysisTrace(this, true, input.Clone()); input.CurrentTrace.AddChild(tempTrace); } UnapplySlots(input.Clone(), m_slots.Count - 1, results, selectTraceMorphs); foreach (WordAnalysis wa in results) { foreach (PartOfSpeech pos in m_requiredPOSs) { wa.AddPOS(pos); } } if (results.Count > 0) { output = results; return(true); } else { output = null; return(false); } }
public bool Equals(WordAnalysis other) { if (other == null) { return(false); } if (m_mrulesUnapplied.Count != other.m_mrulesUnapplied.Count) { return(false); } foreach (KeyValuePair <MorphologicalRule, int> kvp in m_mrulesUnapplied) { int numUnapplies; if (!other.m_mrulesUnapplied.TryGetValue(kvp.Key, out numUnapplies) || numUnapplies != kvp.Value) { return(false); } } if (m_nonHead != null) { if (!m_nonHead.Equals(other.m_nonHead)) { return(false); } } else if (other.m_nonHead != null) { return(false); } return(m_shape.Equals(other.m_shape) && m_rzFeatures.Equals(other.m_rzFeatures)); }
/// <summary> /// Unapplies all of the rules to the specified input word analysis. All matching lexical /// entries are added to the <c>candidates</c> parameter. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="candidates">The set of candidate word synthesis records.</param> /// <returns>All word analyses that result from the unapplication of rules.</returns> public IEnumerable <WordAnalysis> Unapply(WordAnalysis input, ICollection <WordSynthesis> candidates) { if (m_isCyclic) { throw new NotImplementedException(HCStrings.kstidCyclicStratumNotSupported); } if (m_pruleOrder == PRuleOrder.SIMULTANEOUS) { throw new NotImplementedException(HCStrings.kstidSimultOrderNotSupported); } WordAnalysis wa = input.Clone(); UnapplyPhonologicalRules(wa); LexicalLookup(wa, candidates); Set <WordAnalysis> tempOutput = new Set <WordAnalysis>(); tempOutput.Add(wa); UnapplyTemplates(wa, tempOutput, candidates); Set <WordAnalysis> output = new Set <WordAnalysis>(); // TODO: handle cyclicity foreach (WordAnalysis analysis in tempOutput) { UnapplyMorphologicalRules(analysis, m_mrules.Count - 1, 0, candidates, output); } return(output); }
public override void BeginUnapplyPhonologicalRule(PhonologicalRule rule, WordAnalysis input) { if (IsAnalysisTracingEnabled(rule.ID)) { m_currentAnalysisPruleTrace = new PhonologicalRuleAnalysisTrace(rule, input.Clone()); ((Trace) input.CurrentTraceObject).AddChild(m_currentAnalysisPruleTrace); } }
/// <summary> /// Performs any post-processing required after the unapplication of a word analysis. This must /// be called after a successful <c>BeginUnapplication</c> call and any <c>Unapply</c> calls. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="unapplied">if set to <c>true</c> if the input word analysis was successfully unapplied.</param> public override void EndUnapplication(WordAnalysis input, bool unapplied) { if (TraceAnalysis && !unapplied) { // create the morphological rule analysis trace record for a rule that did not succesfully unapply input.CurrentTrace.AddChild(new MorphologicalRuleAnalysisTrace(this, input.Clone())); } }
public override void EndUnapplyPhonologicalRule(PhonologicalRule rule, WordAnalysis output) { if (m_currentAnalysisPruleTrace != null) { m_currentAnalysisPruleTrace.Add(Write("Output", output)); m_currentAnalysisPruleTrace = null; } }
void UnapplyPhonologicalRules(WordAnalysis input) { // TODO: handle ordering properly for (int i = m_prules.Count - 1; i >= 0; i--) { m_prules[i].Unapply(input); } }
public override void EndUnapplyPhonologicalRule(PhonologicalRule rule, WordAnalysis output) { if (m_currentAnalysisPruleTrace != null) { m_currentAnalysisPruleTrace.Output = output.Clone(); m_currentAnalysisPruleTrace = null; } }
public override void EndUnapplyStratum(Stratum stratum, WordAnalysis output) { if (TraceStrataAnalysis) { ((XElement) output.CurrentTraceObject).Add(new XElement("StratumAnalysisTraceOut", Write("Stratum", stratum), Write("Output", output))); } }
public override void BeginUnapplyStratum(Stratum stratum, WordAnalysis input) { if (TraceStrataAnalysis) { ((XElement) input.CurrentTraceObject).Add(new XElement("StratumAnalysisTraceIn", Write("Stratum", stratum), Write("Input", input))); } }
public override void BeginAnalyzeWord(string inputWord, WordAnalysis input) { if (IsTracing) { var trace = new WordAnalysisTrace(inputWord, input.Shape.Clone()); m_traces.Add(trace); input.CurrentTraceObject = trace; } }
public override void BeginUnapplyTemplate(AffixTemplate template, WordAnalysis input) { if (TraceTemplatesAnalysis) { ((XElement) input.CurrentTraceObject).Add(new XElement("TemplateAnalysisTraceIn", Write("AffixTemplate", template), Write("Input", input))); } }
public override void BeginAnalyzeWord(string inputWord, WordAnalysis input) { if (IsTracing) { var trace = new XElement("WordAnalysisTrace", new XElement("InputWord", inputWord)); m_traces.Add(trace); input.CurrentTraceObject = trace; } }
public bool IsUnapplicable(WordAnalysis input) { foreach (PartOfSpeech pos in m_requiredPOSs) { if (input.MatchPOS(pos)) { return(true); } } return(false); }
/// <summary> /// Unapplies this subrule to the input word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="output">The output word analyses.</param> /// <returns><c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c></returns> public bool Unapply(WordAnalysis input, out ICollection <WordAnalysis> output) { VariableValues instantiatedVars = new VariableValues(m_alphaVars); IList <Match> matches; m_transform.RHSTemplate.IsMatch(input.Shape.First, Direction.RIGHT, ModeType.ANALYSIS, instantiatedVars, out matches); List <WordAnalysis> outputList = new List <WordAnalysis>(); output = outputList; foreach (Match match in matches) { PhoneticShape headShape; PhoneticShape nonHeadShape; UnapplyRHS(match, out headShape, out nonHeadShape); // for computational complexity reasons, we ensure that the non-head is a root, otherwise we assume it is not // a valid analysis and throw it away foreach (LexEntry.RootAllomorph allo in Morpheme.Stratum.SearchEntries(nonHeadShape)) { // check to see if this is a duplicate of another output analysis, this is not strictly necessary, but // it helps to reduce the search space bool add = true; for (int i = 0; i < output.Count; i++) { if (headShape.Duplicates(outputList[i].Shape) && allo == outputList[i].NonHead.RootAllomorph) { if (headShape.Count > outputList[i].Shape.Count) { // if this is a duplicate and it is longer, then use this analysis and remove the previous one outputList.RemoveAt(i); } else { // if it is shorter, then do not add it to the output list add = false; } break; } } if (add) { WordAnalysis wa = input.Clone(); wa.Shape = headShape; wa.NonHead = new WordAnalysis(nonHeadShape, wa.Stratum, null); wa.NonHead.RootAllomorph = allo; output.Add(wa); } } } return(outputList.Count > 0); }
public override void BeginUnapplyPhonologicalRule(PhonologicalRule rule, WordAnalysis input) { if (IsAnalysisTracingEnabled(rule.ID)) { m_currentAnalysisPruleTrace = new XElement("PhonologicalRuleAnalysisTrace", Write("PhonologicalRule", rule)); if (WriteInputs) m_currentAnalysisPruleTrace.Add(Write("Input", input)); ((XElement) input.CurrentTraceObject).Add(m_currentAnalysisPruleTrace); } }
public override void MorphologicalRuleUnapplied(MorphologicalRule rule, WordAnalysis input, WordAnalysis output, Allomorph allomorph) { if (IsAnalysisTracingEnabled(rule.ID)) { // create the morphological rule analysis trace record for each output analysis var trace = new MorphologicalRuleAnalysisTrace(rule, input.Clone()) {RuleAllomorph = allomorph, Output = output.Clone()}; ((Trace) output.CurrentTraceObject).AddChild(trace); // set current trace record to the morphological rule trace record for each // output analysis output.CurrentTraceObject = trace; } }
void UnapplyMorphologicalRulesAndTemplates(WordAnalysis wa, Set <WordAnalysis> output, ICollection <WordSynthesis> candidates, string[] selectTraceMorphs) { Set <WordAnalysis> tempOutput = new Set <WordAnalysis>(); tempOutput.Add(wa); UnapplyTemplates(wa, tempOutput, candidates, selectTraceMorphs); foreach (WordAnalysis analysis in tempOutput) { // start over from the very beginning UnapplyMorphologicalRules(analysis, m_mrules.Count - 1, 0, candidates, output, selectTraceMorphs); } }
/// <summary> /// Copy constructor. /// </summary> /// <param name="wa">The word analysis.</param> public WordAnalysis(WordAnalysis wa) { m_shape = wa.m_shape.Clone(); m_pos = new HCObjectSet<PartOfSpeech>(wa.m_pos); m_rootAllomorph = wa.m_rootAllomorph; if (wa.m_nonHead != null) m_nonHead = wa.m_nonHead.Clone(); m_mrules = new List<MorphologicalRule>(wa.m_mrules); m_mrulesUnapplied = new Dictionary<MorphologicalRule, int>(wa.m_mrulesUnapplied); m_rzFeatures = wa.m_rzFeatures.Clone(); m_curTrace = wa.m_curTrace; m_stratum = wa.m_stratum; }
public override bool Unapply(WordAnalysis input, int srIndex, out ICollection<WordAnalysis> output) { output = null; FeatureValues rzFeats; if (!RealizationalFeatures.Unify(input.RealizationalFeatures, out rzFeats)) return false; if (base.Unapply(input, srIndex, out output)) { foreach (WordAnalysis wa in output) wa.RealizationalFeatures = rzFeats; return true; } return false; }
/// <summary> /// Copy constructor. /// </summary> /// <param name="wa">The word analysis.</param> public WordAnalysis(WordAnalysis wa) { m_shape = wa.m_shape.Clone(); m_pos = new HCObjectSet <PartOfSpeech>(wa.m_pos); m_rootAllomorph = wa.m_rootAllomorph; if (wa.m_nonHead != null) { m_nonHead = wa.m_nonHead.Clone(); } m_mrules = new List <MorphologicalRule>(wa.m_mrules); m_mrulesUnapplied = new Dictionary <MorphologicalRule, int>(wa.m_mrulesUnapplied); m_rzFeatures = wa.m_rzFeatures.Clone(); m_curTrace = wa.m_curTrace; m_stratum = wa.m_stratum; }
/// <summary> /// Unapplies this subrule to the input word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="output">The output word analyses.</param> /// <returns><c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c></returns> public bool Unapply(WordAnalysis input, out ICollection <WordAnalysis> output) { VariableValues instantiatedVars = new VariableValues(m_alphaVars); IList <Match> matches; m_transform.RHSTemplate.IsMatch(input.Shape.First, Direction.RIGHT, ModeType.ANALYSIS, instantiatedVars, out matches); List <WordAnalysis> outputList = new List <WordAnalysis>(); output = outputList; foreach (Match match in matches) { PhoneticShape shape = UnapplyRHS(match); if (shape.Count > 2) { // check to see if this is a duplicate of another output analysis, this is not strictly necessary, but // it helps to reduce the search space bool add = true; for (int i = 0; i < output.Count; i++) { if (shape.Duplicates(outputList[i].Shape)) { if (shape.Count > outputList[i].Shape.Count) { // if this is a duplicate and it is longer, then use this analysis and remove the previous one outputList.RemoveAt(i); } else { // if it is shorter, then do not add it to the output list add = false; } break; } } if (add) { WordAnalysis wa = input.Clone(); wa.Shape = shape; output.Add(wa); } } } return(outputList.Count > 0); }
/// <summary> /// Unapplies the specified subrule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="srIndex">Index of the subrule.</param> /// <param name="output">All resulting word analyses.</param> /// <returns> /// <c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c> /// </returns> public override bool Unapply(WordAnalysis input, int srIndex, out ICollection <WordAnalysis> output) { if (m_subrules[srIndex].Unapply(input, out output)) { foreach (WordAnalysis wa in output) { if (m_headRequiredPOSs != null && m_headRequiredPOSs.Count > 0) { foreach (PartOfSpeech pos in m_headRequiredPOSs) { wa.AddPOS(pos); } } else if (m_outPOS == null) { wa.UninstantiatePOS(); } if (m_nonHeadRequiredPOSs != null) { foreach (PartOfSpeech pos in m_nonHeadRequiredPOSs) { wa.NonHead.AddPOS(pos); } } wa.MorphologicalRuleUnapplied(this); if (TraceAnalysis) { // create the morphological rule analysis trace record for each output analysis MorphologicalRuleAnalysisTrace trace = new MorphologicalRuleAnalysisTrace(this, input.Clone()); trace.RuleAllomorph = m_subrules[srIndex]; trace.Output = wa.Clone(); wa.CurrentTrace.AddChild(trace); // set current trace record to the morphological rule trace record for each // output analysis wa.CurrentTrace = trace; } } return(true); } output = null; return(false); }
void UnapplySlots(WordAnalysis input, int sIndex, Set <WordAnalysis> output, string[] selectTraceMorphs) { for (int i = sIndex; i >= 0; i--) { foreach (MorphologicalRule rule in m_slots[i].MorphologicalRules) { if (rule.BeginUnapplication(input)) { bool ruleUnapplied = false; for (int j = 0; j < rule.SubruleCount; j++) { ICollection <WordAnalysis> analyses; if (rule.Unapply(input, j, out analyses, selectTraceMorphs)) { ruleUnapplied = true; foreach (WordAnalysis wa in analyses) { if (wa.Shape.Count > 2) { UnapplySlots(wa, i - 1, output, selectTraceMorphs); } } } } rule.EndUnapplication(input, ruleUnapplied); } } // we can skip this slot if it is optional if (!m_slots[i].IsOptional) { if (Morpher.TraceTemplatesAnalysis) { input.CurrentTrace.AddChild(new TemplateAnalysisTrace(this, false, null)); } return; } } if (Morpher.TraceTemplatesAnalysis) { input.CurrentTrace.AddChild(new TemplateAnalysisTrace(this, false, input.Clone())); } output.Add(input); }
public override bool Unapply(WordAnalysis input, int srIndex, out ICollection <WordAnalysis> output) { output = null; FeatureValues rzFeats; if (!RealizationalFeatures.Unify(input.RealizationalFeatures, out rzFeats)) { return(false); } if (base.Unapply(input, srIndex, out output)) { foreach (WordAnalysis wa in output) { wa.RealizationalFeatures = rzFeats; } return(true); } return(false); }
/// <summary> /// Unapplies the rule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> public override void Unapply(WordAnalysis input) { // I don't think there is any difference between iterative and // simultaneous application Direction dir = Direction.RIGHT; switch (m_multApplication) { case MultAppOrder.LR_ITERATIVE: case MultAppOrder.SIMULTANEOUS: dir = Direction.LEFT; break; case MultAppOrder.RL_ITERATIVE: dir = Direction.RIGHT; break; } ProcessIterative(input.Shape, dir, m_rhsTemp, ModeType.ANALYSIS); }
void LexicalLookup(WordAnalysis input, ICollection <WordSynthesis> candidates, string[] selectTraceMorphs) { LexLookupTrace lookupTrace = null; if (Morpher.TraceLexLookup) { // create lexical lookup trace record lookupTrace = new LexLookupTrace(this, input.Shape.Clone()); input.CurrentTrace.AddChild(lookupTrace); } foreach (SegmentDefinitionTrie <LexEntry.RootAllomorph> .Match match in m_entryTrie.Search(input.Shape)) { // don't allow a compound where both roots are the same if (input.NonHead == null || input.NonHead.RootAllomorph.Morpheme != match.Value.Morpheme) { LexEntry entry = (LexEntry)match.Value.Morpheme; if (IgnoreEntry(entry, selectTraceMorphs)) { continue; } foreach (LexEntry.RootAllomorph allomorph in entry.Allomorphs) { WordAnalysis wa = input.Clone(); wa.RootAllomorph = allomorph; if (Morpher.TraceLexLookup) { // successful lookup, so create word synthesis trace record WordSynthesisTrace wsTrace = new WordSynthesisTrace(wa.RootAllomorph, wa.UnappliedMorphologicalRules, wa.RealizationalFeatures.Clone()); lookupTrace.AddChild(wsTrace); wa.CurrentTrace = wsTrace; } candidates.Add(new WordSynthesis(wa)); } } } }
void MorphologicalRuleUnapplied(WordAnalysis ruleOutput, int rIndex, int srIndex, ICollection <WordSynthesis> candidates, Set <WordAnalysis> output, string[] selectTraceMorphs) { if (ruleOutput.Shape.Count > 2) { // lookup resulting phonetic shape in lexicon LexicalLookup(ruleOutput, candidates, selectTraceMorphs); // recursive call so that we can cover every permutation of rule unapplication switch (m_mruleOrder) { case MRuleOrder.LINEAR: UnapplyMorphologicalRules(ruleOutput, rIndex, srIndex, candidates, output, selectTraceMorphs); break; case MRuleOrder.UNORDERED: UnapplyMorphologicalRulesAndTemplates(ruleOutput, output, candidates, selectTraceMorphs); break; } } }
void MorphologicalRuleUnapplied(WordAnalysis ruleOutput, int rIndex, int srIndex, ICollection <WordSynthesis> candidates, Set <WordAnalysis> output) { if (ruleOutput.Shape.Count > 2) { // lookup resulting phonetic shape in lexicon LexicalLookup(ruleOutput, candidates); // recursive call so that we can cover every permutation of rule unapplication switch (m_mruleOrder) { case MRuleOrder.LINEAR: UnapplyMorphologicalRules(ruleOutput, rIndex, srIndex, candidates, output); break; case MRuleOrder.UNORDERED: // start over from the very beginning UnapplyMorphologicalRules(ruleOutput, m_mrules.Count - 1, 0, candidates, output); break; } } }
/// <summary> /// Unapplies the rule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> public override void Unapply(WordAnalysis input) { PhonologicalRuleAnalysisTrace trace = null; if (TraceAnalysis) { // create phonological rule analysis trace record trace = new PhonologicalRuleAnalysisTrace(this, input.Clone()); input.CurrentTrace.AddChild(trace); } foreach (Subrule sr in m_subrules) { sr.Unapply(input.Shape); } if (trace != null) { // add output to trace record trace.Output = input.Clone(); } }
void UnapplyTemplates(WordAnalysis input, Set <WordAnalysis> output, ICollection <WordSynthesis> candidates, string[] selectTraceMorphs) { foreach (AffixTemplate template in m_templates) { if (template.IsUnapplicable(input)) { IEnumerable <WordAnalysis> tempOutput; if (template.Unapply(input, out tempOutput, selectTraceMorphs)) { foreach (WordAnalysis tempAnalysis in tempOutput) { // don't bother to do a lookup if this analysis already exists if (!output.Contains(tempAnalysis)) { output.Add(tempAnalysis); // lookup resulting phonetic shape in lexicon LexicalLookup(tempAnalysis, candidates, selectTraceMorphs); } } } } } }
/// <summary> /// Unapplies all of the rules to the specified input word analysis. All matching lexical /// entries are added to the <c>candidates</c> parameter. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="candidates">The set of candidate word synthesis records.</param> /// <returns>All word analyses that result from the unapplication of rules.</returns> public IEnumerable <WordAnalysis> Unapply(WordAnalysis input, ICollection <WordSynthesis> candidates, string[] selectTraceMorphs) { if (m_isCyclic) { throw new NotImplementedException(HCStrings.kstidCyclicStratumNotSupported); } if (m_pruleOrder == PRuleOrder.SIMULTANEOUS) { throw new NotImplementedException(HCStrings.kstidSimultOrderNotSupported); } WordAnalysis wa = input.Clone(); UnapplyPhonologicalRules(wa); LexicalLookup(wa, candidates, selectTraceMorphs); Set <WordAnalysis> output = new Set <WordAnalysis>(); UnapplyMorphologicalRulesAndTemplates(wa, output, candidates, selectTraceMorphs); return(output); }
/// <summary> /// Initializes a new instance of the <see cref="MorphologicalRuleAnalysisTrace"/> class. /// </summary> /// <param name="rule">The rule.</param> /// <param name="input">The input.</param> internal MorphologicalRuleAnalysisTrace(MorphologicalRule rule, WordAnalysis input) : base(rule) { m_input = input; }
/// <summary> /// Performs any post-processing required after the unapplication of a word analysis. This must /// be called after a successful <c>BeginUnapplication</c> call and any <c>Unapply</c> calls. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="trace"></param> /// <param name="unapplied">if set to <c>true</c> if the input word analysis was successfully unapplied.</param> public override void EndUnapplication(WordAnalysis input, TraceManager trace, bool unapplied) { if (trace != null && !unapplied) trace.MorphologicalRuleNotUnapplied(this, input); }
public override void BeginUnapplyTemplate(AffixTemplate template, WordAnalysis input) { if (TraceTemplatesAnalysis) ((Trace) input.CurrentTraceObject).AddChild(new TemplateAnalysisTrace(template, true, input.Clone())); }
/// <summary> /// Initializes a new instance of the <see cref="PhonologicalRuleAnalysisTrace"/> class. /// </summary> /// <param name="rule">The rule.</param> /// <param name="input">The input.</param> internal PhonologicalRuleAnalysisTrace(PhonologicalRule rule, WordAnalysis input) : base(rule) { m_input = input; }
/// <summary> /// Initializes a new instance of the <see cref="MorphologicalRuleAnalysisTrace"/> class. /// </summary> /// <param name="rule">The rule.</param> /// <param name="input">The input.</param> internal MorphologicalRuleAnalysisTrace(MorphologicalRule rule, WordAnalysis input) : base(rule) { m_input = input; }
/// <summary> /// Initializes a new instance of the <see cref="TemplateAnalysisTrace"/> class. /// </summary> /// <param name="template">The template.</param> /// <param name="input">if <c>true</c> this is an input record, if <c>false</c> this is an output record.</param> /// <param name="analysis">The input or output word analysis.</param> internal TemplateAnalysisTrace(AffixTemplate template, bool input, WordAnalysis analysis) : base(template, input) { m_analysis = analysis; }
/// <summary> /// Unapplies the rule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> public override void Unapply(WordAnalysis input) { // I don't think there is any difference between iterative and // simultaneous application Direction dir = Direction.RIGHT; switch (m_multApplication) { case MultAppOrder.LR_ITERATIVE: case MultAppOrder.SIMULTANEOUS: dir = Direction.LEFT; break; case MultAppOrder.RL_ITERATIVE: dir = Direction.RIGHT; break; } ProcessIterative(input.Shape, dir, m_rhsTemp, ModeType.ANALYSIS); }
public bool Equals(WordAnalysis other) { if (other == null) return false; if (m_mrulesUnapplied.Count != other.m_mrulesUnapplied.Count) return false; foreach (KeyValuePair<MorphologicalRule, int> kvp in m_mrulesUnapplied) { int numUnapplies; if (!other.m_mrulesUnapplied.TryGetValue(kvp.Key, out numUnapplies) || numUnapplies != kvp.Value) return false; } if (m_nonHead != null) { if (!m_nonHead.Equals(other.m_nonHead)) return false; } else if (other.m_nonHead != null) { return false; } return m_shape.Equals(other.m_shape) && m_rzFeatures.Equals(other.m_rzFeatures); }
public override void EndUnapplyTemplate(AffixTemplate template, WordAnalysis output, bool unapplied) { if (TraceTemplatesAnalysis) ((Trace) output.CurrentTraceObject).AddChild(new TemplateAnalysisTrace(template, false, unapplied ? output.Clone() : null)); }
/// <summary> /// Unapplies the specified subrule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="srIndex">Index of the subrule.</param> /// <param name="output">All resulting word analyses.</param> /// <param name="selectTraceMorphs">list of ids to be used in a selective trace</param> /// <returns><c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c></returns> public abstract bool Unapply(WordAnalysis input, int srIndex, out ICollection <WordAnalysis> output, string[] selectTraceMorphs);
/// <summary> /// Performs any pre-processing required for unapplication of a word analysis. This must /// be called before <c>Unapply</c>. <c>Unapply</c> and <c>EndUnapplication</c> should only /// be called if this method returns <c>true</c>. /// </summary> /// <param name="input">The input word analysis.</param> /// <returns><c>true</c> if the specified input is unapplicable, otherwise <c>false</c>.</returns> public abstract bool BeginUnapplication(WordAnalysis input);
/// <summary> /// Performs any post-processing required after the unapplication of a word analysis. This must /// be called after a successful <c>BeginUnapplication</c> call and any <c>Unapply</c> calls. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="unapplied">if set to <c>true</c> if the input word analysis was successfully unapplied.</param> public abstract void EndUnapplication(WordAnalysis input, bool unapplied);
/// <summary> /// Initializes a new instance of the <see cref="StratumAnalysisTrace"/> class. /// </summary> /// <param name="stratum">The stratum.</param> /// <param name="input">if <c>true</c> this is an input record, if <c>false</c> this is an output record.</param> /// <param name="analysis">The input or output word analysis.</param> internal StratumAnalysisTrace(Stratum stratum, bool input, WordAnalysis analysis) : base(stratum, input) { m_analysis = analysis; }
/// <summary> /// Performs any pre-processing required for unapplication of a word analysis. This must /// be called before <c>Unapply</c>. <c>Unapply</c> and <c>EndUnapplication</c> should only /// be called if this method returns <c>true</c>. /// </summary> /// <param name="input">The input word analysis.</param> /// <returns> /// <c>true</c> if the specified input is unapplicable, otherwise <c>false</c>. /// </returns> public override bool BeginUnapplication(WordAnalysis input) { return(input.GetNumUnappliesForMorphologicalRule(this) < m_maxNumApps && input.NonHead == null && (m_outPOS == null || input.MatchPOS(m_outPOS))); }
/// <summary> /// Initializes a new instance of the <see cref="PhonologicalRuleAnalysisTrace"/> class. /// </summary> /// <param name="rule">The rule.</param> /// <param name="input">The input.</param> internal PhonologicalRuleAnalysisTrace(PhonologicalRule rule, WordAnalysis input) : base(rule) { m_input = input; }
/// <summary> /// Unapplies this subrule to the input word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="output">The output word analyses.</param> /// <returns><c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c></returns> public bool Unapply(WordAnalysis input, out ICollection<WordAnalysis> output) { VariableValues instantiatedVars = new VariableValues(m_alphaVars); IList<Match> matches; m_transform.RHSTemplate.IsMatch(input.Shape.First, Direction.RIGHT, ModeType.ANALYSIS, instantiatedVars, out matches); List<WordAnalysis> outputList = new List<WordAnalysis>(); output = outputList; foreach (Match match in matches) { PhoneticShape headShape; PhoneticShape nonHeadShape; UnapplyRHS(match, out headShape, out nonHeadShape); // for computational complexity reasons, we ensure that the non-head is a root, otherwise we assume it is not // a valid analysis and throw it away foreach (LexEntry.RootAllomorph allo in Morpheme.Stratum.SearchEntries(nonHeadShape)) { // check to see if this is a duplicate of another output analysis, this is not strictly necessary, but // it helps to reduce the search space bool add = true; for (int i = 0; i < output.Count; i++) { if (headShape.Duplicates(outputList[i].Shape) && allo == outputList[i].NonHead.RootAllomorph) { if (headShape.Count > outputList[i].Shape.Count) // if this is a duplicate and it is longer, then use this analysis and remove the previous one outputList.RemoveAt(i); else // if it is shorter, then do not add it to the output list add = false; break; } } if (add) { WordAnalysis wa = input.Clone(); wa.Shape = headShape; wa.NonHead = new WordAnalysis(nonHeadShape, wa.Stratum, null); wa.NonHead.RootAllomorph = allo; output.Add(wa); } } } return outputList.Count > 0; }
/// <summary> /// Unapplies the rule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> public override void Unapply(WordAnalysis input) { PhonologicalRuleAnalysisTrace trace = null; if (TraceAnalysis) { // create phonological rule analysis trace record trace = new PhonologicalRuleAnalysisTrace(this, input.Clone()); input.CurrentTrace.AddChild(trace); } foreach (Subrule sr in m_subrules) sr.Unapply(input.Shape); if (trace != null) // add output to trace record trace.Output = input.Clone(); }
/// <summary> /// Unapplies the specified subrule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="srIndex">Index of the subrule.</param> /// <param name="output">All resulting word analyses.</param> /// <returns> /// <c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c> /// </returns> public override bool Unapply(WordAnalysis input, int srIndex, out ICollection<WordAnalysis> output) { if (m_subrules[srIndex].Unapply(input, out output)) { foreach (WordAnalysis wa in output) { if (m_headRequiredPOSs != null && m_headRequiredPOSs.Count > 0) { foreach (PartOfSpeech pos in m_headRequiredPOSs) wa.AddPOS(pos); } else if (m_outPOS == null) { wa.UninstantiatePOS(); } if (m_nonHeadRequiredPOSs != null) { foreach (PartOfSpeech pos in m_nonHeadRequiredPOSs) wa.NonHead.AddPOS(pos); } wa.MorphologicalRuleUnapplied(this); if (TraceAnalysis) { // create the morphological rule analysis trace record for each output analysis MorphologicalRuleAnalysisTrace trace = new MorphologicalRuleAnalysisTrace(this, input.Clone()); trace.RuleAllomorph = m_subrules[srIndex]; trace.Output = wa.Clone(); wa.CurrentTrace.AddChild(trace); // set current trace record to the morphological rule trace record for each // output analysis wa.CurrentTrace = trace; } } return true; } output = null; return false; }
/// <summary> /// Initializes a new instance of the <see cref="StratumAnalysisTrace"/> class. /// </summary> /// <param name="stratum">The stratum.</param> /// <param name="input">if <c>true</c> this is an input record, if <c>false</c> this is an output record.</param> /// <param name="analysis">The input or output word analysis.</param> internal StratumAnalysisTrace(Stratum stratum, bool input, WordAnalysis analysis) : base(stratum, input) { m_analysis = analysis; }
public override bool BeginUnapplication(WordAnalysis input) { return(true); }
/// <summary> /// Initializes a new instance of the <see cref="TemplateAnalysisTrace"/> class. /// </summary> /// <param name="template">The template.</param> /// <param name="input">if <c>true</c> this is an input record, if <c>false</c> this is an output record.</param> /// <param name="analysis">The input or output word analysis.</param> internal TemplateAnalysisTrace(AffixTemplate template, bool input, WordAnalysis analysis) : base(template, input) { m_analysis = analysis; }
void LexicalLookup(WordAnalysis input, ICollection <WordSynthesis> candidates) { LexicalLookup(input, candidates, null); }
/// <summary> /// Performs any pre-processing required for unapplication of a word analysis. This must /// be called before <c>Unapply</c>. <c>Unapply</c> and <c>EndUnapplication</c> should only /// be called if this method returns <c>true</c>. /// </summary> /// <param name="input">The input word analysis.</param> /// <returns> /// <c>true</c> if the specified input is unapplicable, otherwise <c>false</c>. /// </returns> public override bool BeginUnapplication(WordAnalysis input) { return input.GetNumUnappliesForMorphologicalRule(this) < m_maxNumApps && input.NonHead == null && (m_outPOS == null || input.MatchPOS(m_outPOS)); }
/// <summary> /// Unapplies this subrule to the input word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="output">The output word analyses.</param> /// <returns><c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c></returns> public bool Unapply(WordAnalysis input, out ICollection<WordAnalysis> output) { VariableValues instantiatedVars = new VariableValues(m_alphaVars); IList<Match> matches; m_transform.RHSTemplate.IsMatch(input.Shape.First, Direction.RIGHT, ModeType.ANALYSIS, instantiatedVars, out matches); List<WordAnalysis> outputList = new List<WordAnalysis>(); output = outputList; foreach (Match match in matches) { PhoneticShape shape = UnapplyRHS(match); if (shape.Count > 2) { // check to see if this is a duplicate of another output analysis, this is not strictly necessary, but // it helps to reduce the search space bool add = true; for (int i = 0; i < output.Count; i++) { if (shape.Duplicates(outputList[i].Shape)) { if (shape.Count > outputList[i].Shape.Count) // if this is a duplicate and it is longer, then use this analysis and remove the previous one outputList.RemoveAt(i); else // if it is shorter, then do not add it to the output list add = false; break; } } if (add) { WordAnalysis wa = input.Clone(); wa.Shape = shape; output.Add(wa); } } } return outputList.Count > 0; }
/// <summary> /// Performs any post-processing required after the unapplication of a word analysis. This must /// be called after a successful <c>BeginUnapplication</c> call and any <c>Unapply</c> calls. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="unapplied">if set to <c>true</c> if the input word analysis was successfully unapplied.</param> public override void EndUnapplication(WordAnalysis input, bool unapplied) { if (TraceAnalysis && !unapplied) // create the morphological rule analysis trace record for a rule that did not succesfully unapply input.CurrentTrace.AddChild(new MorphologicalRuleAnalysisTrace(this, input.Clone())); }
/// <summary> /// Unapplies the specified subrule to the specified word analysis. /// </summary> /// <param name="input">The input word analysis.</param> /// <param name="srIndex">Index of the subrule.</param> /// <param name="output">All resulting word analyses.</param> /// <param name="selectTraceMorphs">list of ids to be used in a selective trace</param> /// <returns> /// <c>true</c> if the subrule was successfully unapplied, otherwise <c>false</c> /// </returns> public override bool Unapply(WordAnalysis input, int srIndex, TraceManager trace, string[] selectTraceMorphs, out ICollection<WordAnalysis> output) { if (UseThisRule(selectTraceMorphs) && m_subrules[srIndex].Unapply(input, out output)) { foreach (WordAnalysis wa in output) { if (m_requiredPOSs != null && m_requiredPOSs.Count > 0) { foreach (PartOfSpeech pos in m_requiredPOSs) wa.AddPOS(pos); } else if (m_outPOS == null) { wa.UninstantiatePOS(); } wa.MorphologicalRuleUnapplied(this); if (trace != null) trace.MorphologicalRuleUnapplied(this, input, wa, m_subrules[srIndex]); } return true; } output = null; return false; }
public override void MorphologicalRuleNotUnapplied(MorphologicalRule rule, WordAnalysis input) { if (IsAnalysisTracingEnabled(rule.ID)) { // create the morphological rule analysis trace record for a rule that did not succesfully unapply ((Trace) input.CurrentTraceObject).AddChild(new MorphologicalRuleAnalysisTrace(rule, input.Clone())); } }
public override void EndUnapplyStratum(Stratum stratum, WordAnalysis output) { if (TraceStrataAnalysis) ((Trace) output.CurrentTraceObject).AddChild(new StratumAnalysisTrace(stratum, false, output.Clone())); }