edu.stanford.nlp.ling.tokensregex.matcher

Class TrieMapMatcher<K,V>

java.lang.Object

edu.stanford.nlp.ling.tokensregex.matcher.TrieMapMatcher<K,V>

public class TrieMapMatcher<K,V>
extends Object

The TrieMapMatcher provides functions to match against a trie. It can be used to: - Find matches in a document (findAllMatches and findNonOverlapping) - Find approximate matches in a document (findClosestMatches) - Segment a sequence based on entries in the trie (segment) TODO: Have TrieMapMatcher implement a matcher interface

Author:

Angel Chang

Field Summary

Fields

Modifier and Type	Field and Description
static Comparator<Match>	MATCH_LENGTH_ENDPOINTS_COMPARATOR
static Function<Match,Double>	MATCH_LENGTH_SCORER

Constructor Summary

Constructors

Constructor and Description
TrieMapMatcher(TrieMap<K,V> root)
TrieMapMatcher(TrieMap<K,V> root, List<K> multimatchDelimiter)

Method Summary

Methods

Modifier and Type	Method and Description
static <K,V> MatchCostFunction<K,V>	defaultCost()
List<Match<K,V>>	findAllMatches(K... list) Given a sequence to search through (e.g.
List<Match<K,V>>	findAllMatches(List<K> list) Given a sequence to search through (e.g.
List<Match<K,V>>	findAllMatches(List<K> list, int start, int end) Given a sequence to search through (e.g.
List<ApproxMatch<K,V>>	findClosestMatches(K[] target, int n) Given a target sequence, returns the n closes matches (or sequences of matches) from the trie.
List<ApproxMatch<K,V>>	findClosestMatches(K[] target, int n, boolean multimatch, boolean keepAlignments) Given a target sequence, returns the n closes matches (or sequences of matches) from the trie.
List<ApproxMatch<K,V>>	findClosestMatches(K[] target, MatchCostFunction<K,V> costFunction, Double maxCost, int n, boolean multimatch, boolean keepAlignments) Given a target sequence, returns the n closes matches (or sequences of matches) from the trie based on the cost function (lower cost mean better match).
List<ApproxMatch<K,V>>	findClosestMatches(List<K> target, int n) Given a target sequence, returns the n closes matches (or sequences of matches) from the trie.
List<ApproxMatch<K,V>>	findClosestMatches(List<K> target, int n, boolean multimatch, boolean keepAlignments) Given a target sequence, returns the n closes matches (or sequences of matches) from the trie.
List<ApproxMatch<K,V>>	findClosestMatches(List<K> target, MatchCostFunction<K,V> costFunction, double maxCost, int n, boolean multimatch, boolean keepAlignments) Given a target sequence, returns the n closes matches (or sequences of matches) from the trie based on the cost function (lower cost mean better match).
List<Match<K,V>>	findNonOverlapping(K... list) Given a sequence to search through (e.g.
List<Match<K,V>>	findNonOverlapping(List<K> list) Given a sequence to search through (e.g.
List<Match<K,V>>	findNonOverlapping(List<K> list, int start, int end) Given a sequence to search through (e.g.
List<Match<K,V>>	findNonOverlapping(List<K> list, int start, int end, Comparator<? super Match<K,V>> compareFunc) Given a sequence to search through (e.g.
List<Match<K,V>>	findNonOverlapping(List<K> list, int start, int end, Function<? super Match<K,V>,Double> scoreFunc) Given a sequence to search through (e.g.
List<Match<K,V>>	getNonOverlapping(List<Match<K,V>> allMatches) Given a list of matches, returns all non-overlapping matches.
List<Match<K,V>>	getNonOverlapping(List<Match<K,V>> allMatches, Comparator<? super Match<K,V>> compareFunc) Given a list of matches, returns all non-overlapping matches.
List<Match<K,V>>	getNonOverlapping(List<Match<K,V>> allMatches, Function<? super Match<K,V>,Double> scoreFunc)
static <K,V> Comparator<edu.stanford.nlp.ling.tokensregex.matcher.TrieMapMatcher.PartialApproxMatch<K,V>>	partialMatchComparator()
List<Match<K,V>>	segment(K... list) Segment a sequence into sequence of sub-sequences by attempting to find the longest non-overlapping sub-sequences.
List<Match<K,V>>	segment(List<K> list) Segment a sequence into sequence of sub-sequences by attempting to find the longest non-overlapping sub-sequences.
List<Match<K,V>>	segment(List<K> list, Function<? super Match<K,V>,Double> scoreFunc)
List<Match<K,V>>	segment(List<K> list, int start, int end) Segment a sequence into sequence of sub-sequences by attempting to find the longest non-overlapping sub-sequences.
List<Match<K,V>>	segment(List<K> list, int start, int end, Comparator<? super Match<K,V>> compareFunc) Segment a sequence into sequence of sub-sequences by attempting to find the non-overlapping sub-sequences that comes earlier using the compareFunc.
List<Match<K,V>>	segment(List<K> list, int start, int end, Function<? super Match<K,V>,Double> scoreFunc) Segment a sequence into sequence of sub-sequences by attempting to maximize the total score Non-matched parts will be included as a match with a null value.
protected void	updateAllMatches(TrieMap<K,V> trie, List<Match<K,V>> matches, List<K> matched, List<K> list, int start, int end)
protected void	updateAllMatchesWithStart(TrieMap<K,V> trie, List<Match<K,V>> matches, List<K> matched, List<K> list, int start, int end)

Methods inherited from class java.lang.Object

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

Field Detail

MATCH_LENGTH_ENDPOINTS_COMPARATOR

public static final Comparator<Match> MATCH_LENGTH_ENDPOINTS_COMPARATOR

MATCH_LENGTH_SCORER

public static final Function<Match,Double> MATCH_LENGTH_SCORER

Constructor Detail

TrieMapMatcher

public TrieMapMatcher(TrieMap<K,V> root)

TrieMapMatcher

public TrieMapMatcher(TrieMap<K,V> root,
              List<K> multimatchDelimiter)

Method Detail

findClosestMatches

public List<ApproxMatch<K,V>> findClosestMatches(K[] target,
                                        int n)

Given a target sequence, returns the n closes matches (or sequences of matches) from the trie. The cost function used is a exact match cost function (exact match has cost 0, otherwise, cost is 1)

Parameters:

target - Target sequence to match

n - Number of matches to return. The actual number of matches may be less.

Returns:

List of approximate matches

findClosestMatches

public List<ApproxMatch<K,V>> findClosestMatches(K[] target,
                                        int n,
                                        boolean multimatch,
                                        boolean keepAlignments)

Given a target sequence, returns the n closes matches (or sequences of matches) from the trie. The cost function used is a exact match cost function (exact match has cost 0, otherwise, cost is 1)

Parameters:

target - Target sequence to match

n - Number of matches to return. The actual number of matches may be less.

multimatch - If true, attempt to return matches with sequences of elements from the trie. Otherwise, only each match will contain one element from the trie.

keepAlignments - If true, alignment information is returned

Returns:

List of approximate matches

findClosestMatches

public List<ApproxMatch<K,V>> findClosestMatches(K[] target,
                                        MatchCostFunction<K,V> costFunction,
                                        Double maxCost,
                                        int n,
                                        boolean multimatch,
                                        boolean keepAlignments)

Given a target sequence, returns the n closes matches (or sequences of matches) from the trie based on the cost function (lower cost mean better match).

Parameters:

target - Target sequence to match

costFunction - Cost function to use

maxCost - Matches with a cost higher than this are discarded

n - Number of matches to return. The actual number of matches may be less.

multimatch - If true, attempt to return matches with sequences of elements from the trie. Otherwise, only each match will contain one element from the trie.

keepAlignments - If true, alignment information is returned

Returns:

List of approximate matches

findClosestMatches

public List<ApproxMatch<K,V>> findClosestMatches(List<K> target,
                                        int n)

Given a target sequence, returns the n closes matches (or sequences of matches) from the trie. The cost function used is a exact match cost function (exact match has cost 0, otherwise, cost is 1)

Parameters:

target - Target sequence to match

n - Number of matches to return. The actual number of matches may be less.

Returns:

List of approximate matches

findClosestMatches

public List<ApproxMatch<K,V>> findClosestMatches(List<K> target,
                                        int n,
                                        boolean multimatch,
                                        boolean keepAlignments)

Given a target sequence, returns the n closes matches (or sequences of matches) from the trie. The cost function used is a exact match cost function (exact match has cost 0, otherwise, cost is 1)

Parameters:

target - Target sequence to match

n - Number of matches to return. The actual number of matches may be less.

multimatch - If true, attempt to return matches with sequences of elements from the trie. Otherwise, only each match will contain one element from the trie.

keepAlignments - If true, alignment information is returned

Returns:

List of approximate matches

findClosestMatches

public List<ApproxMatch<K,V>> findClosestMatches(List<K> target,
                                        MatchCostFunction<K,V> costFunction,
                                        double maxCost,
                                        int n,
                                        boolean multimatch,
                                        boolean keepAlignments)

Given a target sequence, returns the n closes matches (or sequences of matches) from the trie based on the cost function (lower cost mean better match).

Parameters:

target - Target sequence to match

costFunction - Cost function to use

maxCost - Matches with a cost higher than this are discarded

n - Number of matches to return. The actual number of matches may be less.

multimatch - If true, attempt to return matches with sequences of elements from the trie. Otherwise, only each match will contain one element from the trie.

keepAlignments - If true, alignment information is returned

Returns:

List of approximate matches

findAllMatches

public List<Match<K,V>> findAllMatches(K... list)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all matching sub-sequences that matches entries in the trie

Parameters:

list - Sequence to search through

Returns:

List of matches

findAllMatches

public List<Match<K,V>> findAllMatches(List<K> list)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all matching sub-sequences that matches entries in the trie

Parameters:

list - Sequence to search through

Returns:

List of matches

findAllMatches

public List<Match<K,V>> findAllMatches(List<K> list,
                              int start,
                              int end)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all matching sub-sequences that matches entries in the trie

Parameters:

list - Sequence to search through

start - start index to start search at

end - end index (exclusive) to end search at

Returns:

List of matches

findNonOverlapping

public List<Match<K,V>> findNonOverlapping(K... list)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all non-overlapping matching sub-sequences that matches entries in the trie. Sub-sequences that are longer are preferred, then sub-sequences that starts earlier.

Parameters:

list - Sequence to search through

Returns:

List of matches sorted by start position

findNonOverlapping

public List<Match<K,V>> findNonOverlapping(List<K> list)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all non-overlapping matching sub-sequences that matches entries in the trie. Sub-sequences that are longer are preferred, then sub-sequences that starts earlier.

Parameters:

list - Sequence to search through

Returns:

List of matches sorted by start position

findNonOverlapping

public List<Match<K,V>> findNonOverlapping(List<K> list,
                                  int start,
                                  int end)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all non-overlapping matching sub-sequences that matches entries in the trie. Sub-sequences that are longer are preferred, then sub-sequences that starts earlier.

Parameters:

list - Sequence to search through

start - start index to start search at

end - end index (exclusive) to end search at

Returns:

List of matches sorted by start position

findNonOverlapping

public List<Match<K,V>> findNonOverlapping(List<K> list,
                                  int start,
                                  int end,
                                  Comparator<? super Match<K,V>> compareFunc)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all non-overlapping matching sub-sequences that matches entries in the trie.

Parameters:

list - Sequence to search through

start - start index to start search at

end - end index (exclusive) to end search at

compareFunc - Comparison function to use for evaluating which overlapping sub-sequence to keep. Earlier sub-sequences based on the comparison function are favored.

Returns:

List of matches sorted by start position

findNonOverlapping

public List<Match<K,V>> findNonOverlapping(List<K> list,
                                  int start,
                                  int end,
                                  Function<? super Match<K,V>,Double> scoreFunc)

Given a sequence to search through (e.g. piece of text would be a sequence of words), finds all non-overlapping matching sub-sequences that matches entries in the trie while attempting to maximize the scoreFunc.

Parameters:

list - Sequence to search through

start - start index to start search at

end - end index (exclusive) to end search at

scoreFunc - Scoring function indicating how good the match is

Returns:

List of matches sorted by start position

segment

public List<Match<K,V>> segment(K... list)

Segment a sequence into sequence of sub-sequences by attempting to find the longest non-overlapping sub-sequences. Non-matched parts will be included as a match with a null value.

Parameters:

list - Sequence to search through

Returns:

List of segments (as matches) sorted by start position

segment

public List<Match<K,V>> segment(List<K> list)

Segment a sequence into sequence of sub-sequences by attempting to find the longest non-overlapping sub-sequences. Non-matched parts will be included as a match with a null value.

Parameters:

list - Sequence to search through

Returns:

List of segments (as matches) sorted by start position

segment

public List<Match<K,V>> segment(List<K> list,
                       int start,
                       int end)

Segment a sequence into sequence of sub-sequences by attempting to find the longest non-overlapping sub-sequences. Non-matched parts will be included as a match with a null value.

Parameters:

list - Sequence to search through

start - start index to start search at

end - end index (exclusive) to end search at

Returns:

List of segments (as matches) sorted by start position

segment

public List<Match<K,V>> segment(List<K> list,
                       int start,
                       int end,
                       Comparator<? super Match<K,V>> compareFunc)

Segment a sequence into sequence of sub-sequences by attempting to find the non-overlapping sub-sequences that comes earlier using the compareFunc. Non-matched parts will be included as a match with a null value.

Parameters:

list - Sequence to search through

start - start index to start search at

end - end index (exclusive) to end search at

compareFunc - Comparison function to use for evaluating which overlapping sub-sequence to keep. Earlier sub-sequences based on the comparison function are favored.

Returns:

List of segments (as matches) sorted by start position

segment

public List<Match<K,V>> segment(List<K> list,
                       int start,
                       int end,
                       Function<? super Match<K,V>,Double> scoreFunc)

Segment a sequence into sequence of sub-sequences by attempting to maximize the total score Non-matched parts will be included as a match with a null value.

Parameters:

list - Sequence to search through

start - start index to start search at

end - end index (exclusive) to end search at

scoreFunc - Scoring function indicating how good the match is

Returns:

List of segments (as matches) sorted by start position

segment

public List<Match<K,V>> segment(List<K> list,
                       Function<? super Match<K,V>,Double> scoreFunc)

getNonOverlapping

public List<Match<K,V>> getNonOverlapping(List<Match<K,V>> allMatches)

Given a list of matches, returns all non-overlapping matches. Matches that are longer are preferred, then matches that starts earlier.

Parameters:

allMatches - List of matches

Returns:

List of matches sorted by start position

getNonOverlapping

public List<Match<K,V>> getNonOverlapping(List<Match<K,V>> allMatches,
                                 Comparator<? super Match<K,V>> compareFunc)

Given a list of matches, returns all non-overlapping matches.

Parameters:

allMatches - List of matches

compareFunc - Comparison function to use for evaluating which overlapping sub-sequence to keep. Earlier sub-sequences based on the comparison function are favored.

Returns:

List of matches sorted by start position

getNonOverlapping

public List<Match<K,V>> getNonOverlapping(List<Match<K,V>> allMatches,
                                 Function<? super Match<K,V>,Double> scoreFunc)

updateAllMatches

protected void updateAllMatches(TrieMap<K,V> trie,
                    List<Match<K,V>> matches,
                    List<K> matched,
                    List<K> list,
                    int start,
                    int end)

updateAllMatchesWithStart

protected void updateAllMatchesWithStart(TrieMap<K,V> trie,
                             List<Match<K,V>> matches,
                             List<K> matched,
                             List<K> list,
                             int start,
                             int end)

defaultCost

public static <K,V> MatchCostFunction<K,V> defaultCost()

partialMatchComparator

public static <K,V> Comparator<edu.stanford.nlp.ling.tokensregex.matcher.TrieMapMatcher.PartialApproxMatch<K,V>> partialMatchComparator()