Showing papers on "Binary heap published in 2018"

Stereo Vision-Based Optimal Path Planning with Stochastic Maps for Mobile Robot Navigation

Abstract: This paper addresses the problem of stereo vision-based environment mapping and optimal path planning for an autonomous mobile robot by using the methodology of getting 3D point cloud from disparity images, its transformation to 2D stochastic navigation map with occupancy grid cell values assigned from the set {obstacle, unoccupied, occupied}. We re-examined and extended this methodology with a combination of A-Star with binary heap algorithms for obstacle avoidance and indoor navigation of the Innopolis autonomous mobile robot with ZED stereo camera.

Method of mechanical arm three-dimensional obstacle avoidance path planning with artificial potential field based on optimization A *

Abstract: The invention relates to a method of a mechanical arm three-dimensional obstacle avoidance path planning with an artificial potential field based on the optimization A *. The method comprises the following steps that a three-dimensional obstacle avoidance environment and mechanical arm initialization are established; the A * is used for preventing the artificial potential field method from sinkinginto a local minimum value, and the efficiency of the A * searches a minimum estimation cost is improved through a minimum binary heap sorting to plan the mechanical arm three-dimensional obstacle avoidance path; and kinematic inversion is conducted on the planned path, and each joint angle of the mechanical arm are obtained, so that a mechanical arm tail end path avoiding obstacles is planned. According to the invention, the minimum binary heap sorting method is used for conducting minimum binary heap sorting on an OPEN table in an path searching algorithm of the artificial potential field method of the A *, so that a node with a minimum estimated cost can be searched out more quickly, and therefore the obstacle avoidance path with the minimum estimation cost can be quickly found, and the efficiency of the algorithm is improved; and a least square method is used for performing smooth processing on the obstacle avoidance path, the obstacle avoidance path is enabled to be smooth and the motion jitter of the mechanical arm is avoided.

On Design and Applications of Practical Concurrent Data Structures

Abstract: The proliferation of multicore processors is having an enormous impact on software design and development. In order to exploit parallelism available in multicores, there is a need to design and implement abstractions that programmers can use for general purpose applications development. A common abstraction for coordinated access to memory is a concurrent data structure. Concurrent data structures are challenging to design and implement as they are required to be correct, scalable, and practical under various application constraints. In this thesis, we contribute to the design of efficient concurrent data structures, propose new design techniques and improvements to existing implementations. Additionally, we explore the utilization of concurrent data structures in demanding application contexts such as data stream processing. In the first part of the thesis, we focus on data structures that are difficult to parallelize due to inherent sequential bottlenecks. We present a lock-free vector design that efficiently addresses synchronization bottlenecks by utilizing the combining technique. Typical combining techniques are blocking. Our design introduces combining without sacrificing non-blocking progress guarantees. We extend the vector to present a concurrent lock-free unbounded binary heap that implements a priority queue with mutable priorities. In the second part of the thesis, we shift our focus to concurrent search data structures. In order to offer strong progress guarantee, typical implementations of non-blocking search data structures employ a "helping" mechanism. However, helping may result in performance degradation. We propose help-optimality, which expresses optimization in amortized step complexity of concurrent operations. To describe the concept, we revisit the lock-free designs of a linked-list and a binary search tree and present improved algorithms. We design the algorithms without using any language/platform specific constructs; we do not use bit-stealing or runtime type introspection of objects. Thus, our algorithms are portable. We further delve into multi-dimensional data and similarity search. We present the first lock-free multi-dimensional data structure and linearizable nearest neighbor search algorithm. Our algorithm for nearest neighbor search is generic and can be adapted to other data structures. In the last part of the thesis, we explore the utilization of concurrent data structures for deterministic stream processing. We propose solutions to two challenges prevalent in data stream processing: (1) efficient processing on cloud as well as edge devices and (2) deterministic data-parallel processing at high-throughput and low-latency. As a first step, we present a methodology for customization of streaming aggregation on low-power multicore embedded platforms. Then we introduce Viper, a communication module that can be integrated into stream processing engines for the coordination of threads analyzing data in parallel.

Fp-growth algorithm based incremental association rule mining algorithm for big data

Abstract: Discovering associations among huge collection of transactions is beneficial to rectify and to take appropriate decision made by decision makers. Discovering frequent itemsets is the key process in association rule mining. Since association rule mining process generates large number of rules which makes the algorithm inefficient is the biggest challenge for any and makes it difficult for the end users to comprehend the generated rules. The better idea is to use iterative technique to discover association rules. To overcome this problem, incremental updating of frequent itemsets is proposed in this paper. Proposed incremental data mining algorithm is based on FP-Growth and uses the concept of heap tree to address the issue of incremental updating of frequent itemsets. The proposed uses good tricks of FP-Growth, and significantly reduces the complexity. The experimental results show that the proposed algorithm reduces the execution time substantially and outperforms other algorithms.

List Heaps.

Abstract: This paper presents a simple extension of the binary heap, the List Heap. We use List Heaps to demonstrate the idea of adaptive heaps: heaps whose performance is a function of both the size of the problem instance and the disorder of the problem instance. We focus on the presortedness of the input sequence as a measure of disorder for the problem instance. A number of practical applications that rely on heaps deal with input that is not random. Even random input contains presorted subsequences. Devising heaps that exploit this structure may provide a means for improving practical performance. We present some basic empirical tests to support this claim. Additionally, adaptive heaps may provide an interesting direction for theoretical investigation.

Concurrent Lock-Free Unbounded Priority Queue with Mutable Priorities

Abstract: The priority queue with DeleteMin and Insert operations is a classical interface for ordering items associated with priorities. Some important algorithms, such as Dijkstra’s single-source-shortest-path, Adaptive Huffman Trees, etc. also require changing the priorities of items in the runtime. Existing lock-free priority queues do not directly support the dynamic mutation of the priorities. This paper presents the first concurrent lock-free unbounded binary heap that implements a priority queue with mutable priorities. The operations are provably linearizable. We also designed an optimized version of the algorithm by combining the concurrent operations that substantially improves the performance. For experimental evaluation, we implemented the algorithm in both C/C++ and Java. A number of micro-benchmarks show that our algorithm performs well in comparison to existing implementations.