/// <summary> /// Initializes a new instance of the <see cref="Match"/> class. /// </summary> /// <param name="pattern"></param> /// <param name="vars">The instantiated variables.</param> internal Match(PhoneticPattern pattern, VariableValues vars) { m_pattern = pattern; m_partitions = new Dictionary <int, List <PhoneticShapeNode> >(); m_entireMatch = new List <PhoneticShapeNode>(); m_instantiatedVars = vars.Clone(); }
void Untruncate(PhoneticPattern lhs, PhoneticShape output, bool optional, VariableValues instantiatedVars) { // create segments from the LHS partition pattern and append them to the output foreach (PhoneticPatternNode node in lhs) { switch (node.Type) { case PhoneticPatternNode.NodeType.SIMP_CTXT: SimpleContext ctxt = node as SimpleContext; Segment newSeg = ctxt.UnapplyDeletion(instantiatedVars); newSeg.IsOptional = optional; output.Add(newSeg); break; case PhoneticPatternNode.NodeType.PATTERN: NestedPhoneticPattern nestedPattern = node as NestedPhoneticPattern; // untruncate nested partitions the maximum number of times it can occur, // marking any segments that occur after the minimum number of occurrences // as optional for (int j = 0; j < nestedPattern.MaxOccur; j++) { Untruncate(nestedPattern.Pattern, output, j >= nestedPattern.MinOccur, instantiatedVars); } break; case PhoneticPatternNode.NodeType.BDRY_CTXT: // skip boundaries break; } } }
/// <summary> /// Generates the RHS template of a morphological rule. /// </summary> /// <param name="rhsTemp">The RHS template.</param> /// <param name="lhs">The LHS.</param> /// <param name="modifyFromCtxts">The modify-from contexts.</param> /// <param name="redup">The reduplication flag.</param> public override void GenerateRHSTemplate(PhoneticPattern rhsTemp, IList <PhoneticPattern> lhs, IDictionary <int, SimpleContext> modifyFromCtxts) { // copy LHS partition over the RHS, only indicate the partition if this is // the first time this partition is being copied rhsTemp.AddPartition(lhs[m_partition], m_redup ? -1 : m_partition); }
public void Reset() { m_multApplication = MultAppOrder.LR_ITERATIVE; m_alphaVars = null; m_lhs = null; m_subrules.Clear(); }
/// <summary> /// Initializes a new instance of the <see cref="Subrule"/> class. /// </summary> /// <param name="rhs">The RHS.</param> /// <param name="env">The environment.</param> /// <param name="rule">The phonological rule.</param> /// <exception cref="System.ArgumentException">Thrown when the size of the RHS is greater than the /// size of the specified rule's LHS and the LHS's size is greater than 1. A standard phonological /// rule does not currently support this type of widening.</exception> public Subrule(PhoneticPattern rhs, Environment env, StandardPhonologicalRule rule) { m_rhs = rhs; m_env = env; m_rule = rule; switch (Type) { case ChangeType.NARROW: case ChangeType.EPENTHESIS: // analysis target is a copy of the RHS, because there is no LHS m_analysisTarget = m_rhs.Clone(); break; case ChangeType.WIDEN: // before generating the analysis we must extend the length of the LHS // to match the length of the RHS PhoneticPattern lhs = m_rule.m_lhs.Clone(); while (lhs.Count != m_rhs.Count) { lhs.Add(lhs.First.Clone()); } m_analysisTarget = m_rhs.Combine(lhs); break; case ChangeType.FEATURE: m_analysisTarget = m_rhs.Combine(m_rule.m_lhs); break; case ChangeType.UNKNOWN: throw new ArgumentException(HCStrings.kstidInvalidSubruleType, "rhs"); } }
/// <summary> /// Checks for overlap of features between the specified simple context and the specified /// environment. /// </summary> /// <param name="ctxt">The simple context.</param> /// <param name="envSeq">The environment.</param> /// <returns> /// <c>true</c> if there is no overlap, otherwise <c>false</c>. /// </returns> bool IsNonSelfOpaquing(SimpleContext ctxt, PhoneticPattern env) { foreach (PhoneticPatternNode node in env) { switch (node.Type) { case PhoneticPatternNode.NodeType.SIMP_CTXT: SimpleContext envCtxt = node as SimpleContext; if (!envCtxt.FeatureValues.IsDisjoint(ctxt.AntiFeatureValues)) { return(false); } break; case PhoneticPatternNode.NodeType.BDRY_CTXT: break; case PhoneticPatternNode.NodeType.PATTERN: NestedPhoneticPattern optSeq = node as NestedPhoneticPattern; if (!IsNonSelfOpaquing(ctxt, optSeq.Pattern)) { return(false); } break; } } return(true); }
/// <summary> /// Initializes a new instance of the <see cref="Subrule"/> class. /// </summary> /// <param name="id">The id.</param> /// <param name="desc">The description.</param> /// <param name="morpher">The morpher.</param> /// <param name="headLhs">The head LHS.</param> /// <param name="nonHeadLhs">The non-head LHS.</param> /// <param name="rhs">The RHS.</param> /// <param name="alphaVars">The alpha variables.</param> public Subrule(string id, string desc, Morpher morpher, IEnumerable <PhoneticPattern> headLhs, IEnumerable <PhoneticPattern> nonHeadLhs, IEnumerable <MorphologicalOutput> rhs, AlphaVariables alphaVars) : base(id, desc, morpher) { m_alphaVars = alphaVars; List <PhoneticPattern> lhs = new List <PhoneticPattern>(); lhs.AddRange(headLhs); lhs.AddRange(nonHeadLhs); m_transform = new MorphologicalTransform(lhs, rhs, MorphologicalTransform.RedupMorphType.IMPLICIT); // the LHS template is generated by simply concatenating all of the // LHS partitions; it matches the entire word, so we check for both the // left and right margins. m_headLhsTemp = new PhoneticPattern(); m_headLhsTemp.Add(new MarginContext(Direction.LEFT)); int partition = 0; foreach (PhoneticPattern pat in headLhs) { m_headLhsTemp.AddPartition(pat, partition++); } m_headLhsTemp.Add(new MarginContext(Direction.RIGHT)); m_firstNonHeadPartition = partition; m_nonHeadLhsTemp = new PhoneticPattern(); m_nonHeadLhsTemp.Add(new MarginContext(Direction.LEFT)); foreach (PhoneticPattern pat in nonHeadLhs) { m_nonHeadLhsTemp.AddPartition(pat, partition++); } m_nonHeadLhsTemp.Add(new MarginContext(Direction.RIGHT)); }
PhoneticPattern GenerateChangePartition(PhoneticPattern lhs, PhoneticPattern rhs) { PhoneticPattern result = new PhoneticPattern(); foreach (PhoneticPatternNode node in lhs) { switch (node.Type) { case PhoneticPatternNode.NodeType.SIMP_CTXT: PhoneticPattern temp = new PhoneticPattern(); temp.Add(node.Clone()); // generates the RHS template the same way that phonological rules generate their // RHS analysis targets result.AddMany(rhs.Combine(temp)); break; case PhoneticPatternNode.NodeType.PATTERN: NestedPhoneticPattern nestedPattern = node as NestedPhoneticPattern; PhoneticPattern pattern = GenerateChangePartition(nestedPattern.Pattern, rhs); NestedPhoneticPattern newNestedPattern = new NestedPhoneticPattern(pattern, nestedPattern.MinOccur, nestedPattern.MaxOccur); result.Add(newNestedPattern); break; } } return(result); }
/// <summary> /// Copy constructor. /// </summary> /// <param name="nestedPattern">The nested pattern.</param> public NestedPhoneticPattern(NestedPhoneticPattern nestedPattern) : base(nestedPattern) { m_pattern = new PhoneticPattern(nestedPattern.m_pattern); m_minOccur = nestedPattern.m_minOccur; m_maxOccur = nestedPattern.m_maxOccur; }
/// <summary> /// Generates the RHS template of a morphological rule. /// </summary> /// <param name="rhsTemp">The RHS template.</param> /// <param name="lhs">The LHS.</param> /// <param name="modifyFromCtxts">The modify-from contexts.</param> /// <param name="redup">The reduplication flag.</param> public override void GenerateRHSTemplate(PhoneticPattern rhsTemp, IList <PhoneticPattern> lhs, IDictionary <int, SimpleContext> modifyFromCtxts) { PhoneticPattern ctxtPattern = new PhoneticPattern(); ctxtPattern.Add(m_ctxt); // combines the simple context with all of the simple contexts on the LHS // and adds the results to the RHS template PhoneticPattern pattern = GenerateChangePartition(lhs[m_partition], ctxtPattern); rhsTemp.AddPartition(pattern, m_redup ? -1 : m_partition); // add context to the modify-from contexts modifyFromCtxts[m_partition] = m_ctxt; }
bool ProcessIterative(PhoneticShape input, Direction dir, PhoneticPattern ptemp, ModeType mode) { bool reordered = false; PhoneticShapeNode node = input.GetFirst(dir); Match match; // iterate thru each match while (FindNextMatch(node, dir, ptemp, mode, out match)) { // reorder the matching segments Reorder(dir, match); reordered = true; IList <PhoneticShapeNode> nodes = match.EntireMatch; node = nodes[nodes.Count - 1].GetNext(dir); } return(reordered); }
/// <summary> /// Initializes a new instance of the <see cref="MorphologicalTransform"/> class. /// </summary> /// <param name="lhs">The LHS.</param> /// <param name="rhs">The RHS.</param> public MorphologicalTransform(IEnumerable <PhoneticPattern> lhs, IEnumerable <MorphologicalOutput> rhs, RedupMorphType redupMorphType) { m_lhs = new List <PhoneticPattern>(lhs); m_rhs = new List <MorphologicalOutput>(rhs); m_modifyFromCtxts = new Dictionary <int, SimpleContext>(); // reduplication flags for each morphological output record CheckReduplication(redupMorphType); m_rhsTemp = new PhoneticPattern(); m_modifyFromCtxts = new Dictionary <int, SimpleContext>(); m_rhsTemp.Add(new MarginContext(Direction.LEFT)); for (int i = 0; i < m_rhs.Count; i++) { m_rhs[i].GenerateRHSTemplate(m_rhsTemp, m_lhs, m_modifyFromCtxts); } m_rhsTemp.Add(new MarginContext(Direction.RIGHT)); }
/// <summary> /// Generates the RHS template. /// </summary> /// <param name="rhsTemp">The RHS template.</param> /// <param name="lhs">The LHS.</param> /// <param name="modifyFromCtxts">The modify-from contexts.</param> /// <param name="redup">The reduplication flag.</param> public override void GenerateRHSTemplate(PhoneticPattern rhsTemp, IList <PhoneticPattern> lhs, IDictionary <int, SimpleContext> modifyFromCtxts) { for (PhoneticShapeNode node = m_pshape.Begin; node != m_pshape.Last; node = node.Next) { // create contexts from the segments and boundaries in the phonetic shape // and append them to the RHS template switch (node.Type) { case PhoneticShapeNode.NodeType.SEGMENT: rhsTemp.Add(new SegmentContext(node as Segment)); break; case PhoneticShapeNode.NodeType.BOUNDARY: rhsTemp.Add(new BoundaryContext(node as Boundary)); break; } } }
bool FindNextMatch(PhoneticShapeNode node, Direction dir, PhoneticPattern ptemp, ModeType mode, out Match match) { for (; node != node.Owner.GetLast(dir); node = node.GetNext(dir)) { if (mode == ModeType.ANALYSIS && node.Type == PhoneticShapeNode.NodeType.BOUNDARY) { continue; } IList <Match> matches; if (ptemp.IsMatch(node, dir, mode, out matches)) { match = matches[0]; return(true); } } match = null; return(false); }
/// <summary> /// Initializes a new instance of the <see cref="Subrule"/> class. /// </summary> /// <param name="id">The id.</param> /// <param name="desc">The description.</param> /// <param name="morpher">The morpher.</param> /// <param name="lhs">The LHS.</param> /// <param name="rhs">The RHS.</param> /// <param name="alphaVars">The alpha variables.</param> /// <param name="redupMorphType">The full reduplication type.</param> public Subrule(string id, string desc, Morpher morpher, IEnumerable <PhoneticPattern> lhs, IEnumerable <MorphologicalOutput> rhs, AlphaVariables alphaVars, MorphologicalTransform.RedupMorphType redupMorphType) : base(id, desc, morpher) { m_alphaVars = alphaVars; m_transform = new MorphologicalTransform(lhs, rhs, redupMorphType); // the LHS template is generated by simply concatenating all of the // LHS partitions; it matches the entire word, so we check for both the // left and right margins. m_lhsTemp = new PhoneticPattern(); m_lhsTemp.Add(new MarginContext(Direction.LEFT)); int partition = 0; foreach (PhoneticPattern pat in lhs) { m_lhsTemp.AddPartition(pat, partition, m_transform.IsGreedy(partition)); partition++; } m_lhsTemp.Add(new MarginContext(Direction.RIGHT)); }
void UnapplyRHS(Direction dir, IList <PhoneticShapeNode> match, VariableValues instantiatedVars) { switch (Type) { case ChangeType.FEATURE: int i = 0; // if there are no phonetic features, unapply using the LHS, since we are simply replacing PhoneticPattern unappPattern = m_rule.Morpher.PhoneticFeatureSystem.HasFeatures ? m_analysisTarget : m_rule.m_lhs; for (PhoneticPatternNode pseqNode = unappPattern.GetFirst(dir); pseqNode != null; pseqNode = pseqNode.GetNext(dir)) { switch (pseqNode.Type) { case PhoneticPatternNode.NodeType.SIMP_CTXT: SimpleContext ctxt = pseqNode as SimpleContext; // match[i] should be a segment, should I check that here? Segment seg = match[i] as Segment; ctxt.Unapply(seg, instantiatedVars); break; case PhoneticPatternNode.NodeType.BDRY_CTXT: // skip boundaries continue; } i++; } break; case ChangeType.EPENTHESIS: // do not remove epenthesized segments, since it is possible that they will not // be epenthesized during synthesis, we just mark them as optional foreach (PhoneticShapeNode node in match) { node.IsOptional = true; } break; } }
/// <summary> /// Initializes a new instance of the <see cref="NestedPhoneticPattern"/> class. /// </summary> /// <param name="pattern">The phonetic pattern.</param> /// <param name="minOccur">The minimum number of occurrences.</param> /// <param name="maxOccur">The maximum number of occurrences.</param> public NestedPhoneticPattern(PhoneticPattern pattern, int minOccur, int maxOccur) { m_pattern = pattern; m_minOccur = minOccur; m_maxOccur = maxOccur; }
/// <summary> /// Initializes a new instance of the <see cref="Environment"/> class. /// </summary> /// <param name="leftEnv">The left environment.</param> /// <param name="rightEnv">The right environment.</param> public Environment(PhoneticPattern leftEnv, PhoneticPattern rightEnv) { m_leftEnv = leftEnv; m_rightEnv = rightEnv; }
/// <summary> /// Generates the RHS template of a morphological rule. If the record /// modifies the input using a simple context, it should add that context /// to varFeats of modify-from contexts. It is used during unapplication. /// The reduplication flags are used to indicate that the same input partition /// is being copied multiple times. /// </summary> /// <param name="rhsTemp">The RHS template.</param> /// <param name="lhs">The LHS.</param> /// <param name="modifyFromCtxts">The modify-from contexts.</param> /// <param name="redup">The reduplication flag.</param> public abstract void GenerateRHSTemplate(PhoneticPattern rhsTemp, IList <PhoneticPattern> lhs, IDictionary <int, SimpleContext> modifyFromCtxts);
/// <summary> /// Generates the RHS template of a morphological rule. /// </summary> /// <param name="rhsTemp">The RHS template.</param> /// <param name="lhs">The LHS.</param> /// <param name="modifyFromCtxts">The modify-from contexts.</param> /// <param name="redup">The reduplication flag.</param> public override void GenerateRHSTemplate(PhoneticPattern rhsTemp, IList <PhoneticPattern> lhs, IDictionary <int, SimpleContext> modifyFromCtxts) { rhsTemp.Add(m_ctxt.Clone()); }