Examples with Synset net.didion.jwnl.data.Synset used on opensource projects

Example 11 with Synset

use of net.didion.jwnl.data.Synset in project lucida by claritylab.

the class WordNet method getHavePart.

/**
	 * Looks up part meronyms of the given noun, assuming that it is used in its
	 * most common sense.
	 * 
	 * @param noun a noun
	 * @return part meronyms or <code>null</code> if lookup failed
	 */
public static String[] getHavePart(String noun) {
    Synset synset = getCommonSynset(noun, NOUN);
    if (synset == null)
        return null;
    Synset[] havePart = getHasPartSynsets(synset);
    if (havePart == null)
        return null;
    return getLemmas(havePart);
}

Example 12 with Synset

use of net.didion.jwnl.data.Synset in project lucida by claritylab.

the class WordNet method getEntailing.

// relations for verbs
/**
	 * Looks up verbs that entail the given verb, assuming that it is used in
	 * its most common sense.
	 * 
	 * @param verb a verb
	 * @return entailing verbs or <code>null</code> if lookup failed
	 */
public static String[] getEntailing(String verb) {
    Synset synset = getCommonSynset(verb, VERB);
    if (synset == null)
        return null;
    Synset[] entailing = getEntailingSynsets(synset);
    if (entailing == null)
        return null;
    return getLemmas(entailing);
}

Example 13 with Synset

use of net.didion.jwnl.data.Synset in project lucida by claritylab.

the class WordNet method getPartsOf.

/**
	 * Looks up part holonyms of the given noun, assuming that it is used in its
	 * most common sense.
	 * 
	 * @param noun a noun
	 * @return part holonyms or <code>null</code> if lookup failed
	 */
public static String[] getPartsOf(String noun) {
    Synset synset = getCommonSynset(noun, NOUN);
    if (synset == null)
        return null;
    Synset[] partsOf = getPartOfSynsets(synset);
    if (partsOf == null)
        return null;
    return getLemmas(partsOf);
}

Example 14 with Synset

use of net.didion.jwnl.data.Synset in project lucida by claritylab.

the class WordNet method getHaveMember.

/**
	 * Looks up member meronyms of the given noun, assuming that it is used in
	 * its most common sense.
	 * 
	 * @param noun a noun
	 * @return member meronyms or <code>null</code> if lookup failed
	 */
public static String[] getHaveMember(String noun) {
    Synset synset = getCommonSynset(noun, NOUN);
    if (synset == null)
        return null;
    Synset[] haveMember = getHasMemberSynsets(synset);
    if (haveMember == null)
        return null;
    return getLemmas(haveMember);
}

Example 15 with Synset

use of net.didion.jwnl.data.Synset in project lucida by claritylab.

the class WordNet method expandEvent.

/**
	 * Expands an event by looking up related events.
	 * 
	 * @param event an event
	 * @return related events and their weights
	 */
public Map<String, Double> expandEvent(String event) {
    if (!isVerb(event))
        return new Hashtable<String, Double>();
    // synsets of related concepts
    Map<Synset, Double> synsets = new Hashtable<Synset, Double>();
    // synsets that have already been expanded
    Map<Synset, Double> expanded = new Hashtable<Synset, Double>();
    // get most common synset
    double hurdle = TermExpander.MIN_EXPANSION_WEIGHT;
    if (SYNONYM_WEIGHT >= hurdle) {
        Synset synset = getCommonSynset(event, VERB);
        if (synset != null)
            synsets.put(synset, 1d);
    }
    // expand synsets
    int pathLength = 0;
    while (pathLength++ < MAX_PATH_LENGTH && synsets.size() > 0) {
        // get synsets and their weights
        Synset[] currSynsets = synsets.keySet().toArray(new Synset[synsets.size()]);
        double[] currWeights = new double[synsets.size()];
        for (int i = 0; i < synsets.size(); i++) currWeights[i] = synsets.get(currSynsets[i]);
        for (int i = 0; i < currSynsets.length; i++) {
            Synset synset = currSynsets[i];
            double weight = currWeights[i];
            // move to expanded synsets
            if (synsets.get(synset) == weight)
                synsets.remove(synset);
            if (!expanded.containsKey(synset) || expanded.get(synset) < weight) {
                expanded.put(synset, weight);
            } else
                continue;
            // 'hypernym' relation
            double hypernymWeight = weight * HYPERNYM_WEIGHT;
            if (hypernymWeight >= hurdle) {
                Synset[] hypernyms = getHypernymSynsets(synset);
                for (Synset hypernym : hypernyms) if (!synsets.containsKey(hypernym) || synsets.get(hypernym) < hypernymWeight)
                    synsets.put(hypernym, hypernymWeight);
            }
            // 'hyponym' relation
            double hyponymWeight = weight * HYPONYM_WEIGHT;
            if (hyponymWeight >= hurdle) {
                Synset[] hyponyms = getHyponymSynsets(synset);
                for (Synset hyponym : hyponyms) if (!synsets.containsKey(hyponym) || synsets.get(hyponym) < hyponymWeight)
                    synsets.put(hyponym, hyponymWeight);
            }
            // 'entailing' relation
            double entailingWeight = weight * ENTAILING_WEIGHT;
            if (entailingWeight >= hurdle) {
                Synset[] entailing = getEntailingSynsets(synset);
                for (Synset entails : entailing) if (!synsets.containsKey(entails) || synsets.get(entails) < entailingWeight)
                    synsets.put(entails, entailingWeight);
            }
            // 'causing' relation
            double causingWeight = weight * CAUSING_WEIGHT;
            if (causingWeight >= hurdle) {
                Synset[] causing = getCausingSynsets(synset);
                for (Synset causes : causing) if (!synsets.containsKey(causes) || synsets.get(causes) < causingWeight)
                    synsets.put(causes, causingWeight);
            }
        }
    }
    for (Synset synset : synsets.keySet()) {
        double weight = synsets.get(synset);
        if (!expanded.containsKey(synset) || expanded.get(synset) < weight)
            expanded.put(synset, weight);
    }
    // get concepts in synsets
    Map<String, Double> expansions = new Hashtable<String, Double>();
    for (Synset synset : expanded.keySet()) {
        double weight = expanded.get(synset);
        // direct synonyms
        if (weight == 1)
            weight = SYNONYM_WEIGHT;
        for (String expansion : getLemmas(synset)) if (!expansions.containsKey(expansion) || expansions.get(expansion) < weight)
            expansions.put(expansion, weight);
    }
    List<String> dropped = new ArrayList<String>();
    for (String expansion : expansions.keySet()) if (expansion.equalsIgnoreCase(event))
        dropped.add(expansion);
    for (String expansion : dropped) expansions.remove(expansion);
    return expansions;
}