/// <summary> /// Overwrite the postOperationFix method. For "a, b and c" or similar: we want "a" to be the head. /// </summary> protected override int PostOperationFix(int headIdx, Tree[] daughterTrees) { if (headIdx >= 2) { string prevLab = Tlp.BasicCategory(daughterTrees[headIdx - 1].Value()); if (prevLab.Equals(PartsOfSpeech.CoordinatingConjunction) || prevLab.Equals(CONJP)) { bool origWasInterjection = PartsOfSpeech.Interjection.Equals(Tlp.BasicCategory(daughterTrees[headIdx].Value())); int newHeadIdx = headIdx - 2; // newHeadIdx is now left of conjunction. Now try going back over commas, etc. for 3+ conjuncts // Don't allow INTJ unless conjoined with INTJ - important in informal genres "Oh and don't forget to call!" while (newHeadIdx >= 0 && ShouldSkip(daughterTrees[newHeadIdx], origWasInterjection)) { newHeadIdx--; } // We're now at newHeadIdx < 0 or have found a left head // Now consider going back some number of punct that includes a , or : tagged thing and then find non-punct while (newHeadIdx >= 2) { int nextHead = FindPreviousHead(newHeadIdx, daughterTrees, origWasInterjection); if (nextHead < 0) { break; } newHeadIdx = nextHead; } if (newHeadIdx >= 0) { headIdx = newHeadIdx; } } } return(headIdx); }
private int FindPreviousHead(int headIdx, Tree[] daughterTrees, bool origWasInterjection) { bool seenSeparator = false; int newHeadIdx = headIdx; while (newHeadIdx >= 0) { newHeadIdx = newHeadIdx - 1; if (newHeadIdx < 0) { return(newHeadIdx); } string label = Tlp.BasicCategory(daughterTrees[newHeadIdx].Value()); if (PartsOfSpeech.Comma.Equals(label) || PartsOfSpeech.ColonSemiColon.Equals(label)) { seenSeparator = true; } else if (daughterTrees[newHeadIdx].IsPreTerminal() && (Tlp.IsPunctuationTag(label) || !origWasInterjection && PartsOfSpeech.Interjection.Equals(label)) || INTJ.Equals(label) && !origWasInterjection) { // keep looping } else { if (!seenSeparator) { newHeadIdx = -1; } break; } } return(newHeadIdx); }
/// <summary> /// Checks whether the tree t is an existential constituent /// There are two cases: /// -- affirmative sentences in which "there" is a left sister of the VP /// -- questions in which "there" is a daughter of the SQ. /// </summary> private bool IsExistential(Tree t, Tree parent) { bool toReturn = false; string motherCat = Tlp.BasicCategory(t.Label().Value()); // affirmative case if (motherCat.Equals(AbstractCollinsHeadFinder.VerbPhrase) && parent != null) { //take t and the sisters Tree[] kids = parent.Children(); // iterate over the sisters before t and checks if existential foreach (Tree kid in kids) { if (!kid.Value().Equals(AbstractCollinsHeadFinder.VerbPhrase)) { List <ILabel> tags = kid.PreTerminalYield(); foreach (ILabel tag in tags) { if (tag.Value().Equals(PartsOfSpeech.ExistentialThere)) { toReturn = true; } } } else { break; } } } // question case else if (motherCat.StartsWith(SQ) && parent != null) { //take the daughters Tree[] kids = parent.Children(); // iterate over the daughters and checks if existential foreach (Tree kid in kids) { if (!PartsOfSpeech.IsVerb(kid.Value())) { //not necessary to look into the verb List <ILabel> tags = kid.PreTerminalYield(); foreach (ILabel tag in tags) { if (tag.Value().Equals(PartsOfSpeech.ExistentialThere)) { toReturn = true; } } } } } return(toReturn); }
protected override int PostOperationFix(int headIdx, Tree[] daughterTrees) { if (headIdx >= 2) { string prevLab = Tlp.BasicCategory(daughterTrees[headIdx - 1].Value()); if (prevLab.Equals(PartsOfSpeech.CoordinatingConjunction) || prevLab.Equals(AbstractCollinsHeadFinder.CONJP)) { int newHeadIdx = headIdx - 2; Tree t = daughterTrees[newHeadIdx]; while (newHeadIdx >= 0 && t.IsPreTerminal() && Tlp.IsPunctuationTag(t.Value())) { newHeadIdx--; } if (newHeadIdx >= 0) { headIdx = newHeadIdx; } } } return(headIdx); }
public Int16Parameter(Tlp tlp) : base(tlp) { Value = 0; }
public Ac40Parameter(Tlp tlp) : base(tlp) { Value = ""; }
public UInt8Parameter(Tlp tlp) : base(tlp) { Value = 0; }
DatabasePoint(Tlp tlp, ParameterType parameterType) { Tlp = tlp; ParameterType = parameterType; }
DatabasePoint(byte pointType, byte logicalNumber, byte parameter, ParameterType parameterType) { Tlp = new Tlp(pointType, logicalNumber, parameter); ParameterType = parameterType; }
public TimeParameter(Tlp tlp) : base(tlp) { Value = new DateTime(1970, 01, 01); }
public FlpParameter(Tlp tlp) : base(tlp) { Value = 0; }
public BinParameter(Tlp tlp) : base(tlp) { Value = 0; }
public DoubleParameter(Tlp tlp) : base(tlp) { Value = 0; }
/// <summary> /// Determine which daughter of the current parse tree is the head. /// It assumes that the daughters already have had their heads determined. /// Uses special rule for VP heads /// </summary> /// <param name="t"> /// The parse tree to examine the daughters of. /// This is assumed to never be a leaf /// </param> /// <returns>The parse tree that is the head</returns> protected override Tree DetermineNonTrivialHead(Tree t, Tree parent) { string motherCat = Tlp.BasicCategory(t.Label().Value()); // Some conj expressions seem to make more sense with the "not" or // other key words as the head. For example, "and not" means // something completely different than "and". Furthermore, // downstream code was written assuming "not" would be the head... if (motherCat.Equals(CONJP)) { var headOfConjpTregex = new TregexPattern[] { TregexPattern.Compile("CONJP < (CC <: /^(?i:but|and)$/ $+ (RB=head <: /^(?i:not)$/))"), TregexPattern.Compile( "CONJP < (CC <: /^(?i:but)$/ [ ($+ (RB=head <: /^(?i:also|rather)$/)) | ($+ (ADVP=head <: (RB <: /^(?i:also|rather)$/))) ])"), TregexPattern.Compile( "CONJP < (CC <: /^(?i:and)$/ [ ($+ (RB=head <: /^(?i:yet)$/)) | ($+ (ADVP=head <: (RB <: /^(?i:yet)$/))) ])"), }; foreach (TregexPattern pattern in headOfConjpTregex) { TregexMatcher matcher = pattern.Matcher(t); if (matcher.MatchesAt(t)) { return(matcher.GetNode("head")); } } // if none of the above patterns match, use the standard method } if (motherCat.Equals(SBARQ) || motherCat.Equals(SINV)) { if (!makeCopulaHead) { var headOfCopulaTregex = new TregexPattern[] { // Matches phrases such as "what is wrong" TregexPattern.Compile("SBARQ < (WHNP $++ (/^VB/ < " + EnglishPatterns.CopularWordRegex + " $++ ADJP=head))"), // matches WHNP $+ VB<copula $+ NP // for example, "Who am I to judge?" // !$++ ADJP matches against "Why is the dog pink?" TregexPattern.Compile("SBARQ < (WHNP=head $++ (/^VB/ < " + EnglishPatterns.CopularWordRegex + " $+ NP !$++ ADJP))"), // Actually somewhat limited in scope, this detects "Tuesday it is", // "Such a great idea this was", etc TregexPattern.Compile("SINV < (NP=head $++ (NP $++ (VP < (/^(?:VB|AUX)/ < " + EnglishPatterns.CopularWordRegex + "))))"), }; foreach (TregexPattern pattern in headOfCopulaTregex) { TregexMatcher matcher = pattern.Matcher(t); if (matcher.MatchesAt(t)) { return(matcher.GetNode("head")); } } } // if none of the above patterns match, use the standard method } Tree[] tmpFilteredChildren = null; // do VPs with auxiliary as special case if ((motherCat.Equals(AbstractCollinsHeadFinder.VerbPhrase) || motherCat.Equals("SQ") || motherCat.Equals("SINV"))) { Tree[] kids = t.Children(); // try to find if there is an auxiliary verb // looks for auxiliaries if (HasVerbalAuxiliary(kids, verbalAuxiliaries, true) || HasPassiveProgressiveAuxiliary(kids)) { // string[] how = new string[] {Left, AbstractCollinsHeadFinder.VerbPhrase, CoordinationTransformer.Adjective, CoordinationTransformer.Noun}; // Including NP etc seems okay for copular sentences but is // problematic for other auxiliaries, like 'he has an answer' // But maybe doing ADJP is fine! string[] how = { Left, AbstractCollinsHeadFinder.VerbPhrase, CoordinationTransformer.Adjective }; //tmpFilteredChildren = ArrayUtils.filter(kids, REMOVE_TMP_AND_ADV); tmpFilteredChildren = kids.Where(k => RemoveTmpAndAdv(k)).ToArray(); Tree pti = TraverseLocate(tmpFilteredChildren, how, false); if (pti != null) { return(pti); } } // looks for copular verbs if (HasVerbalAuxiliary(kids, copulars, false) && !IsExistential(t, parent) && !IsWhQ(t, parent)) { string[] how; if (motherCat.Equals("SQ")) { how = new string[] { Right, AbstractCollinsHeadFinder.VerbPhrase, CoordinationTransformer.Adjective, CoordinationTransformer.Noun, WHADJP, WHNP }; } else { how = new string[] { Left, AbstractCollinsHeadFinder.VerbPhrase, CoordinationTransformer.Adjective, CoordinationTransformer.Noun, WHADJP, WHNP }; } // Avoid undesirable heads by filtering them from the list of potential children if (tmpFilteredChildren == null) { //tmpFilteredChildren = ArrayUtils.filter(kids, REMOVE_TMP_AND_ADV); tmpFilteredChildren = kids.Where(k => RemoveTmpAndAdv(k)).ToArray(); } Tree pti = TraverseLocate(tmpFilteredChildren, how, false); // In SQ, only allow an NP to become head if there is another one to the left (then it's probably predicative) if (motherCat.Equals(SQ) && pti != null && pti.Label() != null && pti.Label().Value().StartsWith(CoordinationTransformer.Noun)) { bool foundAnotherNp = false; foreach (Tree kid in kids) { if (kid == pti) { break; } else if (kid.Label() != null && kid.Label().Value().StartsWith(CoordinationTransformer.Noun)) { foundAnotherNp = true; break; } } if (!foundAnotherNp) { pti = null; } } if (pti != null) { return(pti); } } } Tree hd = base.DetermineNonTrivialHead(t, parent); /* ---- * // This should now be handled at the AbstractCollinsHeadFinder level, so see if we can comment this out * // Heuristically repair punctuation heads * Tree[] hdChildren = hd.children(); * if (hdChildren != null && hdChildren.length > 0 && * hdChildren[0].isLeaf()) { * if (tlp.isPunctuationWord(hdChildren[0].label().value())) { * Tree[] tChildren = t.children(); * for (int i = tChildren.length - 1; i >= 0; i--) { * if (!tlp.isPunctuationWord(tChildren[i].children()[0].label().value())) { * hd = tChildren[i]; * break; * } * } * } * } */ return(hd); }
private bool ShouldSkip(Tree t, bool origWasInterjection) { return(t.IsPreTerminal() && (Tlp.IsPunctuationTag(t.Value()) || !origWasInterjection && PartsOfSpeech.Interjection.Equals(t.Value())) || INTJ.Equals(t.Value()) && !origWasInterjection); }
internal Parameter(Tlp tlp) { _tlp = tlp; _data = null; }