A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.  Home/Search   Document Details and Download   Summary   Related Articles   Check

....for the exact matching case and an O(nm log k=w) algorithm for the k mismatches problem, where w is the number of bits in a machine word, n the length of the text and m the length of the pattern. Wu and Manber in [16] showed an O(nkm=w) algorithm for the k di erences problem. Furthermore, Wright ([15]) presented an O(n log j jm=w) bit vector style algorithm where j j is the size of the alphabet for the pattern. Recently, Myers ( 10] developed a particularly practical method to compute the edit distance in O(nm=w) Related work to the computation of the length of an LCS can be found in [2] ....

A.H. Wright, Approximate string matching using within-word parallelism, Soft. Pract. Exper., 24, 337-362, (1994).

.... filter the text to quickly eliminate uninteresting parts [29, 28, 10, 14, 24] some of them being sublinear on average for moderate ff (i.e. they do not inspect all the text characters) Yet other approaches use bit parallelism [3] in a computer word of w bits to reduce the number of operations [33, 35, 34, 6, 19]. The problem of approximately searching a set of r patterns (i.e. the occurrences of anyone of them) has been considered only recently. This problem has many applications, for instance This work has been supported in part by FONDECYT grant 1990627. 1 ffl Spelling: many incorrect words can be ....

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, 1994.

....technique is shown in [5] which yields an O(n) algorithm for moderate k=m ratios. Yet other approaches use bit parallelism [2, 25] in a RAM machine of word length O(log n) to reduce the number of operations. 24] achieves O(kmn= log n) time, which is competitive for patterns of length O(logn) [22] packs the cells differently to achieve O(mn log oe= log n) time complexity. 26] uses a Four Russians approach and packs the table in machine words, achieving O(kn= log n) time on average. We present a new algorithm which combines the ideas of taking advantage of the properties of the matrix, ....

....of the q grams) as suggested in [16] Baeza Yates Perleberg [5] is essentially the heuristic j = k 1, that our hybrid algorithm uses in the appropriate case. The code is ours. Wu Manber [24] uses bit parallelism to simulate the automaton by rows. Our implementation (taken from Wright s tests [22]) is limited to m 31, and it would be slower if generalized. Wright [22] uses bit parallelism to pack the diagonals (perpendicular to ours) of the dynamic programming matrix (not the automaton) The code is from the author. Wu Manber Myers [26] applies a Four Russians technique to the dynamic ....

[Article contains additional citation context not shown here]

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

....on a sequential processor using bit operations. This takes advantage of the fact that the processor operates in all the bits of the computer word in parallel. In a RAM machine of word length w = Omega Gamma816 n) bits, this can reduce the number of real operations by a factor of O(1=w) In [31] the cells of the dynamic programming matrix are packed in diagonals to achieve O(mn log(oe) w) time complexity. In [34] a Four Russians approach is used to pack the matrix in machine words (they end up in fact with a DFA where they can trade the number of states for their internal complexity) In ....

....it is in, but also to change the strategy if the selected combination proves bad. 25 8 Experimental Comparison In this section we experimentally compare our combined heuristic against the fastest previous algorithms we are aware of. Since we compare only the fastest algorithms, we leave aside [21, 28, 11, 14, 25, 31, 33, 29, 24], which are not competitive in the range of parameters we study here. Our algorithm is shown using and not using speedup explained at the end of Section 2, since it could be applied to many other algorithms as well (but generally not to filtration algorithms) We tested random patterns against 10 ....

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

....Boyer Moore for exact matching and dynamic programming for the case with errors. We refer the reader to [GBY91, Chapter 7] for more details. For string matching problems, non comparison based algorithms include the use of matrix multiplication [FP74, Kar93] or bit wise techniques as in this paper [Abr87, Der95, Wri94, WMM95]. The approach taken here tries to use the same technique for different problems. We use a RAM machine with word size w log 2 n, for any text size n. We use the uniform cost model for a restricted set of operations including comparisons, additions, subtractions, bitwise AND and OR s, and ....

.... implementing g by hardware (still in AC 0 ) and preprocessing the valid values of pairs (j; text) in a table, the time complexity for this algorithm is O(mn log k= log n) which is O(n) for patterns of size up to O(log n= log log n) A different bitwise parallelism is considered by Wright [Wri94], which packs three diagonals of the dynamic programming matrix in one word (the diagonals perpendicular to ours) Wright s approach also has the dependency problem. In [BYN96b] we show how to represent D i using O(k) bits in the usual RAM model and evaluating the recurrence in O(1) operations, ....

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

.... and is O(mn) time [31, 30] Later, a number of algorithms improved this to O(kn) time in the worst case or even less on average, by using cleverly the properties of the dynamic programming matrix (e.g. 12, 22, 36, 9] or parallelizing the computation in the bits of computer words (e.g. [43, 41, 44]) Recently, an O(n) worst case time algorithm for short patterns based on bit parallelism was presented in [5] Another trend is that of filtration algorithms: a fast filter is run over the text quickly discarding uninteresting parts. The interesting parts are later verified with a more ....

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, Apr 1994.

....[21, 20, 19, 7, 8, 11, 5, 18] These algorithms achieve sublinear expected time in many cases (O(kn log oe m=m) is a typical figure) for moderate k=m ratios, but the filtration is not effective for larger ratios. Yet other approaches use bit parallelism [1, 27] to reduce the number of operations [24, 28]. In [28] O(kn=w) average time is achieved, where w is the number of bits in the computer word. A radically different approach to the problem is to look at it as a regular grammar matching problem. Consider the NFA (non deterministic finite automaton) for searching patt with at most k = 2 errors ....

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

....filter the text to quickly eliminate uninteresting parts [17, 16, 7, 13, 5] some of them being sublinear on average for moderate ff. Yet other approaches use bit parallelism [2] to reduce the number of operations This work has been supported in part by FONDECYT grants 1950622 and 1960881. [20, 22, 21, 4]. In [21] the search is modeled with a non deterministic finite automaton, whose execution is simulated in parallel on machine words of w bits, achieving O(kmn=w) time. In [4] we simulate the same automaton in a different way, achieving O(n) time for small patterns. This algorithm is shown to be ....

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, Apr. 1994.

....text retrieval) They may work effectively for any error level. In this thesis we have made improvements in all the four areas, especially in the last two (see Figure 3.1) We cover now each area separately. Our comments about the practical performance of the algorithms are based on [JTU96, CL92, Wri94] and in many cases on our own experiments. Based on DP matrix Worst case Average case (analysis) Automaton Bit parallelism Filters For very long patterns For moderate patterns Based on automata Based on DP matrix Figure 3.1: Taxonomy of the types of solutions for on line searching. The areas ....

....filters do not work well, and other are better [CM94, CL94, Ukk92, ST95] A major theoretical achievement of this area is the filter [CM94] which is proven to be optimal on the average. 3.1.4 Bit Parallel Algorithms [See Figure 3. 5] BY89] Birth of bit parallelism Parallelized DP matrix [Wri94] O(mn log(oe) w) time Parallelize matrix [WM92a] Bit parallel NFA O(kdm=wen) time [Mye98] Optimal parall. DP matrix O(mn=w) worst case O(kn=w) on average [ours 96 98] NFA parallelizedby diagonals O(dkm=wen) worst case O(n) and O( q mk woe n) average Parallelize automaton Figure 3.5: ....

[Article contains additional citation context not shown here]

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

....filtering technique shown in [4] which yields an O(n) algorithm for moderate ff. Yet other approaches use bit parallelism [1, 23] in a RAM machine of word length O(logn) to reduce the number of operations. 22] achieves O(kmn= log n) time, which is competitive for patterns of length O(logn) [20] packs the cells differently to achieve O(mn log oe= log n) time complexity. 24] uses a Four Russians approach and packs the table in machine words, achieving O(kn= log n) time on average. In [3] we propose a new algorithm, which combines the ideas of taking advantage of the properties of the ....

....maximal q (length of the q grams) as suggested in [14] Baeza Yates Perleberg [4] is essentially the heuristic j = k 1, that our hybrid algorithm uses for ff ff 0 . The code is ours. Wu Manber [22] uses bit parallelism to simulate the automaton by rows. The code is taken from Wright s tests [20]. It is limited to m 31, and it would be slower if generalized. Wright [20] uses bit parallelism to pack the diagonals (perpendicular to ours) of the dynamic programming matrix (not the automaton) The code is from the author. Wu Manber Myers [24] applies a Four Russians technique to the ....

[Article contains additional citation context not shown here]

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

....(e.g. O(kn log oe m=m) for small ff. However, they tend to be practical only for m not too small and low error ratios. Some exceptions are [4, 9] which are O(n) for small ff even when m is small. Those that parallelize the computation of a classical algorithm in the bits of computer words [21, 19, 22, 2, 1]. We call w the number of bits in the computer word, which is assumed to be Theta(log n) These algorithms normally obtain a factor of O(1= log n) over their classical counterparts. An exception is [2, 1] which is O(n) for small patterns regardless of ff, and O( p mk= log n n) for larger ....

.... [4] Wu Manber [21] WuManber Myers [22] Agrep [20] and Baeza Yates Navarro [2] In all cases the code is from the authors, except Ukkonen (code is ours and in fact it is used as our verification engine) Baeza Yates Perleberg (code is ours) and Wu Manber (code is from Alden Wright [19]) The codes have been used with the parameters suggested by the authors to achieve optimal behavior, and we verified that that was the case. The code for the counting filter is that of Figure 1. Figures 4 and 5 (upper part) show the results (for random and English text, respectively) Although we ....

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, Apr. 1994.

....filtering technique is shown in [5] which yields an O(n) algorithm for moderate k=m ratios. Yet other approaches use bit paralellism [2] in a RAM machine of word length O(log n) to reduce the number of operations. 21] achieves O(kmn= log n) which is competitive for patterns of length O(log n) [19] packs the cells differently to achieve O(mn log c= log n) complexity. This work has been supported in part by FONDECYT grant 1950622. We present a new algorithm which combines the ideas of taking advantage of the properties of the matrix, filtering the text and using bit parallelism, being ....

....to combine the heuristics, and to show that the resulting hybrid algorithm is faster than previous work on moderate patterns. We tested with 1 Mb of random text on a Sun SparcClassic, of approximately Specmark 26. We use w = 32 and c = 64. The tests were made based on the code developed by Wright [19] (discarding some slow algorithms [16, 9] and adding others) The algorithms are a bit faster (0.1 seconds) in practice, since the test asks them to fill an array of n answers. The algorithms included in this comparison are Ukkonen [17] is the standard dynamic programming algorithm, modified to ....

[Article contains additional citation context not shown here]

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, Apr. 1994.

....is computed in lazy form (i.e. only the states actually reached in the text are generated) Yet other approaches use bit parallelism [2, 4, 34] i.e. they simulate parallelism with bit operations in a RAM machine of word length w = Omega Gamma250 n) bits, to reduce the number of operations. In [32] the cells of the dynamic programming matrix are packed in diagonals to achieve O(mn log(oe) w) time complexity. In [35] a Four Russians approach is used to pack the matrix in machine words, achieving O(kn=w) time on average (they end up in fact with a DFA where they can trade the number of states ....

....the other hand, is due to an imperfect tuning of our heuristic for non random text. 6.4 A Comparison of the Fastest Algorithms Finally, we present a comparison between our algorithms and the fastest previous algorithms we are aware of. Since we compare only the fastest algorithms, we leave aside [22, 29, 13, 16, 26, 32], which were not competitive in the range of parameters we study here. We use our simple algorithm, as well as pure pattern and pure automaton partitioning. We do not make use of the S table speed up, since it could be applied to all other algorithms as well. The algorithms included in this ....

[Article contains additional citation context not shown here]

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

No context found.

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

No context found.

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

No context found.

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

No context found.

A. H. Wright. Approximate string matching using within-word parallelism. Softw. Pract. Exp., 24(4):337-362, 1994.

No context found.

A. Wright. Approximate string matching using within-word parallelism. Software Practice and Experience, 24(4):337--362, April 1994.

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC