almondtools/stringsearchalgorithms

String matching algorithms for searching a single or multiple strings in large texts

stringsearchalgorithms's Issues

Case Insensitive Matching

Yet none of the algorithms does support Case Insensitive Matching (or Char Classes).

Apache 2.0 / MIT

Can this be licensed using a permissive licence.

Wildcardmatching

Yet none of the search algorithms supports wildcard matching.

Approximate Matching

Yet none of the search algorithms supports approximate matching.

Better performance for regex implementation

Using the current regex implementation in https://github.com/almondtools/regexbench is very imperformant. It would be fine to find the reasons for this.

Matching a huge set patterns

We yet support:

• matching one pattern in text
• matching multiple pattern in text

Yet none of the algorithms have been tested for huge sets of patterns (containing thousands or millions of patterns).

Find previous

Consider supporting the very common need of searching backwards in a string.

For example, consider adding a method findPrevious() as a sibling to StringFinder.findNext().

StringFinder {

	public abstract StringMatch findNext();
	public abstract StringMatch findPrevious();

Support of regex in StringAndChars

Hello

Do you have an idea when the support of regex would be possible
I'm very interested in something similar to https://code.google.com/p/esmre/ but implemented in java

we have a lot of regex to run in tons of texts, and it's hard to parse a regex to find the relevent words to be able to identify regex that could match in a text, but generally, it could reduce a lot the number of regex to execute

Invalid LONGEST_MATCH results from SetBackwardOracleMatching

I am using SetBackwardOracleMatching with MatchOption.LONGEST_MATCH to match multiple patterns on a StringCharProvider.

For example: "Die Krankheit ist seit dem Aufkommen wirksamer Antibiotika selten geworden".

• When searching for patterns ("Antibiotik", "Antibiotika"), this configuration returns "Antibiotik", which is not the longest match that I expected.
• AhoCorasick and WuManber return correct results, but they are too slow or memory-intensive for my applications.
• When I reverse the pattern order, the result is correct – so maybe a solution requires some sort of longest-first sorting?

Please see the unit test provided at #8

More efficient Tries/DAWGs

The current trie actually is a directed acyclic word graph (DAWG), yet we have algorithms that do not depend on this:

• Set-Horspool and Wu-Manber need simple tries (can be implemented more efficiently as double array)
• Aho-Corasick needs a trie with support links (can also be implemented as double array, but needs additional structure for support links
• (Set) Backward Oracle Matching uses a factor oracle base on a DAWG, so we will need this implementation at least here

Consequently each algorithm should use the best optimized variant instead of all depending on a DAWG (which is currently labeled trie).