Examples of simplenlg.framework.WordElement$InflectionSet

simplenlg.framework.WordElement
This is the class for a lexical entry (ie, a word). Words are stored in a {@link simplenlg.lexicon.Lexicon}, and usually the developer retrieves a WordElement via a lookup method in the lexicon Words always have a base form, and usually have a {@link simplenlg.framework.LexicalCategory}. They may also have a Lexicon ID. Words also have features (which are retrieved from the Lexicon), these are held in the standard NLGElement feature map @author E. Reiter, University of Aberdeen. @version 4.0

        || modifier.isA(PhraseCategory.NOUN_PHRASE)) {


      position = NOUN_POSITION;
    } else if (modifier.isA(LexicalCategory.ADJECTIVE)
        || modifier.isA(PhraseCategory.ADJECTIVE_PHRASE)) {
      WordElement adjective = getHeadWordElement(modifier);


      if (adjective.getFeatureAsBoolean(LexicalFeature.QUALITATIVE)
          .booleanValue()) {
        position = QUALITATIVE_POSITION;
      } else if (adjective.getFeatureAsBoolean(LexicalFeature.COLOUR)
          .booleanValue()) {
        position = COLOUR_POSITION;
      } else if (adjective
          .getFeatureAsBoolean(LexicalFeature.CLASSIFYING)
          .booleanValue()) {
        position = CLASSIFYING_POSITION;
      }
    }

View Full Code Here

    // Assert.assertEquals("earlier",
    // early.getFeatureAsString(Feature.COMPARATIVE));


    // test getWord. Comparative of ADJ "good" is "better", superlative is
    // "best", this is a qualitative and predicative adjective
    WordElement good = lexicon.getWord("good", LexicalCategory.ADJECTIVE);
    Assert.assertEquals("better", good
        .getFeatureAsString(LexicalFeature.COMPARATIVE));
    Assert.assertEquals("best", good
        .getFeatureAsString(LexicalFeature.SUPERLATIVE));
    Assert.assertEquals(true, good.getFeatureAsBoolean(
        LexicalFeature.QUALITATIVE).booleanValue());
    Assert.assertEquals(true, good.getFeatureAsBoolean(
        LexicalFeature.PREDICATIVE).booleanValue());
    Assert.assertEquals(false, good.getFeatureAsBoolean(
        LexicalFeature.COLOUR).booleanValue());
    Assert.assertEquals(false, good.getFeatureAsBoolean(
        LexicalFeature.CLASSIFYING).booleanValue());


    // test getWord. There is only one "woman", and its plural is "women".
    // It is not an acronym, not proper, and countable
    WordElement woman = lexicon.getWord("woman");


    Assert.assertEquals("women", woman
        .getFeatureAsString(LexicalFeature.PLURAL));
    Assert.assertEquals(null, woman
        .getFeatureAsString(LexicalFeature.ACRONYM_OF));
    Assert.assertEquals(false, woman.getFeatureAsBoolean(
        LexicalFeature.PROPER).booleanValue());
    Assert.assertFalse(woman.hasInflectionalVariant(Inflection.UNCOUNT));


    // NB: This fails if the lexicon is XMLLexicon. No idea why.
    // Assert.assertEquals("irreg",
    // woman.getFeatureAsString(LexicalFeature.DEFAULT_INFL));


    // test getWord. Noun "sand" is non-count
    WordElement sand = lexicon.getWord("sand", LexicalCategory.NOUN);
    Assert.assertEquals(true, sand.hasInflectionalVariant(Inflection.UNCOUNT));
    Assert.assertEquals(Inflection.UNCOUNT, sand.getDefaultInflectionalVariant());


    // test hasWord
    Assert.assertEquals(true, lexicon.hasWord("tree")); // "tree" exists
    Assert.assertEquals(false, lexicon.hasWord("tree",
        LexicalCategory.ADVERB)); // but not as an adverb


    // test getWordByID; quickly, also check that this is a verb_modifier
    WordElement quickly = lexicon.getWordByID("E0051632");
    Assert.assertEquals("quickly", quickly.getBaseForm());
    Assert.assertEquals(LexicalCategory.ADVERB, quickly.getCategory());
    Assert.assertEquals(true, quickly.getFeatureAsBoolean(
        LexicalFeature.VERB_MODIFIER).booleanValue());
    Assert.assertEquals(false, quickly.getFeatureAsBoolean(
        LexicalFeature.SENTENCE_MODIFIER).booleanValue());
    Assert.assertEquals(false, quickly.getFeatureAsBoolean(
        LexicalFeature.INTENSIFIER).booleanValue());


    // test getWordFromVariant, verb type (tran or intran, not ditran)
    WordElement eat = lexicon.getWordFromVariant("eating");
    Assert.assertEquals("eat", eat.getBaseForm());
    Assert.assertEquals(LexicalCategory.VERB, eat.getCategory());
    Assert.assertEquals(true, eat.getFeatureAsBoolean(
        LexicalFeature.INTRANSITIVE).booleanValue());
    Assert.assertEquals(true, eat.getFeatureAsBoolean(
        LexicalFeature.TRANSITIVE).booleanValue());
    Assert.assertEquals(false, eat.getFeatureAsBoolean(
        LexicalFeature.DITRANSITIVE).booleanValue());


    // test BE is handled OK
    Assert.assertEquals("been", lexicon.getWordFromVariant("is",
        LexicalCategory.VERB).getFeatureAsString(
        LexicalFeature.PAST_PARTICIPLE));


    // test modal
    WordElement can = lexicon.getWord("can", LexicalCategory.MODAL);
    Assert.assertEquals("could", can
        .getFeatureAsString(LexicalFeature.PAST));


    // test non-existent word
    Assert.assertEquals(0, lexicon.getWords("akjmchsgk").size());

View Full Code Here

      String line = wordListFile.readLine();
      while (line != null) {
        String[] cols = line.split(",");
        String base = cols[0];
        String cat = cols[1];
        WordElement word = null;
        if (cat.equalsIgnoreCase("noun"))
          word = lex.getWord(base, LexicalCategory.NOUN);
        else if (cat.equalsIgnoreCase("verb"))
          word = lex.getWord(base, LexicalCategory.VERB);
        else if (cat.equalsIgnoreCase("adv"))
          word = lex.getWord(base, LexicalCategory.ADVERB);
        else if (cat.equalsIgnoreCase("adj"))
          word = lex.getWord(base, LexicalCategory.ADJECTIVE);
        else if (cat.equalsIgnoreCase("det"))
          word = lex.getWord(base, LexicalCategory.DETERMINER);
        else if (cat.equalsIgnoreCase("prep"))
          word = lex.getWord(base, LexicalCategory.PREPOSITION);
        else if (cat.equalsIgnoreCase("pron"))
          word = lex.getWord(base, LexicalCategory.PRONOUN);
        else if (cat.equalsIgnoreCase("conj"))
          word = lex.getWord(base, LexicalCategory.CONJUNCTION);
        else if (cat.equalsIgnoreCase("modal"))
          word = lex.getWord(base, LexicalCategory.MODAL);
        else if (cat.equalsIgnoreCase("interjection"))
          word = lex.getWord(base, LexicalCategory.NOUN); // Kilgarriff;s interjections are mostly nouns in the lexicon
        
        if (word == null)
          System.out.println("Missing " + base + ":" + cat);
        else
          xmlFile.write(word.toXML());
        line = wordListFile.readLine();;
      }
      xmlFile.write(String.format("</lexicon>%n"));
      wordListFile.close();
      xmlFile.close();

View Full Code Here

  private static int getMaxPos(NLGElement modifier) {
    int position = NOUN_POSITION;


    if (modifier.isA(LexicalCategory.ADJECTIVE)
        || modifier.isA(PhraseCategory.ADJECTIVE_PHRASE)) {
      WordElement adjective = getHeadWordElement(modifier);


      if (adjective.getFeatureAsBoolean(LexicalFeature.CLASSIFYING)
          .booleanValue()) {
        position = CLASSIFYING_POSITION;
      } else if (adjective.getFeatureAsBoolean(LexicalFeature.COLOUR)
          .booleanValue()) {
        position = COLOUR_POSITION;
      } else if (adjective
          .getFeatureAsBoolean(LexicalFeature.QUALITATIVE)
          .booleanValue()) {
        position = QUALITATIVE_POSITION;
      } else {
        position = CLASSIFYING_POSITION;

View Full Code Here

   * @param element
   *            the <code>NLGElement</code> from which the head is required.
   * @return the <code>WordElement</code>
   */
  private static WordElement getHeadWordElement(NLGElement element) {
    WordElement head = null;


    if (element instanceof WordElement)
      head = (WordElement) element;
    else if (element instanceof InflectedWordElement) {
      head = (WordElement) element.getFeature(InternalFeature.BASE_WORD);

View Full Code Here

  }
  
  @Test
  public void testMultipleSpecifics() {
    // try to get word which is only in NIH lexicon
    WordElement UK = lexicon.getWord("UK");
    Assert.assertEquals("United Kingdom", UK.getFeatureAsString(LexicalFeature.ACRONYM_OF));


    // test alwaysSearchAll flag
    boolean alwaysSearchAll = lexicon.isAlwaysSearchAll();
    
    // tree as noun exists in both, but as verb only in NIH

View Full Code Here

      addPreModifier(modifierElement);
      return;
    }


    // else extract WordElement if modifier is a single word
    WordElement modifierWord = null;
    if (modifierElement != null && modifierElement instanceof WordElement)
      modifierWord = (WordElement) modifierElement;
    else if (modifierElement != null
        && modifierElement instanceof InflectedWordElement)
      modifierWord = ((InflectedWordElement) modifierElement)
          .getBaseWord();


    // check if modifier is an adjective
    if (modifierWord != null
        && modifierWord.getCategory() == LexicalCategory.ADJECTIVE) {
      addPreModifier(modifierWord);
      return;
    }


    // default case

View Full Code Here

      addPreModifier(modifierElement);
      return;
    }


    // extract WordElement if modifier is a single word
    WordElement modifierWord = null;
    if (modifierElement != null && modifierElement instanceof WordElement)
      modifierWord = (WordElement) modifierElement;
    else if (modifierElement != null
        && modifierElement instanceof InflectedWordElement)
      modifierWord = ((InflectedWordElement) modifierElement)
          .getBaseWord();


    if (modifierWord != null
        && modifierWord.getCategory() == LexicalCategory.ADVERB) {
      // adverb rules
      if (modifierWord
          .getFeatureAsBoolean(LexicalFeature.SENTENCE_MODIFIER))
        addFrontModifier(modifierWord);
      else
        addPreModifier(modifierWord);
      return;

View Full Code Here

  public void testKalijurand() {
    // K Kalijurand's test
        String lemma = "walk"; 




        WordElement word = lexicon.lookupWord(lemma,  LexicalCategory.VERB); 
        InflectedWordElement inflectedWord = new InflectedWordElement(word); 


        inflectedWord.setFeature(Feature.FORM, Form.PAST_PARTICIPLE); 
        String form = realiser.realise(inflectedWord).getRealisation(); 
        Assert.assertEquals("walked", form);

View Full Code Here

0 1 2

TOP

Related Classes of simplenlg.framework.WordElement$InflectionSet

simplenlg.lexicon.dumpXML

simplenlg.lexicon.Lexicon

simplenlg.lexicon.NIHDBLexicon

simplenlg.lexicon.XMLLexicon

simplenlg.phrasespec.NPPhraseSpec

simplenlg.phrasespec.SPhraseSpec

simplenlg.phrasespec.VPPhraseSpec

simplenlg.syntax.english.NounPhraseHelper

simplenlg.syntax.english.SyntaxProcessor

simplenlg.test.lexicon.LexicalVariantsTests

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.