Showing papers on "Sorting published in 1989"

The de Bruijn multiprocessor network: a versatile parallel processing and sorting network for VLSI

Abstract: It is shown that the binary de Bruijn multiprocessor network (BDM) can solve a wide variety of classes of problems. The BDM admits an N-node linear array, an N-node ring, (N-1)-node complete binary trees, ((3N/4)-2)-node tree machines, and an N-node one-step shuffle-exchange network, where N (=2/sup k/, k an integer) is the total number of nodes. The de Bruijn multiprocessor networks are proved to be fault-tolerant as well as extensible. A tight lower bound of the VLSI layout area of the BDM is derived; a procedure for an area-optimal VLSI layout is also described. It is demonstrated that the BDM is more versatile than the shuffle-exchange and the cube-connected cycles. Recent work has classified sorting architectures into (1) sequential input/sequential output, (2) parallel input/sequential output, (3) parallel input/parallel output, (4) sequential input/parallel output, and (5) hybrid input/hybrid output. It is demonstrated that the de Bruijn multiprocessor networks can sort data items in all of the abovementioned categories. No other network which can sort data items in all the categories is known. >

Why Do Smaller Firms Pay Less

Abstract: This paper uses data from the National Longitudinal Survey of Young Men and the Current Population Survey for 1983 to examine the relationships among wages, firm size, and plant size. We reach three key findings. First, plant size has little independent effect on wages once we have controlled for firm size for firms with fewer than 1,000 employees. Second, we find evidence of sorting on observed and unobserved ability characteristics across firm sizes. Better educated and more stable workers are in larger firms. Third, results from a first-difference estimator indicate that about 60 percent of the wage-size effect is due to unobserved heterogeneity when all firms are considered and about 100 percent when firms with 25 or more employees are considered.

Multilingual database system including sorting data using a master universal sort order for all languages

Abstract: A multilingual database system is disclosed in which data can be searched and retrieved by a user whether or not that data is in the user's own language. The data to be stored in the database is first encoded according to a master (or universal) sort order.

Color sorting system and method

Abstract: Color sorting system and method which are particularly suitable for sorting fruits and vegetables. The objects to be sorted are scanned with a color video camera, and the signals from the camera are digitized and utilized to address a look up table. The look up table is preloaded to provide reject data at those addresses for colors to be rejected. Several techniques for loading the look up table are disclosed. Then, on an online basis, the successive images address the look up table and the reject data is analyzed to drive appropriate reject apparatus. In one embodiment, the data from the look up table is applied to a spatial filter, and objects are rejected only if they have a certain number or sequence of unacceptable colors.

Fast algorithms for running ordering and max/min calculation

Abstract: Order statistics are used in a variety of filtering techniques (e.g. median, alpha -trimmed mean, nonlinear order statistics filtering, morphological filtering). Their computation is relatively fast, because it requires only comparisons. The author presents an algorithm that requires a significantly smaller number of comparisons and is significantly faster than the traditional approach to order statistics filtering. Also proposed are filter structures for order statistics filtering that are much faster than the known sorting structures. >

Adaptive Bitonic Sorting: An Optimal Parallel Algorithm for Shared Memory Machines

Abstract: We propose a parallel algorithm, called adaptive bitonic sorting, which runs on a PRAC, a shared-memory multiprocessor where fetch and store conflicts are disallowed. On a $P$ processors PRAC, our algorithm achieves optimal performance $TP = O(N \log N)$, for any computation time $T$ in the range $\Omega (\log^{2} N) \leq T \leq O(N \log N)$. Adaptive bitonic sorting has also a small constant factor, since it performs less than $2N \log N$ comparisons, and only a handful of operations per comparison.

An O(logN) deterministic packet routing scheme

Abstract: We present a deterministic O(log N) time algorithm for the problem of routing an arbitrary permutation on an N-processor bounded-degree network with bounded buffers.Unlike all previous deterministic solutions to this problem, our routing scheme does not reduce the routing problem to sorting and does not use the Ajtai, Komlos and Szemeredi sorting network [AKS]. Consequently, the constant in the run time of our routing scheme is substantially smaller, and the network topology is significantly simpler.

Parallel sorting in two-dimensional VLSI models of computation

Abstract: The gradual refinement of a general approach to two-dimensional sorting, the shear-sort algorithm, to more sophisticated and specialized sorting algorithms on mesh-connected computers is described. The analysis of the shear-sort algorithm gives rise to a novel perspective of two-dimensional sorting, which seems to be a very powerful tool for developing efficient algorithms. The same methods can be extended for sorting in higher dimensions, for example, in the three-dimensional mesh. The concept of clean and dirty rows can be modified to clean and dirty planes (or hyperplanes for dimensions greater than three). Although only two schemes (purely recursive and iterative) are explicitly described, the reader may construct his own algorithm using similar technique and slight modifications. Designing an O(n) algorithm for sorting on a mesh becomes much simpler using the techniques developed. >

Sorting system for organizing in one pass randomly order route grouped mail in delivery order

Abstract: A one-pass sorting system for sorting mail pieces in a sequence corresponding to a mail carrier's route includes storage media for storing a database containing a delivery sequence for each address on the carrier's route. As mail pieces to be delivered by the carrier are fed into the system, each of the mail pieces are transported to an multiline optical character reader (MLOCR) which reads the address printed on the mail piece. A processor operatively connected to the MLOCR and the storage media determines the sorting sequence representative of the delivery order sequence for each of the mail pieces which are then stored in a temporary storage bin until the sorting sequence has been determined for all the mail pieces. The mail pieces are then removed from the temporary storage bin and deposited into final sorting bins in an order corresponding to a sorting scheme corresponding to the delivery sequence in the carrier's route.

Method and apparatus for sorting randomly positioned items minimizing sorting conveyor movement

Abstract: Improved methods and apparatus are provided for sorting and arranging garments in a selected order which have been sequentially placed in an unordered sequence. The garments are identified by a marking affixed to each garment, and each garment is arranged in its identified sequence on a sorting conveyor having a multiplicity of movable carriers each for receiving a garment. Identification signals are rearranged in a preselected order, and a plurality of arranged signals are assigned to each one of a corresponding plurality of pick-off mechanisms positioned along the sorting conveyor. A computer calculates bidirectional movement of the sorting conveyor to minimize conveyor movement for positioning a garment for pick-off in its proper sequence by a respective one of the pick-off mechanisms. The conveyor is driven in a bidirectional mode to properly position the garment, and a pick-off mechanism is activated to remove the garment from the sorting conveyor and position the garment on an unloading conveyor. Each conveyor pick-off apparatus includes a fluid-powered cylinder inclined downward toward the sorting conveyor, and a drive unit for closing the gripper mechanism. The method and apparatus of the present invention are particularly well suited for commercial laundry and industrial uniform rental plant industry, wherein commingled garments are arranged in a selected order for pickup or delivery to customers.

Parallel algorithms for the execution of relational database operations

Abstract: This paper presents and analyzes algorithms for parallel processing of relational database operations in a general multiprocessor framework To analyze alternative algorithms, we introduce an analysis methodology which incorporates I/O, CPU, and message costs and which can be adjusted to fit different multiprocessor architectures Algorithms are presented and analyzed for sorting, projection, and join operations While some of these algorithms have been presented and analyzed previously, we have generalized each in order to handle the case where the number of pages is significantly larger than the number of processors In addition, we present and analyze algorithms for the parallel execution of update and aggregate operations

Sorting system for organizing randomly ordered route grouped mail in delivery order sequence

Abstract: A multiple-pass sorting system for sorting mail pieces in a sequence corresponding to a mail carrier's route includes storage media for storing a database containing a delivery sequence for each address on the carrier's route. As mail pieces to be delivered by the carrier are fed into the system, each of the mail pieces are transported to an multiline optical character reader (MLOCR) which reads the address printed on the mail piece. A processor operatively connected to the MLOCR and the storage media determines the sorting sequence representative of the delivery order sequence for each of the mail pieces. The mail pieces are sorted into sorting bins based on a first pass sorting scheme. Subsequent sort passes are required until the mail pieces are in delivery order sequence.

Method for controlling the exact positioning of the items to be sorted in an automatic sorting plant

Abstract: The automatic sorting plant has a plurality of carriages (5) movable along a fixed sorting path. Each carriage (5) has a movable support belt. The sorting plant also includes loading means (6) comprising a series of rotatable loading belts arranged to form a loading path at a predetermined angle to the sorting path. An item (1) is placed on the loading means (6) and is weighed and has its shape and position determined by a series of sensors (8). The item (1) is moved along the loading path from a first imaginary target (X) to a second imaginary target (Y), the position of which is such that future movement of the item along the loading path and future movement along the sorting path of the carriage (5) intended to receive the item will ensure that the item (1) is loaded onto the centre (10) of the support belt of the carriage (5). The item (1) moves forwards from the second imaginary target (Y) at an increased speed and achieves the accurate loading onto the centre (10) of the support belt of the carriage (5).

A general sequential time-space tradeoff for finding unique elements

Abstract: An optimal O(n2) lower bound is shown for the time-space product of any R-way branching program that determines those values which occur exactly once in a list of n integers in the range [1, R] where R ≥ n. This O(n2) tradeoff also applies to the sorting problem and thus improves the previous time-space tradeoffs for sorting. Because the R-way branching program is a such a powerful model these time-space product tradeoffs also apply to all models of sequential computation that have a fair measure of space such as off-line multi-tape Turing machines and off-line log-cost RAMs.

A low communication sort algorithm for a parallel database machine

Abstract: The paper considers the prcblem of sorting a file in a distributed system. The file is originally distributed on many sites, and the result of the sort is needed at another site called the “host”. The particular environment that we resume is a backend parallel database machine, but the work is applicable to distributed database systems as well. After discussing the drawbacks of several existing algorithms, we propose a novel algorithm that exhibits complete parallelism during the sort, merge, and return-tohost phases. In addition, this algorithm decreases the amou@ of inter-processor communication compared to existing parallel sort algorithms. We describe an implementation of the algorithm, present performance measurements, and use a validated model to demonstrate its scalability. We also discuss the effect of an uneven distribution of data among the various processors.

Percentile finding algorithm for multiple sorted runs

Abstract: External sorting is frequently used b>relational database s!-stems for building indexes on tables, ordered retrieval, duplicate elimination, joins, subqueries. grouping, and aggregation; it would be quite beneficial to parallelize this function. Previous parallel external sorting algorithms found in the database literature used a sequential merge as the final stage of the parallel sort. This reduces the speedup gained through parallelism in earlier stages of sort. The solution is to merge in parallel as well. Load balanced parallel two way merges and approximately load balanced parallel multi way merges are known. Measurements reported on parallel sorting that employs one of the approximate partitioning methods indicate that even if the sort keys are randomly distributed the load imbalance due to the approximation degrades speedup due to parallelism. Sort key value skews, known to occur in database workloads, can only exacerbate this problem. We give, prove and analyze an efficient exact method which can find any percentile of an arbitrary number of sorted runs. Application of our algorithm ensures load balance during the parallel merge. By removing the effect of skews of sort key values which caused loss of speed up in previous approaches our method can improve the spcedup for parallel sorting on multiple processors. While we target our work to a parallel computer architecture of shared memory MIMD parallel processors, our results are also likely to be useful for other parallel computer architectures. 1 fntroduction The need for database MIPS per database installation is outstripping the uniprocessor MIPS supplied by computer vendors. External sorting is frequently invoked by relational database systems for building indexes on tables, ordered retrieval, duplicate elimination, joins, sub-queries, grouping, and aggregation and is known to be a time consuming operation. External sorting on multiple processors is, therefore, an important and beneficial problem to be solved for relational database svstems. For purposes of exposition and analysis we w’fl assume a shared memory shared data computer architecture. Yet, the reader may find much of our work equally applicable to loosely coupled architectures. Pew&&n to copy without fee all or part of this material is granted provided that the copies are not made OT distributed for direct commercial advantage, the VLDB copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Very Large Data Base Endowment. To copy otherwise, OT to republish, requires a fee and/or special permission from the Endowment. Proceedings of the Fifteenth International Conference on Very Large Data Bases 55901 Houston, TX 7725i1892 1.1 Background We start by examining some of the parallel sort algorithms in the database literature. Perhaps the simplest technique is to partition the sort kelrange prior to accessing the database. Selected rows from the database are assigned to different buckets, each bucket corresponding to a key range. Rows in different buckets are sorted in parallel and then the result concatenated or used for further processing. This simple technique is not practical for the following two reasons: (a) tight upper and lower bounds for the sort key range are not easily ‘determined before the rows from a database are selected, and (b) it is dficult to partition the sort key range into partitions so that about the same number of rows will have sort k.eys belonging to any one partition, load balancing 1s compromised. Bitton et. al. (BIT83j propose two external parallel sort algorithms for use in database systems that they call parallel binary merge and block bitonic sort. Both algorithms employ the binary two way merge of sorted runs. In a typical external sort for database systems, sorted runs are first created as temporary relations .on disk and then merged. If we use algorithms that rely on a two way merge the number of IiO’s. temporary relation inserts and fetches per sorted row will be of the order of lo&(A-R) where A’R is the number of initial sorted runs created. Both I/O’s and number of temporary relation interactions are expensive and they make algorithms based on a two way merge expensive, suggesting that the two algorithms are primarily useful for internal sort where there is no I/O or temporary relation interaction. Even for parallel internal sorting, Bitton’s parallel binary merge algorithm suffers from the drawback that its last phase is essentially a sequential binary merge and it is therefore impossible to finish the sort earlier than the time for one sequential pass through the entire data regardless of the number of processors. While it may not be possible to avoid examining all the data for sorting, we must avoid examining it all serialIp if we are to obtain speedup linear in the number of processors (over a reasonable range of values for the number of processors). Valduriez and Gardarin (VAL84) generalized the parallel binary merge algorithm to a k-way merge algorithm. In their algorithm p proLcssors will merge different sets of runs in parallel using a k-way merge. We then have p runs. These are merged (assuming p < k) sequentially on a single processor. A pipelined version of this algorithm has been proto-

On adaptive sorting in sequential and parallel models

Abstract: Sorting is probably the most well-studied problem in computer science In many applications the elements to be sorted are not randomly distributed, but are already nearly ordered Most existing alg

Method and apparatus for automatically monitoring the destruction of thin sheet material

Abstract: The invention relates to a method and apparatus for monitoring the destruction of thin sheet material, in particular bank notes, in an automatic sorting machine, whereby the sheet material is fed by a transport means successively sheet by sheet to a motor-driven cutting means having meshing cutter boards. The destruction process and/or its immediate result are detected by sensor means.

The external Heapsort

Abstract: Heapsort is an internal sorting method which sorts an array of n records in place in O(n log n) time. Heapsort is generally considered unsuitable for external random-access sorting. By replacing key comparisons with merge operations on pages, it is shown how to obtain an in-place external sort which requires O(m log m) page references, where m is the number of pages which the file occupies. The new sort method (called Hillsort) has several useful properties for advanced database management systems. Not only does Hillsort operate in place, i.e., no additional external storage space is required assuming that the page table can be kept in core memory, but accesses to adjacent pages in the heap require one seek only if the pages are physically contiguous. The authors define the Hillsort model of computation for external random-access sorting, develop the complete algorithm and then prove it correct. The model is next refined and a buffer management concept is introduced so as to reduce the number of merge operations and page references, and make the method competitive to a basic balanced two-way external merge. Performance characteristics are noted such as the worst-case upper bound, which can be carried over from Heapsort, and the average-case behavior, deduced from experimental findings. It is shown that the refined version of the algorithm which is on a par with the external merge sort. >

Time-efficient VLSI artwork analysis algorithms in GOALIE2

Abstract: New algorithms used in the GOALIE2 circuit extraction system are presented that are based on representing VLSI layout geometries as trapezoids. These include polygon-to-trapezoid decomposition, scanline management, and output sorting. The scanline algorithm virtually eliminates the redundant computation present in similar systems. It solves the VLSI layout analysis problem in O(n+k) expected time and O( square root n) expected space, where n is the total number of input segments and k is the total number of intersection points. The new scanline algorithm is robust in what it will maintain its performance over a wide range of layout styles. Experimental results show that the running time is O(n/sup 1.0547/), i.e. that these algorithms enable one to perform VLSI layout analysis in nearly linear time. >

Method of making up batches of small items

Abstract: The installation comprises a delivery conveyor (4) for delivering unit items in buckets (5). A station (3) injects unit items onto the delivery conveyor. A sorting conveyor (6) carries packs (8) corresponding to respective batches to be made up. The sorting conveyor is disposed relative to said delivery conveyor so as to establish at least one item transfer zone therebetween. A central control unit (10) ensure that desired coincidences occur between item-containing buckets (5) and packs (8) for receiving the items, with the control units controlling the transfer of items from the buckets to the packs. The invention is particularly applicable to making up batches of items in response to orders therefor.

Merging and sorting networks with the topology of the omega network

Abstract: A class of comparator networks obtained from the omega permutation network by replacing each switch with a comparator exchanger of arbitrary direction is considered. These networks are all isomorphic to each other, have merging capabilities, and can be used as building blocks of sorting networks in ways different from the standard merge-sort scheme. It is shown that the bitonic and balanced mergers are members of the class. These two networks were not previously known to be isomorphic. >

Apparatus for sorting conveyed articles

Abstract: Apparatus for sorting articles having a roller conveyor for moving articles through an inspection region where they are scanned by a camera. From the scans, the position of boundaries of the articles is determined so that the existence and location of the articles can be identified. Color counts, representative of the color of the articles are made from the scans and are correlated with the appropriate article identified. Load cells produce weight information which is similarly correlated with the appropriate articles. The information is fed to a processor which is arranged to track the articles through the inspection region and is arranged to route the articles differently in accordance with the color counts and/or weight information correlated therewith.

Reliable distributed sorting through the application-oriented fault tolerance paradigm

Abstract: The design and implementation of a reliable version of the distributed bitonic sorting algorithm using the application-oriented fault tolerance paradigm on a commercial multicomputer is described. Sorting assertions in general are discussed and the bitonic sort algorithm is introduced. Faulty behavior is discussed and a fault-tolerant parallel bitonic sort developed using this paradigm is presented. The error coverage and the response of the fault-tolerant algorithm to faulty behavior are presented. Both asymptotic complexity and the results of run-time experimental measurements on an Ncube multicomputer are given. The authors demonstrate that the application-oriented fault tolerance paradigm is applicable to problems of a noniterative nature. >

Automatic distribution machine

Abstract: An automatic distribution machine includes a plurality of bin modules, each bin module being adapted to dispense packages onto a conveyor belt or the like. The bin modules are removable and interchangeable, thereby facilitating replacement if one fails. A sorting operation performed by the machine is controlled by a computer, which communicates with the bin modules through a common data bus. Expansion of the sorting operation can be achieved by extending the data bus to additional bin modules.

Relational division: four algorithms and their performance

Abstract: Three known algorithms for relational division, the algebra operator used to express universal quantification (for-all conditions) and an algorithm called hash-division are outlined. By comparing the algorithms analytically and experimentally, it is shown that the algorithm provides performance competitive with or superior to that of techniques used to date, namely techniques using sorting or aggregate functions. Furthermore, the algorithm can eliminate duplicates in the divisor on the fly, ignores duplicates in the dividend, and allows two kinds of partitioning, either of which can be used to resolve hash table overflow or to efficiently implement the algorithm on a multiprocessor system. >

Control method for a sorter

Abstract: A method for controlling a sheet sorter wherein plural bins are sequentially moved to be faced to a sheet material inlet to sort the sheet materials onto the bins includes permitting sorting operation; and starting to reset the plural bins after the sheet materials are taken out of the bins.