Regular Expression Search Research Articles

BRUTE FORCE DETERMINIZATION OF NFAs BY MEANS OF STATE COVERS

Finite automata determinization is a critical operation for numerous practical applications such as regular expression search. Algorithms have to deal with the possible blow up of determinization. There exist solutions to control the space and time complexity like the so called "on the fly" determinization. Another solution consists in performing brute force determinization, which is robust and technically fast, although a priori its space complexity constitutes a weakness. However, one can reduce this complexity by perfoming a partial brute force determinization. This paper provides optimizations that consist in detecting classes of unreachable states and transitions of the subset automaton, which leads in average to an exponential reduction of the complexity of brute force and partial brute force determinization.

Oracle Database 10g: a platform for BLAST search and Regular Expression pattern matching in life sciences

As database management systems expand their array of analytical functionality, they become powerful research engines for biomedical data analysis and drug discovery. Databases can hold most of the data types commonly required in life sciences and consequently can be used as flexible platforms for the implementation of knowledgebases. Performing data analysis in the database simplifies data management by minimizing the movement of data from disks to memory, allowing pre-filtering and post-processing of datasets, and enabling data to remain in a secure, highly available environment. This article describes the Oracle Database 10g implementation of BLAST and Regular Expression Searches and provides case studies of their usage in bioinformatics. http://www.oracle.com/technology/software/index.html

Mutable strings in Java: design, implementation and lightweight text-search algorithms

The Java string classes, String and StringBuffer, lie at the extremes of a spectrum (immutable, reference based, and mutable, content based). Analogously, available text-search methods on string classes are implemented either as trivial, brute-force double loops, or as very sophisticated and resource-consuming regular-expression search methods. Motivated by our experience in data-intensive text applications, we propose a new string class, MutableString, which tries to get the right balance between extremes in both cases. Mutable strings can be in one of two states, compact and loose, in which they behave more like String and StringBuffer, respectively. Moreover, they support a wide range of sophisticated text-search algorithms with a very low resource usage and set-up time, using a new, very simple randomised data structure (a generalisation of Bloom filters) that stores an approximation from above of a lattice-valued function. Computing the function value requires a constant number of steps, and the error probability can be balanced with space usage. As a result, we obtain practical implementations of Boyer–Moore type algorithms that can be used with very large alphabets, such as Unicode collation elements. The techniques we develop are very general and amenable to a wide range of applications.

Compact and fast algorithms for safe regular expression search

This article describes an improvement of the brute force determinization algorithm in the case of homogeneous nondeterministic finite automata (NFAs), as well as its application to pattern matching. Brute force determinization with limited memory may provide a partially determinized automaton, but its bounded complexity makes it a safe procedure contrary to the classical subset construction. Actually, our algorithm is inspired by both recent results of Champarnaud concerning the subset automaton of a homogeneous NFA and the algorithm recently designed by Navarro and Raffinot to implement the brute force determinization of the Glushkov NFA of a regular pattern. Our algorithm significantly improves Navarro–Raffinot's one since it has an average exponentially smaller memory requirement for a given level of determinization, which, considering a bounded memory, implies a quadratically smaller parsing time. This algorithm has been implemented in CCP software (http://www.univ-rouen.fr/LIFAR/aia/ccp.html). Tests have been carried out in the field of text processing and biology. Experimental results are reported.

Fast and simple character classes and bounded gaps pattern matching, with applications to protein searching.

The problem of fast exact and approximate searching for a pattern that contains classes of characters and bounded size gaps (CBG) in a text has a wide range of applications, among which a very important one is protein pattern matching (for instance, one PROSITE protein site is associated with the CBG [RK] - x(2,3) - [DE] - x(2,3) - Y, where the brackets match any of the letters inside, and x(2,3) a gap of length between 2 and 3). Currently, the only way to search for a CBG in a text is to convert it into a full regular expression (RE). However, a RE is more sophisticated than a CBG, and searching for it with a RE pattern matching algorithm complicates the search and makes it slow. This is the reason why we design in this article two new practical CBG matching algorithms that are much simpler and faster than all the RE search techniques. The first one looks exactly once at each text character. The second one does not need to consider all the text characters, and hence it is usually faster than the first one, but in bad cases may have to read the same text character more than once. We then propose a criterion based on the form of the CBG to choose a priori the fastest between both. We also show how to search permitting a few mistakes in the occurrences. We performed many practical experiments using the PROSITE database, and all of them show that our algorithms are the fastest in virtually all cases.

How the Internet was indexed

The scope and characteristics of what may be considered the first three generations of automated Internet indexing systems are identified and described as to their methods of compiling their datasets, their search interfaces and their associated etymological metaphors and mythologies. These three are suggested to be: firstly, the archie system for single keyword and regular expression searches of the file lists of anonymous ftp sites; secondly, the veronica system for Boolean keyword in title searches of the world's gopher servers; thirdly, a range of software techniques known as robots and search engines, which compile searchable data bases of information accessible via the World Wide Web, such as the currently popular Lycos project at Carnegie Mellon University. The present dominance of World Wide Web client software as the preferred interface to Internet information has led to provision of methods of also using the first two systems by this single interface, and these are also noted.

CHUCKLES: a method for representing and searching peptide and peptoid sequences on both monomer and atomic levels.

Dual representation of peptide and non-peptide structures in a chemical database as atomic-level molecular graphs and sequence strings permits chemical substructure and similarity searches as well as sequence-based substring and regular expression searches. CHUCKLES interconverts monomer-based sequences with SMILES, which represent atomic-level molecular graphs. Forward-translation maps peptide or other sequences into SMILES. Back-translation extracts monomer sequences from SMILES. This approach permits a generalized representation of monomers allowing user specification of any monomer. CHUCKLES allows mixing of atoms with user-defined monomer names; that is, monomer representation is consistent with SMILES notation. In addition, oligomer branching and cyclization are handled.

Programming Techniques: Regular expression search algorithm

A method for locating specific character strings embedded in character text is described and an implementation of this method in the form of a compiler is discussed. The compiler accepts a regular expression as source language and produces an IBM 7094 program as object language. The object program then accepts the text to be searched as input and produces a signal every time an embedded string in the text matches the given regular expression. Examples, problems, and solutions are also presented.