Stable Merging Research Articles

An Ensemble and Multi-View Clustering Method Based on Kolmogorov Complexity

The ability to build more robust clustering from many clustering models with different solutions is relevant in scenarios with privacy-preserving constraints, where data features have a different nature or where these features are not available in a single computation unit. Additionally, with the booming number of multi-view data, but also of clustering algorithms capable of producing a wide variety of representations for the same objects, merging clustering partitions to achieve a single clustering result has become a complex problem with numerous applications. To tackle this problem, we propose a clustering fusion algorithm that takes existing clustering partitions acquired from multiple vector space models, sources, or views, and merges them into a single partition. Our merging method relies on an information theory model based on Kolmogorov complexity that was originally proposed for unsupervised multi-view learning. Our proposed algorithm features a stable merging process and shows competitive results over several real and artificial datasets in comparison with other state-of-the-art methods that have similar goals.

단순하고 스테이블한 머징알고리즘

단순하고 스테이블한 머징알고리즘의 비교횟수와 관련된 worst case 복잡도를 분석한다. 복잡도 분석을 통해 소개되는 알고리즘이 m 과 n, <TEX>$m{\leq}n$</TEX> 사이즈의 두 수열에 대해 O(mlog(n/m))의 비교횟수를 요구하는 사실을 증명한다. 그래서 병합에 있어서의 하계가 <TEX>$\Omega$</TEX>(mlog(n/m))이라는 사실로부터 우리의 알고리즘이 비교횟수와 관련해 점근적 최적 알고리즘에 해당함 을 추론가능하다. worst case 복잡도 증명을 위해 모든 입력수열로 구성된 정의구역을 두개의 서로소인 집합으로 나눈다. 그런 후 서로소인 각각의 집합으로 부터 특수한 subcase를 구별한 후 이들 subcase 각각에 대해 점근적 최적성을 증명한다. 이 증명을 바탕으로 나머지 모든 경우에 대한 최적성 또한 추론 또는 증명 가능함을 소개한다. 이로써 우리는 복잡도 분석이 까다로운 알고리즘에 대해 투명한 하나의 해를 제시한다. We investigate the worst case complexity regarding the number of comparisons for a simple and stable merging algorithm. The complexity analysis shows that the algorithm performs O(mlog(n/m)) comparisons for two sequences of sizes m and n <TEX>$m{\leq}n$</TEX>. So, according to the lower bound for merging <TEX>$\Omega$</TEX>(mlog(n/m)), the algorithm is asymptotically optimal regarding the number of comparisons. For proving the worst case complexity we divide the domain of all inputs into two disjoint cases. For either of these cases we will extract a special subcase and prove the asymptotic optimality for these two subcases. Using this knowledge for special cases we will prove the optimality for all remaining cases. By using this approach we give a transparent solution for the hardly tractable problem of delivering a clean complexity analysis for the algorithm.

328 加速度ピックアップセンサーによる衝撃回避型迅速駆動制御機構(G15-4 ロボットシステム,G15 ロボティクス・メカトロニクス)

The 2-DOF control system has an advantage to make some standard which are the traceability for the desired value and the suppression for the disturbance. For example the pneumatic motor system for the axial piston type is applied to determine the position for the desired value. In this paper the safety control system of the avoiding impact is designed and it is expected to protect the unintentional accident like a falling down on the frozen sidewalk while walking by using the wearable sensors. The simulation results is discussed by the new proposal control design which is constructed by the stable merge with the loop transfer function.

Optimizing stable in-place merging

In 2000, Geffert et al. (Theoret. Comput. Sci. 237 (2000) 159) presented an asymptotically efficient algorithm for stable merging in constant extra space. The algorithm requires at most m 1( t+1)+ m 2/2 t +o( m 1) comparisons ( t=⌊log 2( m 2/ m 1)⌋) and 5 m 2+12 m 1+o( m 1) moves, where m 1 and m 2 are the sizes of two ordered sublists to be merged, and m 1⩽ m 2. This paper optimizes the algorithm. The optimized algorithm is simpler than their algorithm, and makes at most m 1( t+1)+ m 2/2 t +o( m 1+ m 2) comparisons and 6 m 2+7 m 1+o( m 1+ m 2) moves.

In situ, Stable Merging by Way of the Perfect Shuffle

In situ, Stable Merging by Way of the Perfect Shuffle

In-place algorithms for sorting problems

An algorithm is said to operate in-place if it uses only a constant amount of extra memory for storing local variables besides the memory reserved for the input elements. In other words, the size of the extra memory does not grow as the number of input elements, &lt;i&gt;n&lt;/i&gt;, gets larger, but it is bounded by a constant. An algorithm reorders the input elements stably if the original relative order of equal elements is retained. In this thesis, we devise in-place algorithms for sorting and related problems. We measure the efficiency of the algorithms by calculating the number of element comparisons and element moves performed in the worst case in the following. The amount of index manipulation operations is closely related to these quantities, so it is omitted in our calculations. When no precise figures are needed, we denote the sum of all operations by a general expression "time". The thesis consists of five separate articles, the main contributions of which are described below. We construct algorithms for stable partitioning and stable selection which are the first linear-time algorithms being both stable and in-place concurrently. Moreover, we define problems stable unpartitioning and restoring selection and devise linear-time algorithms for these problems. The algorithm for stable un-partitioning is in-place while that for restoring selection uses O(&lt;i&gt;n&lt;/i&gt;) extra bits. By using these algorithms as subroutines we construct an adaption of Quicksort that sorts a multiset stably in &lt;i&gt;O&lt;/i&gt;(&amp;Sigma;&lt;sup&gt;&lt;i&gt;k&lt;/i&gt;&lt;/sup&gt;&lt;sub&gt;&lt;i&gt;i&lt;/i&gt; = 1&lt;/sub&gt; &lt;i&gt;m&lt;sub&gt;i&lt;/sub&gt;&lt;/i&gt; log(&lt;i&gt;n/m&lt;sub&gt;i&lt;/sub&gt;&lt;/i&gt;)) time where &lt;i&gt;m&lt;sub&gt;i&lt;/sub&gt;&lt;/i&gt; is the multiplicity of ith distinct element for &lt;i&gt;i&lt;/i&gt; = 1,.., &lt;i&gt;k&lt;/i&gt;. This is the first in-place algorithm that sorts a multiset stably in asymptotically optimal time. We present in-place algorithms for unstable and stable merging. The algorithms are asymptotically more efficient than earlier ones: the number of moves is 3(&lt;i&gt;n + m&lt;/i&gt;)+&lt;i&gt;o(m)&lt;/i&gt; for the unstable algorithm, 5&lt;i&gt;n&lt;/i&gt;+12&lt;i&gt;m&lt;/i&gt;+&lt;i&gt;o&lt;/i&gt;(&lt;i&gt;m&lt;/i&gt;) for the stable algorithm, and the number of comparisons at most &lt;i&gt;m&lt;/i&gt;(&lt;i&gt;t&lt;/i&gt; + 1) + &lt;i&gt;n&lt;/i&gt;/2&lt;sup&gt;t&lt;/sup&gt; + &lt;i&gt;o&lt;/i&gt;(&lt;i&gt;m&lt;/i&gt;) comparisons where m &amp;le; &lt;i&gt;n&lt;/i&gt; and &lt;i&gt;t&lt;/i&gt; = [log(&lt;i&gt;n/m&lt;/i&gt;)]. The previous best results were 1.125(&lt;i&gt;n + m&lt;/i&gt;) + &lt;i&gt;o&lt;/i&gt;(&lt;i&gt;n&lt;/i&gt;) comparisons and 5(&lt;i&gt;n + in&lt;/i&gt;) + &lt;i&gt;o(n)&lt;/i&gt; moves for unstable merging, and 16.5(&lt;i&gt;n + in&lt;/i&gt;) + &lt;i&gt;o(n)&lt;/i&gt; moves for stable merging. Finally, we devise two in-place algorithms for sorting. Both algorithms are adaptions of Mergesort. The first performs &lt;i&gt;n&lt;/i&gt; log&lt;sub&gt;2&lt;/sub&gt; &lt;i&gt;n&lt;/i&gt; + O(&lt;i&gt;n&lt;/i&gt;) comparisons and &amp;#949; &lt;i&gt;n&lt;/i&gt; loge &lt;i&gt;n&lt;/i&gt; + O(&lt;i&gt;n&lt;/i&gt; log log &lt;i&gt;n&lt;/i&gt;) moves for any fixed 0 &amp;lt; &amp;#949; &amp;le; 2. Our experiments show that this algorithm performs well in practice The second requires &lt;i&gt;n&lt;/i&gt; loge &lt;i&gt;n&lt;/i&gt; + O(&lt;i&gt;n&lt;/i&gt;) comparisons and fewer than O(&lt;i&gt;n&lt;/i&gt; log &lt;i&gt;n&lt;/i&gt;/log log &lt;i&gt;n&lt;/i&gt;) moves. This is the first in-place sorting algorithm that performs &lt;i&gt;o&lt;/i&gt;(&lt;i&gt;n&lt;/i&gt; log &lt;i&gt;n&lt;/i&gt;) moves in the worst case while guaranteeing O(&lt;i&gt;n&lt;/i&gt; log &lt;i&gt;n&lt;/i&gt;) comparisons.

Fast integer merging on the EREW PRAM

We investigate the complexity of merging sequences of small integers on the EREW PRAM. Our most surprising result is that two sorted sequences ofn bits each can be merged inO(log logn) time. More generally, we describe an algorithm to merge two sorted sequences ofn integers drawn from the set {0, ...,m−1} inO(log logn+log min{n, m}) time with an optimal time-processor product. No sublogarithmic-time merging algorithm for this model of computation was previously known. On the other hand, we show a lower bound of Ω(log min{n, m}) on the time needed to merge two sorted sequences of lengthn each with elements drawn from the set {0, ...,m−1}, implying that our merging algorithm is as fast as possible form=(logn)Ω(1). If we impose an additional stability condition requiring the elements of each input sequence to appear in the same order in the output sequence, the time complexity of the problem becomes Θ(logn), even form=2. Stable merging is thus harder than nonstable merging.

Optimal Stable Merging

This paper shows how to stably merge two sequences A and B of sizes m and n, m ≤ n, respectively, with O(m + n) assignments, O(mlog(n/m + 1)) comparisons and using only a constant amount of additional space. This result matches all known lower bounds and closes an open problem posed by Dudzinski and Dydek in 1981. Our algorithm is based on the unstable algorithm of Mannila and Ukkonen. All techniques we use have appeared in the literature in more complicated forms but were never combined together. They are powerful enough to make stable all the existing linear in-place unstable algorithms we are aware of. We also present a stable algorithm that requires a linear number of comparisons and assignments which we consider to be the simplest algorithm for in-place merging.

Fast Stable Merging and Sorting in Constant Extra Space

In an earlier research paper,9 we presented a novel, yet straightforward linear-time algorithm for merging two sorted lists in a fixed amount of additional space. Constant of proportionality estimates and empirical testing reveal that this procedure is reasonably competitive with merge routines free to squander unbounded additional memory, making it particularly attractive whenever space is a critical resource. In this paper, we devise a relatively simple strategy by which this efficient merge can be made stable, and extend our results in a nontrivial way to the problem of stable sorting by merging. We also derive upper bounds on our algorithms' constants of proportionality, suggesting that in some environments (most notably external file processing) their modest run-time premiums may be more than offset by the dramatic space savings achieved.

Stable duplicate-key extraction with optimal time and space bounds

We consider the problem of transforming a list L of records sorted on some key into two sublists L1 and L2 where, for each distinct key in L, L1 contains the first record of L that possesses the key and L2 contains all records of L with duplicate keys. We desire that our duplicate-key extraction algorithm perform the transformation in place and be stable (that is, records within each sublist must obey the original order given by L). This operation is useful in database and related file processing environments whenever only distinct keys need be considered. Moreover, stability in extraction insures that L can be efficiently restored at a later time with a stable merge of L1 and L2. Any procedure for performing duplicate-key extraction on a list of size n must require at least O(n) time and O(1) extra space, although the obvious algorithm for achieving either bound alone violates the other bound. We design a stable algorithm, using block-rearrangement techniques, and show that it is optimal in the theoretical sense that it achieves both lower bounds simultaneously. We also prove that its worst-case number of key comparisons and record exchanges sum to no more than 6 n, suggesting that the algorithm has practical application as well.

Merging by Decomposition Revisited

This paper presents some modifications of stable merging by decomposition (referred to as DM here). The changes made reduce the time requirements considerably. Furthermore, a O(1)-space version of merging is described. The modifications of DM resemble improvements to the original Quicksort method for sorting, since both the algorithms are of the same generic scheme.

Simplified stable merging tasks

Simplified stable merging tasks

Stable Linear Time Sublinear Space Merging

A new method for stable merging of two segments A(1..m), A(m+1..n) into A(1..n) in O(n) time is presented. There are no restrictions on n or m and the algorithm requires O(n1/2) workspace. The corresponding procedure is given in Pascal together with results of time measurements on samples of random integers.

Splitmerge—A fast stable merging algorithm

An algorithm that merges two ordered lists of sizes n and m into one in a stable way is presented. It requires O(m log n) binary digits as extra space, besides the space needed to store the n+m records in the lists. The number of assignments is O(n+m), and the number of comparisons between records is O(m log(n/m + 1)), which is less than O(m+n)when m is much smaller than n. Both worst-case and average-case behaviour are analysed and compared with other merging algorithms.

Stable Sorting and Merging with Optimal Space and Time Bounds

This work introduces two algorithms for stable merging and stable sorting of files. The algorithms have optimal worst case time bounds, the merge is linear and the sort is of order $n \log n$. Extra storage requirements are also optimal, since both algorithms make use of a fixed number of pointers. Files are handled only by means of the primitives exchange and comparison of records and basic pointer transformations.