Java POS.VERB属性代码示例

public static POS getJWIStylePos(String postag){
	
	if (verb_postag.contains(postag)){
		return POS.VERB;
	} 
	else if (real_noun_postag.contains(postag)){
		return POS.NOUN;
	} 
	else if  (adj_postag.contains(postag)){
		return POS.ADJECTIVE;
	} 
	else if (adv_postag.contains(postag)){
		return POS.ADVERB;
	} 
	else {
		return POS.NOUN;
	}
}
 

public boolean check(Map<Variable, String> assignment)
{
   final String sourceString = source == null ? sourceLiteral : assignment.get(source);
   final String targetString = target == null ? targetLiteral : assignment.get(target);

   String posString = source != null ? source.type : target.type;
   POS pos = posString.equals("noun") ? POS.NOUN : POS.VERB;
   // if we're checking a constraint where one of the variables hasn't been
   // assigned yet, it passes for now
   if (sourceString == null || targetString == null)
      return true;
   if (hypernym)
      return wordNet.isHypernym(pos, sourceString, pos, targetString);
   // hyponym otherwise, which is just the reverse
   return wordNet.isHypernym(pos, targetString, pos, sourceString);
}
 

/**
 * JWI POS tag from Penn tag. (by Nils Reiter)
 * 
 * @param postag
 * @return
 */
public static POS getPOSFromPenn(String postag) {
	POS pos = null;
	switch (postag.charAt(0)) {
	case 'J':
	case 'j':
		pos = POS.ADJECTIVE;
		break;
	case 'N':
	case 'n':
		pos = POS.NOUN;
		break;
	case 'V':
	case 'v':
		pos = POS.VERB;
		break;
	case 'R':
	case 'r':
		if (postag.charAt(1) == 'B' || postag.charAt(1) == 'b')
			pos = POS.ADVERB;
		break;
	}
	return pos;
}
 

public static POS convertArk(String arkTag) {
  if (arkTag.equals("N") || arkTag.equals("O") || arkTag.equals("^")
      || arkTag.equals("S") || arkTag.equals("Z")) {
    return POS.NOUN;
  }
  if (arkTag.equals("V")) {
    return POS.VERB;
  }
  if (arkTag.equals("A")) {
    return POS.ADJECTIVE;
  }
  if (arkTag.equals("R")) {
    return POS.ADVERB;
  }
  return null;
}
 

public static POS getWordnetPOS(CoreLabel word){
	
	String stanfordPOS = word.getString(PartOfSpeechAnnotation.class);
	
	if(stanfordPOS.startsWith("N"))
		return POS.NOUN;
	if(stanfordPOS.startsWith("J"))
		return POS.ADJECTIVE;
	if(stanfordPOS.startsWith("V"))
		return POS.VERB;
	if(stanfordPOS.startsWith("R"))
		return POS.ADVERB;
	
	return null;
	
	
}
 

public String getMeaning(int nType, int order){
	POS pos;
	switch(nType){
	case nNOUN:
		pos = POS.NOUN;
		break;
	case nVERB:
		pos = POS.VERB;
		break;
	case nADJ:
		pos = POS.ADJECTIVE;
		break;
	case nADV:
		pos = POS.ADVERB;
		break;
	default:
		pos = POS.NOUN;
		break;
	}
	String gloss = dict.getSynset(
			dict.getIndexWord(wordName, pos).getWordIDs().get(order).getSynsetID()).getGloss();
	int partitionIndex = gloss.indexOf('\"');
	return gloss.substring(0, (partitionIndex < 0) ? gloss.length() : partitionIndex);
}
 

private static POS getSynsetType(String pos) {
  if (!synsetTypeForPOS.containsKey(pos)) {
    POS result = null;
  
    if (pos.startsWith("NN")) {
      result = POS.NOUN;
    } else if (pos.startsWith("VB")) {
      result = POS.VERB;
    } else if (pos.startsWith("RB")) {
      result = POS.ADVERB;
    } else if (pos.startsWith("JJ")) {
      result = POS.ADJECTIVE;
    }
    
    if (result != null) {
      synsetTypeForPOS.put(pos, result);
    }
  }
  
  return synsetTypeForPOS.get(pos);
}
 

/**
 * converts string to {@link POS}
 * @param tag
 * @return
 */
public static POS getTagfromTag(String tag)
{
	if(tag.toLowerCase().startsWith("n"))
		return POS.NOUN;
	
	else
		if(tag.toLowerCase().startsWith("v"))
			return POS.VERB;
	
	else
		if(tag.toLowerCase().startsWith("r") || tag.toLowerCase().startsWith("adv"))
			return POS.ADVERB;
		
	else
		if(tag.toLowerCase().startsWith("j") 
				|| tag.toLowerCase().startsWith("adj") 
				|| tag.toLowerCase().startsWith("a"))
			return POS.ADJECTIVE;
		
	return null;
}
 

private POS getPOS(TAG pos) {

		POS ps = null;

		switch (pos) {

		case n:
			ps = POS.NOUN;
			break;

		case v:
			ps = POS.VERB;
			break;

		case a:
			ps = POS.ADJECTIVE;
			break;

		case r:
			ps = POS.ADVERB;
			break;

		default:
			ps = POS.NOUN;
			break;
		}

		return ps;
	}
 

private POS getCorrectPOS(String pos) {
  if (pos.startsWith("NN"))
    return POS.NOUN;
  else if (pos.startsWith("VB"))
    return POS.VERB;
  return POS.NOUN;
}
 

public static POS parseString(String tag) {
  switch (tag.charAt(0)) {
    case 'n':
      return POS.NOUN;
    case 'v':
      return POS.VERB;
    case 'a':
      return POS.ADJECTIVE;
    case 'r':
      return POS.ADVERB;
    default:
      throw new IllegalStateException("Unknown POS tag '" + tag + "'!");
  }
}
 

public static POS convertPTB(String pennTag) {
  if (pennTag.startsWith("NN")) { // includes proper nouns
    return POS.NOUN;
  }
  if (pennTag.startsWith("VB")) {
    return POS.VERB;
  }
  if (pennTag.startsWith("JJ")) {
    return POS.ADJECTIVE;
  }
  if (pennTag.startsWith("RB")) {
    return POS.ADVERB;
  }
  return null;
}
 

public POS toPOS(String pos) {
	if (pos.equals("noun"))
		return POS.NOUN;
	if (pos.equals("verb"))
		return POS.VERB;
	if (pos.equals("adj"))
		return POS.ADJECTIVE;
	if (pos.equals("adv"))
		return POS.ADVERB;
	return null;
}
 

/**
 * Retrieve Wordnet POS 
 **/
private POS retrieveWordnetPOS(String pos){
	if (pos.toUpperCase().startsWith("VB") || pos.toUpperCase().equals("MD")) { 
		return POS.VERB; 
	} else if (pos.toUpperCase().startsWith("NN")) { 
		return POS.NOUN; 
	} else if(pos.toUpperCase().startsWith("RB") || pos.toUpperCase().equals("WRB")){ 
		return POS.ADVERB; 
	} else if(pos.toUpperCase().startsWith("JJ")){
		return POS.ADJECTIVE; 
	} else { 
		return null; 
	}
}
 

private POS retrieveWordnetPOS(String pos){
	if(pos.toUpperCase().startsWith("VB") || pos.toUpperCase().equals("MD")){
		return POS.VERB; 
	} else if(pos.toUpperCase().startsWith("NN")){
		return POS.NOUN; 
	} else if(pos.toUpperCase().startsWith("RB") || pos.toUpperCase().equals("WRB")){
		return POS.ADVERB; 
	} else if(pos.toUpperCase().startsWith("JJ")){
		return POS.ADJECTIVE; 
	} else {
		return null; 
	}
}