Measuring Cache Complexity Using Data Movement Distance (DMD)

This paper focuses on Dynamic Implementation using Array and Linked list. In the data structure concept, the list plays a major role in the allocation of data where it is a general overview of creating a node in a linked list using an array with the initialization of size. The node contains data and is interconnected to the next node in the sequence via their links which perform the search operation where the space and time complexity are not wasted in these analyses. Linked lists are a great way to store a theoretically infinite amount of data with a small and versatile amount of code. The amount of data stored increases linearly with the number of nodes in the list (space-o(n)) where linked lists are more efficient than arrays. It is observed that considering the time complexity when there is a variation in data set linked array is almost reaches close to array whenever dataset is high also linked array has better time complexity than linked list when the searching element is in middle and last. Considering the space complexity linked array is almost 2 times and 4 times less space is needed than array and linked list respectively.

The Dual Complexity Space as the Dual of a Normed Cone

Data in the network is not secure and can be accessed by unauthenticated and unauthorized users. So to make data secure in the network, various encryption algorithms are used. Security along with confidentiality of the data is to be maintained in the network. Encryption is the technique by which data is encoded and sent to the receiver, where it gets decoded back to the plaintext. Encryption algorithm or technique should take minimum time and space for the execution. There are various encryption algorithms which are frequently used and some of them are high in measure of time and space complexity. This paper presents a more Secure and Time Efficient Encryption Method (STEEM) which is concentrating on high security of the encrypted text along with the time efficiency. This paper shows the working flows of the proposed work which would be solely responsible for achieving more efficiency on prime parameters.

Binary embedding refers to methods for embedding points in $\mathbb {R}^{d}$ into vertices in the Hamming cube of dimension ${\mathcal{O}}(d)$ , such that the normalized Hamming distance between the codes preserves a prespecified distance between vectors in the original space. A common approach to binary embedding is to use random projection , followed by one-bit quantization to produce binary codes. Of particular interest, in this letter, is sparse circulant binary embedding (SCBE), where a sparse random circulant matrix with random sampling at a rate of $1-s$ for $s\in (0, 1)$ is used for random projection. The SCBE has the space complexity ${\mathcal{O}}((1-s)d)$ , while unstructured random projection has the space complexity ${\mathcal{O}}(d^2)$ . We present an asymptotic analysis of SCBE, when $d$ approaches $\infty$ , showing that the performance of SCBE is comparable to that of binary embedding with unstructured random projection whilethe former has the space complexity ${\mathcal{O}}((1-s)d)$ and the time complexity ${\mathcal{O}}(d\log d)$ but the latter has both space and time complexities ${\mathcal{O}}(d^2)$ .

We initiate the systematic study of the energy complexity of algorithms (in addition to time and space complexity) based on Landauer's Principle in physics, which gives a lower bound on the amount of energy a system must dissipate if it destroys information. We propose energy-aware variations of three standard models of computation: circuit RAM, word RAM, and transdichotomous RAM. On top of these models, we build familiar high-level primitives such as control logic, memory allocation, and garbage collection with zero energy complexity and only constant-factor overheads in space and time complexity, enabling simple expression of energy-efficient algorithms. We analyze several classic algorithms in our models and develop low-energy variations: comparison sort, insertion sort, counting sort, breadth-first search, Bellman-Ford, Floyd-Warshall, matrix all-pairs shortest paths, AVL trees, binary heaps, and dynamic arrays. We explore the time/space/energy trade-off and develop several general techniques for analyzing algorithms and reducing their energy complexity. These results lay a theoretical foundation for a new field of semi-reversible computing and provide a new framework for the investigation of algorithms.

This paper introduces a new heuristic function with high efficiency for an optimum solving of the 8 - puzzle, this one being the double of the Chebyshev distance. The comparative study is realized among this new heuristic (Chebyshev heuristic), the Hamming h euristic and the Manhattan heuristic using A* algorithm implemented in Java. The Chebyshev heuristic function is more informed than Hamming and Manhattan heuristics. This paper also presents the necessary stages in object oriented development of an interactive software dedicated to simulate the A* search algorithm for 8 -puzzle. The modeling of the software is achieved through specific UML diagrams representing the phases of analysis, design and implementation, the system thus being described in a clear and practical manner. In order to confirm the obtained theoretical results which show that Chebyshev heuristic is more efficient, two performance criteria were used: space complexity and time complexity. The space complexity was measured by the number of generated nodes from the search tree, by the number of the expanded nodes and by the effective branching factor. The time complexity was measured by the running time. From the experimental results obtained by using the Chebyshev heuristic, improvements were obs erved regarding space and time complexity of A* algorithm versus Hamming and Manhattan heuristics.

WITHDRAWN: Spearman rank correlation based bagging ensemble bayes optimal classification for genomic predictive pattern analytics

This paper presents a multicore-cache model that reflects the reality that multicore processors have both per-processor private (L1) caches and a large shared (L2) cache on chip. We consider a broad class of parallel divide-and-conquer algorithms and present a new on-line scheduler, CONTROLLED-PDF, that is competitive with the standard sequential scheduler in the following sense. Given any dynamically unfolding computation DAG from this class of algorithms, the cache complexity on the multicore-cache model under our new scheduler is within a constant factor of the sequential cache complexity for both L1 and L2, while the time complexity is within a constant factor of the sequential time complexity divided by the number of processors p. These are the first such asymptotically-optimal results for any multicore model. Finally, we show that a separator-based algorithm for sparse-matrix-dense-vector-multiply achieves provably good cache performance in the multicore-cache model, as well as in the well-studied sequential cache-oblivious model.

A faster FPTAS for knapsack problem with cardinality constraint

The classic buffer insertion algorithm of van Ginneken has time and space complexity O(n/sup 2/), where n is the number of possible buffer positions. For more than a decade, van Ginneken's algorithm has been the foundation of buffer insertion. In this paper, we present a new algorithm that computes the same optimal buffer insertion, but runs much faster. For 2-pin nets, our time complexity is O(nlogn) and space complexity is O(n). For multipin nets, our time complexity is O(nlog/sup 2/n) and space complexity is O(nlogn). The speedup is achieved by four novel techniques: predictive pruning, candidate tree, fast redundancy check, and fast merging. On industrial test cases, the new algorithms is 2-80 times faster than van Ginneken's algorithm and uses 1/4-1/500 of the memory. Since van Ginneken's algorithm and its variations are used by most existing algorithms on buffer insertion and buffer sizing, our new algorithm significantly improves the performance of all these algorithms. The predictive pruning technique has been applied to buffer cost minimization (Shi et al., 2004), and significantly improved the running time.

최근 세계적으로 에너지 부족 문제를 해결하기 위해 에너지저장시스템에 관한 연구가 활발히 이루어지고 있다. 에너지저장시스템은 에너지 네트워크상의 모든 에너지 인프라에 대한 모니터링 및 제어를 통해 ESS(Energy Storage System) 에너지 사용을 극대화할 수 있다. 하지만 에너지저장시스템의 주요 부품이나 장치들 간의 호환 문제는 ESS 제품 개발에 걸림돌로 작용하고 있다. 이를 해결하기 위해 ESS 부품 및 장치들의 특성을 확장 할 수 있는 프로파일과 이를 검증할 수 있는 소프트웨어 기술이 요구되어지고 있다. 본 논문에서는 에너지저장장치용 확장성 프로파일 검증 소프트웨어의 구조에 따른 복잡도 분석에 관한 연구를 수행한다. 프로파일 검증 소프트웨어 분석을 위해 기존의 XML(eXtensible Markup Language) 기반의 프로파일과 C언어 구조체 기반의 프로파일을 사용한다. XML 기반의 프로파일을 여러번 파싱하는 복잡한 검증 구조와 파싱 절차를 감소하고 단순 반복을 이용한 C언어 구조체 기반의 검증 소프트웨어의 복잡도를 분석하고 비교한다. 시간 복잡도, 공간 복잡도 및 순환 복잡도 알고리즘을 이용하여 XML 기반의 프로파일과 C언어 구조체 기반의 프로파일 검증 소프트웨어의 복잡도를 비교 및 분석하여 연구 결과를 제시한다. Recently, a study has been progressed about the energy storage system for resolving energy shortage problems in the world. The energy storage system can maximize energy storage system's energy usage by monitoring and controlling about all energy infrastructures on energy network. However, compatibility problems among main components or devices of the energy storage system are obstacles to development of energy storage system products. An extensible profile and extensible profile verification software being able to verify the extensible profile have been required in order to resolve compatibility problems. In this paper, the study on complexity analysis for the extensible profile verification software for the energy storage system is performed. A XML based profile and C language structure based profile are used for analysis of the profile verification software. The complexity of complex verification structure that parses the XML based profile several times and simple verification structure that parses the C language structure based profile are analyzed and compared. Time complexity, space complexity, and cyclomatic complexity are used for complexity analysis. By using these complexity analysis, the study result that compares and analyzes the complexity of XML based and C language structure based profile verification software is presented.

A number of algorithms are available for computing the simulation relation on Kripke structures and on labelled transition systems representing concurrentsystems. Among them, the algorithm by Ranzato and Tapparo~[2007] has the best time complexity, while the algorithm by Gentilini et al.~[2003]~--~successivelycorrected by van Glabbeek and Ploeger~[2008]~--~has thebest space complexity. Both space and time complexities are critical issues in a simulation algorithm, in particular memory requirements are crucial in the context of model checking when dealing with large state spaces.We propose here a new simulation algorithm thatis obtained as a space saving modification of the time efficient algorithm by Ranzato and Tapparo: a symbolic representation of sets is embedded in thisalgorithm so that any set of states manipulated by the algorithm can be efficiently stored as a set of blocks of a suitable state partition. It turns out that this new simulation algorithm retains a space complexity comparable with Gentilini et al.'s algorithm while improving on Gentilini et al.'s time bound.

The increasing demand for higher resolution images and higher frame rate videos will always pose a challenge to computational power when performance is required to solve the stereo-matching problem in 3D reconstruction applications. Therefore, the use of asymptotic analysis is necessary to measure the time and space performance of stereo-matching algorithms regardless of the size of the input and of the computational power available. In this paper, we survey several classic stereo-matching algorithms with regard to time---space complexity. We also report running time experiments for several algorithms that are consistent with our complexity analysis. We present a new dense stereo-matching algorithm based on a greedy heuristic path computation in disparity space. A procedure which improves disparity maps in depth discontinuity regions is introduced. This procedure works as a post-processing step for any technique that solves the dense stereo-matching problem. We prove that our algorithm and post-processing procedure have optimal O(n) time---space complexity, where n is the size of a stereo image. Our algorithm performs only a constant number of computations per pixel since it avoids a brute force search over the disparity range. Hence, our algorithm is faster than real-time techniques while producing comparable results when evaluated with ground-truth benchmarks. The correctness of our algorithm is demonstrated with experiments in real and synthetic data.

Paper: "Correlations between a Shintergy synchronized<br> brain and a laser eld; a possible fractal structure<br> of Consciousness<br> (Part I of 7 – Local measure in time and space)." and supplemental material

Paper: "Correlations between a Shintergy synchronized<br> brain and a laser eld; a possible fractal structure<br> of Consciousness<br> (Part I of 7 – Local measure in time and space)." and supplemental material