import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static String[] getSenseBag(Synset synset) {
    String senseBag = "";

    VerbSynset verbSynset = (VerbSynset) synset;
    senseBag += getSynsetBag(verbSynset);

    VerbSynset[] troponyms = verbSynset.getTroponyms();
    for (VerbSynset troponym : troponyms)
        senseBag += getSynsetBag(troponym);

    VerbSynset[] entailments = verbSynset.getEntailments();
    for (VerbSynset entailment : entailments)
        senseBag += getSynsetBag(entailment);

    VerbSynset[] outcomes = verbSynset.getOutcomes();
    for (VerbSynset outcome : outcomes)
        senseBag += getSynsetBag(outcome);

    VerbSynset[] hypernyms = verbSynset.getHypernyms();
    for (VerbSynset hypernym : hypernyms)
        senseBag += getSynsetBag(hypernym);

    return extractWordsFromSenseBag(senseBag);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static String[] getSenseBag(Synset synset, String word) {
    String senseBag = "";

    AdverbSynset adverbSynset = (AdverbSynset) synset;
    senseBag += getSynsetBag(adverbSynset);

    NounSynset[] topics = adverbSynset.getTopics();
    for (NounSynset topic : topics)
        senseBag += getSynsetBag(topic);

    WordSense[] pertainyms = adverbSynset.getPertainyms(word);
    for (WordSense pertainym : pertainyms)
        senseBag += getSynsetBag(pertainym.getSynset());

    WordSense[] antonyms = adverbSynset.getAntonyms(word);
    for (WordSense antonym : antonyms)
        senseBag += getSynsetBag(antonym.getSynset());

    return extractWordsFromSenseBag(senseBag);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static String[] getSenseBag(Synset synset) {
    String senseBag = "";

    NounSynset nounSynset = (NounSynset) synset;
    senseBag += getSynsetBag(nounSynset);

    NounSynset[] hyponyms = nounSynset.getHyponyms();
    for (NounSynset hyponym : hyponyms)
        senseBag += getSynsetBag(hyponym);

    NounSynset[] meronyms = nounSynset.getMemberMeronyms();
    for (NounSynset meronym : meronyms)
        senseBag += getSynsetBag(meronym);

    return extractWordsFromSenseBag(senseBag);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
private static String[] getSenseBag(Synset synset, String word) {
    if(synset == null)
        return new String[0];

    SynsetType pos = synset.getType();

    if(pos == SynsetType.NOUN) {
        return NounSenseBag.getSenseBag(synset);
    } else if (pos == SynsetType.VERB) {
        return VerbSenseBag.getSenseBag(synset);
    } else if(pos == SynsetType.ADJECTIVE) {
        return AdjectiveSenseBag.getSenseBag(synset, word);
    } else if(pos == SynsetType.ADJECTIVE_SATELLITE) {
        return AdjectiveSenseBag.getSenseBag(synset, word);
    } else if(pos == SynsetType.ADVERB) {
        return AdverbSenseBag.getSenseBag(synset, word);
    }

    return new String[0];
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public double computeSimilarity(Synset synset1, String word1, Synset synset2, String word2){
    SynsetType pos1 = null, pos2 = null;

    try {
        pos1 = synset1.getType();
        pos2 = synset2.getType();
    } catch(Exception e){
        System.out.printf("ok");
    }

    if(pos1 == SynsetType.NOUN && pos2 == SynsetType.NOUN) {
        return NounSimilarity.similarity(synset1, synset2);
    } else if(pos1 == SynsetType.VERB && pos2 == SynsetType.VERB) {
        return VerbSimilarity.similarity(synset1, synset2);
    } else if(AdjectiveSimilarity.synsetTypeAdjective(pos1, pos2)) {
        return AdjectiveSimilarity.similarity(synset1, word1, synset2, word2);
    } else if(pos1 == SynsetType.ADVERB && pos2 == SynsetType.ADVERB) {
        return AdverbSimilarity.similarity(synset1, word1, synset2, word2);
    } else {
        return SynsetSimilarity.similarity(synset1, synset2);
    }
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 * Extract from WordNet Database the synsets of a word
 * @param wnDatabase WordNet Database
 * @param word The word that we want to extract its synsets
 * @param synsetType POS Tag of the word
 * @return Array of Synsets
 */
public static Synset[] getSynsetsFromWord(WordNetDatabase wnDatabase, String word, SynsetType synsetType) {
    Synset[] tmpSynsets;

    if(synsetType == null)
        tmpSynsets = wnDatabase.getSynsets(word);
    else {
        tmpSynsets = wnDatabase.getSynsets(word, synsetType);

        // If the synset type is an adjective, check for adjective satellite too
        if (synsetType == SynsetType.ADJECTIVE) {
            tmpSynsets = (Synset[])ArrayUtils.addAll(tmpSynsets, wnDatabase.getSynsets(word, SynsetType.ADJECTIVE_SATELLITE));
        }
    }

    return tmpSynsets;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public Synset[] convertFinalSynsets(String[] finalSenses){
    int wordIndex, senseIndex;
    String[] split;
    Synset[] synsets = new Synset[finalSenses.length];

    for (int i = 0; i < finalSenses.length; i++) {
        if(finalSenses[i] == null){
            synsets[i] = null;
        } else {
            split = finalSenses[i].split("-");

            wordIndex = Integer.parseInt(split[0]);
            senseIndex = Integer.parseInt(split[1]);

            synsets[i] = getSynset(wordIndex, senseIndex);
        }
    }

    return synsets;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static boolean isMostlyNounInWordNet(String word) {
	Synset[] synsets = database.getSynsets(word);
	if (synsets.length == 0) {
		return true;
	}
	Synset[] n_synsets = database.getSynsets(word, SynsetType.NOUN);
	Synset[] v_synsets = database.getSynsets(word, SynsetType.VERB);
	Synset[] a_synsets = database.getSynsets(word, SynsetType.ADJECTIVE);
	Synset[] ad_synsets = database.getSynsets(word, SynsetType.ADVERB);
	//		System.out.println(word + " " + n_synsets.length + " " + a_synsets.length + ad_synsets.length);
	if (n_synsets.length != 0 && n_synsets.length > a_synsets.length && 
			n_synsets.length > ad_synsets.length) {// && n_synsets.length > v_synsets.length) {
		return true;
	}
	return false;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static boolean isMostlyAdjectiveInWordNet(String word) {
	Synset[] synsets = database.getSynsets(word);
	if (synsets.length == 0) {
		return true;
	}
	Synset[] n_synsets = database.getSynsets(word, SynsetType.NOUN);
	Synset[] v_synsets = database.getSynsets(word, SynsetType.VERB);
	Synset[] a_synsets = database.getSynsets(word, SynsetType.ADJECTIVE);
	Synset[] ad_synsets = database.getSynsets(word, SynsetType.ADVERB);
	//		System.out.println(word + " " + n_synsets.length + " " + a_synsets.length + ad_synsets.length);
	if (a_synsets.length != 0 && a_synsets.length > n_synsets.length && 
			a_synsets.length > ad_synsets.length && a_synsets.length > v_synsets.length) {
		return true;
	}
	return false;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static boolean canWordBeNounOrAdjInWordNet(String word) {
	Synset[] synsets = database.getSynsets(word, SynsetType.NOUN);
	if (synsets.length == 0) {
		synsets = database.getSynsets(word, SynsetType.ADJECTIVE);
		if (synsets.length == 0) {
			synsets = database.getSynsets(word);
			if (synsets.length == 0 && word.length() > 3) {
				return true;
			}
			return false;
		} else {
			return true;
		}
	} else {
		return true;
	}
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 * Converts unresolved pointers of a particular type to resolved
 * references to the corresponding synsets.
 * <br><p>
 * Note that on successful completion of this method that the pointers
 * that were resolved will be removed. This is done to reduce memory
 * usage since the pointers are presumed to no longer be needed given
 * that their sole purpose was to provide eventual access to their
 * corresponding synsets.
 * 
 * @param  type Type of relationships to resolve and return.
 * @return Synsets that were referenced by pointers or <code>null</code>
 *         if no pointers existed for the specified type.
 * @throws WordNetException An error occurred retrieving data.
 */
private Synset[] resolvePointers(RelationshipType type)
		throws WordNetException
{
	Synset[] synsets = null;
	SynsetPointer[] pointers = getPointers(type);
	if (pointers != null)
	{
		SynsetFactory factory = SynsetFactory.getInstance();
		synsets = new Synset[pointers.length];
		for (int i = 0; i < synsets.length; i++)
		{
			synsets[i] = factory.getSynset(pointers[i]);
		}
		clearPointers(type);
	}
	return synsets;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
protected static String getSenseKeysBag(Synset synset) {
    String senseBag = "";

    String[] senseKeys = synset.getSenseKeys();
    for(String senseKey : senseKeys) {
        senseBag += senseKey.split("%")[0] + " ";
    }

    return senseBag;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
protected static String getSynsetBag(Synset synset) {
    String senseBag = " ";
    String[] examples;

    senseBag += getSenseKeysBag(synset);
    senseBag += synset.getDefinition();
    examples = synset.getUsageExamples();

    for (String example1 : examples)
        senseBag += " " + example1;

    return senseBag;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public double computeSimilarity(Synset synset1, String word1, Synset synset2, String word2){
    INDArray[] senseEmbeddings = new INDArray[2];
    senseEmbeddings[0] = Nd4j.create(SenseEmbedding.getSenseEmbedding(wordVectors, synset1, word1, senseComputation));
    senseEmbeddings[1] = Nd4j.create(SenseEmbedding.getSenseEmbedding(wordVectors, synset2, word2, senseComputation));

    return computeSimilarity(senseEmbeddings, null, null, 0, 1);
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 * Generates the sense embedding for each synset of every word from the context window
 */
public Object[] computeSynsetRepresentations(Synset[] windowWordsSynsets, String[] windowWords, int[] synset2WordIndex) {
    Object[] windowWordsSenseEmbeddings = new INDArray[windowWordsSynsets.length];
    for (int k = 0; k < windowWordsSynsets.length; k++) {
        windowWordsSenseEmbeddings[k] = Nd4j.create(SenseEmbedding.getSenseEmbedding(wordVectors, windowWordsSynsets[k], windowWords[synset2WordIndex[k]], senseComputation));
    }

    return windowWordsSenseEmbeddings;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 *
 * @param wordVector The Word Embeddings dictionary
 * @param synset The synset ...
 * @param word The word ...
 * @return The sense embedding of a synset
 */
public static double[] getSenseEmbedding(WordVectors wordVector, Synset synset, String word, SenseComputation senseComputation) {
    if(wordEmbeddings.containsKey(synset)){
        return ArrayUtils.toPrimitive(wordEmbeddings.get(synset));
    }

    String[] words = getSenseBag(synset, word);

    double[] senseEmbedding, tmpEmbedding;
    Double[] tmpEmbedding2, tmpSenseEmbedding;
    ArrayList<Double[]> senseEmbeddings = new ArrayList<>();

    // For each word in the sense bag, get the coresponding word embeddings and store them in an array
    for (String w : words) {
        if (w != null) {
            if (wordVector.hasWord(w)) {
                tmpEmbedding = wordVector.getWordVector(w);

                tmpEmbedding2 = new Double[tmpEmbedding.length];
                for (int i = 0; i < tmpEmbedding.length; i++) {
                    tmpEmbedding2[i] = tmpEmbedding[i];
                }
                senseEmbeddings.add(tmpEmbedding2);
            }
        }
    }

    senseEmbedding = senseComputation.compute(senseEmbeddings);

    tmpSenseEmbedding = new Double[senseEmbedding.length];
    for (int i = 0; i < tmpSenseEmbedding.length; i++) {
        tmpSenseEmbedding[i] = senseEmbedding[i];
    }
    wordEmbeddings.put(synset, tmpSenseEmbedding);

    return senseEmbedding;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public static double similarity(Synset synset1, Synset synset2) {
    double score;
    String gloss1,gloss2;

/* 1. Compute glosses for each synset. */
    gloss1 = SynsetUtils.getGloss(synset1);
    gloss2 = SynsetUtils.getGloss(synset2);

/* 2. Compute the overlap score of the two glosses. */
    score = getScore(gloss1,gloss2);

    return score;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
/**
 * Extract from WordNet Database only the synsets that contains the lemma of a word
 * @param wnDatabase WordNet Database
 * @param word The word that we want to extract its synsets
 * @param synsetType POS Tag of the word
 * @return Array of Synsets
 */
public static Synset[] extractSynsets(WordNetDatabase wnDatabase, String word, SynsetType synsetType) {
    // Extract the senses for the word
    Synset[] tmpSynsets = getSynsetsFromWord(wnDatabase, word, synsetType);

    if(tmpSynsets.length == 0) {
        tmpSynsets = getSynsetsFromWord(wnDatabase, new Sentence(word).lemma(0), synsetType);
    }

    ArrayList<Synset> synsets = new ArrayList<>();
    // Keep only the senses that the lemma is match
    for(Synset tmpSynset : tmpSynsets){
        String[] senseKeys = tmpSynset.getSenseKeys();
        for (int j = 0; j < senseKeys.length; j++) {
            if(senseKeys[j].contains(word.replace(" ", "_"))){
                synsets.add(tmpSynset);
                break;
            }

        }
    }

    Synset[] resultSynsets;

    if(synsets.isEmpty()) {
        resultSynsets = tmpSynsets;
    } else {
        resultSynsets = new Synset[synsets.size()];
        resultSynsets = synsets.toArray(resultSynsets);
    }

    return resultSynsets;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public Synset getSynset(int wordIndex, int senseIndex) {
    Synset[] tmpSynsets;
    Synset synset;


    tmpSynsets = WordUtils.getSynsetsFromWord(wnDatabase, document.getWord(wordIndex), POSUtils.asSynsetType(document.getWordPos(wordIndex)));

    if(tmpSynsets.length == 0) {
        synset = null;
    } else {
        synset = tmpSynsets[senseIndex];
    }

    return synset;
}
 

import edu.smu.tspell.wordnet.Synset; //导入依赖的package包/类
public WindowConfiguration(int[] synsetIndex, String[] windowWords, String[] windowWordsPOS, Synset[] configurationSynsets, double score){
    this.synsetIndex = synsetIndex;
    this.windowWords = windowWords;
    this.windowWordsPOS = windowWordsPOS;
    this.configurationSynsets = configurationSynsets;
    this.score = score;
}