fr.univnantes.termsuite.engines.splitter

Class CompoundUtils

java.lang.Object

fr.univnantes.termsuite.engines.splitter.CompoundUtils

public class CompoundUtils
extends java.lang.Object

A set of helper methods for compound words and for iteration over word components (see TermValueProviders).

Constructor Summary

Constructors

Constructor and Description
CompoundUtils()

Method Summary

Modifier and Type	Method and Description
static java.util.List<Component>	allSizeComponents(Word word) Returns all possible components for a compound word by combining its atomic components.
static java.util.Set<Component>	getPossibleComponentsAt(Word word, int i) Gives all possible component of a compound word at given index.
static java.util.List<Pair<Component>>	innerComponentPairs(Word word) Produces the set of all pairs of non-overlapping components for a given word.
static java.util.Set<Pair<Component>>	innerContiguousComponentPairs(Word word) WARNING: This method does not behave as innerComponentPairs(Word).
static Component	merge(Word word, int begin, int end)
static Component	merge(Word word, java.lang.Iterable<? extends Component> components) Merges n consecutive components of a compound word into a single Component object.
static java.lang.String	toClassString(java.lang.String s1, java.lang.String s2)
static java.util.Set<java.lang.String>	toIndexStrings(Pair<Component> pair)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CompoundUtils

public CompoundUtils()

Method Detail

allSizeComponents

public static java.util.List<Component> allSizeComponents(Word word)

Returns all possible components for a compound word by combining its atomic components. E.g. ab|cd|ef returns abcdef, ab, cdef, abcd, ef, cd

Parameters:

word - the compound word

Returns:

the list of all possible component lemmas

merge

public static Component merge(Word word,
                              java.lang.Iterable<? extends Component> components)

Merges n consecutive components of a compound word into a single Component object. The lemma of the returned Component is the concatenation of the 1st to n-1-th param components' substring and the last param component's lemma.

Parameters:

word - The compound word

components - The list of consecutive components of the word to merge

Returns:

The merged component

Throws:

java.lang.IllegalArgumentException - when the components param is empty

java.lang.IllegalArgumentException - when the components are not consecutive

java.lang.IllegalArgumentException - when the components offsets do not match with the word size.

merge

public static Component merge(Word word,
                              int begin,
                              int end)

Parameters:

word -

begin -

end -

Returns:

See Also:

merge(Word, Iterable)

innerComponentPairs

public static java.util.List<Pair<Component>> innerComponentPairs(Word word)

Produces the set of all pairs of non-overlapping components for a given word. E.g. ab|cd|ef returns: ab+cd, ab+ef, cd+ef, ab+cdef, abcd+ef

Parameters:

word - the compound word

Returns:

the exhaustive list of pairs.

toClassString

public static java.lang.String toClassString(java.lang.String s1,
                                             java.lang.String s2)

toIndexStrings

public static java.util.Set<java.lang.String> toIndexStrings(Pair<Component> pair)

innerContiguousComponentPairs

public static java.util.Set<Pair<Component>> innerContiguousComponentPairs(Word word)

WARNING: This method does not behave as innerComponentPairs(Word). This method enforces that returned pairs cover the input word completely and without any overlap. Example 1: with a word that is not a compound, it returns an empty list. Example 2: with a word that is a size-2 compound, it returns the only pair of lemmas possible: w = "ab|cd" returnedPairs are [["ab","cd"]] Example 3: with a word that is a size-3 compound, it returns two pairs of lemmas: w = "ab|cd|ef" returnedPairs are [["ab","cded"], ["abcd","ef"]] Example 4: with a word that is a size-n compound, it returns n-1 pairs of lemmas: w = "comp1|comp2|...|compn" returnedPairs are [ ["comp1","comp2comp3...compn"], ["comp1comp2","comp3comp4...compn"], ..., ["comp1comp2...compn-1","compn"] ]

Parameters:

word - The input compound word

getPossibleComponentsAt

public static java.util.Set<Component> getPossibleComponentsAt(Word word,
                                                               int i)

Gives all possible component of a compound word at given index. Example with word ab|cd|ef|gg word[0] can be any of: ab, abcd, or abcdef word[1] can be any of: cd, cdef, cdefgg, ef, efgg, or gg word[2] can be any of: ef, efgg, gg word[3] can only be: gg Explanation: word[0] can be: - aa if word is considered to be composed as ab|cd|ef|gg, - abcd if word is considered to be composed as abcd|ef|gg or abcd|efgg - abcdef if word is considered to be composed as abcdef|gg idem with word[1], word[2] and word[3]

Parameters:

word -

i -

Returns: