Size() public method

Returns the number of words in the phrase.
public Size ( ) : int
return int
        public bool PhraseNodesAreEqual(PhraseNode pn1, PhraseNode pn2)
        {
            if(pn1 == pn2) {
                return true;
            }
            if(pn1 == null ^ pn2 == null) {
                return false;
            }

            if(pn1.Size() != pn2.Size()) {
                return false;
            }
            for(int i = 0; i < pn1.Size(); i++) {
                if(!WordNodesAreEqual(pn1[i], pn2[i])) {
                    return false;
                }
            }
            return true;
        }
Example #2
0
        /// <summary>
        /// Assigns part-of-speech tags to the word nodes in the given phrase, assuming it is a noun phrase.
        /// Only the words between startIndex and stopIndex, inclusive, are tagged.
        /// </summary>
        /// <param name="phrase">The noun phrase to tag.</param>
        /// <param name="startIndex">The index of the first word to tag.</param>
        /// <param name="stopIndex">The index of the last word to tag.</param>
        /// <exception cref="System.ArgumentOutOfRangeException">startIndex or stopIndex are not valid indices, or stopIndex is less than startIndex</exception>
        public override void TagNounPhrase(PhraseNode phrase, int startIndex, int stopIndex)
        {
            if (phrase == null || phrase.Size() <= 0) { return; }
            if (startIndex < 0 || startIndex >= phrase.Size())
            {
                throw new ArgumentOutOfRangeException("startIndex", startIndex, string.Format("The given value is not a valid index of the PhraseNode. It must be between 0 and {0}.", phrase.Size() - 1));
            }
            if (stopIndex < startIndex || stopIndex >= phrase.Size())
            {
                throw new ArgumentOutOfRangeException("stopIndex", stopIndex, string.Format("The given value must be a valid index of the PhraseNode, and must be larger than the given startIndex value of {0}", startIndex));
            }

            //start from the end of the phrase
            int currentWord = stopIndex;
            //skip any digits at the end
            while (phrase[currentWord].Tag == PartOfSpeechTag.Digit) { currentWord--; }

            //tag the last word
            if (currentWord >= startIndex)
            {
                if (pos.IsDeterminer(phrase[currentWord].Text))
                {
                    phrase[currentWord].Tag = PartOfSpeechTag.Determiner;
                }
                else if (pos.IsPronoun(phrase[currentWord].Text))
                {
                    phrase[currentWord].Tag = PartOfSpeechTag.Pronoun;
                }
                else if (pos.IsIgnorableHeadWord(phrase[currentWord].Text))
                {
                    phrase[currentWord].Tag = PartOfSpeechTag.NounIgnorable;
                }
                else
                {
                    phrase[currentWord].Tag = PartOfSpeechTag.Noun;
                }
                currentWord--;
            }

            //tag the rest of the words
            while (currentWord >= startIndex)
            {
                if (pos.IsDeterminer(phrase[currentWord].Text))
                {
                    phrase[currentWord].Tag = PartOfSpeechTag.Determiner;
                }
                else if (pos.IsPronoun(phrase[currentWord].Text))
                {
                    phrase[currentWord].Tag = PartOfSpeechTag.Pronoun;
                }
                else if (phrase[currentWord].Tag != PartOfSpeechTag.Digit)
                {
                    phrase[currentWord].Tag = PartOfSpeechTag.NounModifier;
                }

                currentWord--;
            }
        }
Example #3
0
 /// <summary>
 /// Assigns part-of-speech tags to the word nodes in the given phrase, assuming it is a noun phrase.
 /// </summary>
 /// <param name="phrase">The noun phrase to tag.</param>
 public override void TagNounPhrase(PhraseNode phrase)
 {
     TagNounPhrase(phrase, 0, phrase.Size() - 1);
 }
Example #4
0
 /// <summary>
 /// Determines whether the given phrase indicates an event handler method.
 /// </summary>
 /// <param name="parsedName">The PhraseNode to test.</param>
 /// <returns>True if the phrase indicates an event handler method, False otherwise.</returns>
 protected bool IsEventHandler(PhraseNode parsedName)
 {
     if (parsedName == null || parsedName.Size() == 0)
     {
         return false;
     }
     else
     {
         return IsNonBaseVerb(parsedName.LastWord().Text)
             && parsedName[0].Text.ToLower() != "get"
             && parsedName[0].Text.ToLower() != "set";
     }
 }
Example #5
0
        /// <summary>
        /// Determines whether the given PhraseNode overlaps with the given word.
        /// The two overlap if the last word of the phrase is the same as the given word, 
        /// or if the second-to-last word of the phrase is the same as the given word and the last word of the phrase is ignorable.
        /// </summary>
        /// <param name="name">The phrase to check for overlap.</param>
        /// <param name="word">The word to check for overlap with.</param>
        /// <returns>True if the phrase and word overlap, False otherwise.</returns>
        private bool HasOverlap(PhraseNode name, string word)
        {
            if (name == null || name.Size() == 0 || string.IsNullOrEmpty(word)) { return false; }

            bool hasOverlap = false;
            if (string.Equals(name.LastWord().Text, word, StringComparison.InvariantCultureIgnoreCase))
            {
                //last word of name is same as given word
                hasOverlap = true;
            }
            else if (name.Size() > 1)
            {
                if (string.Equals(name[name.Size() - 2].Text, word, StringComparison.InvariantCultureIgnoreCase) 
                    && PosData.IsIgnorableHeadWord(name.LastWord().Text))
                {
                    //second-to-last word of name is same as given word, and the last word of name is ignorable
                    hasOverlap = true;
                }
            }

            return hasOverlap;
        }
Example #6
0
 /// <summary>
 /// Returns a PhraseNode containing the noun phrase words from the given name, starting from startIndex.
 /// All noun phrase words prior to the first encountered preposition are included.
 /// </summary>
 /// <param name="parsedName">The PhraseNode to get the noun phrase from.</param>
 /// <param name="startIndex">The index of the word to start from.</param>
 private PhraseNode GetNounPhrase(PhraseNode parsedName, int startIndex)
 {
     PhraseNode phrase = parsedName.GetNewEmpty();
     for (int i = startIndex; i < parsedName.Size(); i++)
     {
         PartOfSpeechTag tag = parsedName[i].Tag;
         if (tag == PartOfSpeechTag.Noun
             || tag == PartOfSpeechTag.NounModifier
             || tag == PartOfSpeechTag.Determiner
             || tag == PartOfSpeechTag.Pronoun
             || tag == PartOfSpeechTag.NounIgnorable
             || tag == PartOfSpeechTag.Digit
             || tag == PartOfSpeechTag.Preamble)
         {
             phrase.Add(parsedName[i]);
         }
         else if (tag == PartOfSpeechTag.Preposition)
         {
             break;
         }
     }
     return phrase;
 }
Example #7
0
 /// <summary>
 /// Finds the index of the first preposition within the given PhraseNode, starting from the word indicated by startIndex.
 /// </summary>
 /// <param name="parsedName">The PhraseNode to search.</param>
 /// <param name="startIndex">The index of the word to start searching for prepositions from.</param>
 /// <returns>The index of the first preposition in the PhraseNode after startIndex, inclusively.</returns>
 private int FindFirstPreposition(PhraseNode parsedName, int startIndex)
 {
     for (int i = startIndex; i < parsedName.Size(); i++)
     {
         if (parsedName[i].Tag == PartOfSpeechTag.Preposition) { return i; }
     }
     return -1;
 }
Example #8
0
 /// <summary>
 /// Determines whether the specified word in the given phrase is an ignorable verb. If so, it tags it appropriately.
 /// </summary>
 /// <param name="parsedName">The PhraseNode containing the word to check.</param>
 /// <param name="wordIndex">The index of the desired word within the PhraseNode.</param>
 /// <returns>wordIndex+1 if the word was an ignorable verb; wordIndex if it was not.</returns>
 private int CheckForIgnorableVerb(PhraseNode parsedName, int wordIndex)
 {
     if (wordIndex < parsedName.Size() - 1 //make sure last word in name is verb
         && (PosData.IsIgnorableVerb(parsedName[wordIndex].Text)
             && (PositionalFrequencies.GetVerbProbability(parsedName[wordIndex + 1].Text) > PositionalFrequencies.GetNounProbability(parsedName[wordIndex + 1].Text))
             || PosData.IsModalVerb(parsedName[wordIndex].Text))
         )
     {
         parsedName[wordIndex].Tag = PartOfSpeechTag.VerbIgnorable;
         wordIndex++;
     }
     return wordIndex;
 }