Time Sequential Algorithm Research Articles

PENGEMBANGAN ABSENSI ONLINE SECARA REAL TIME ALGORITMA SEQUENTIAL SEARCHING MENGGUNAKAN TEKNOLOGI GPS BERBASIS WEB

The attendance application system is important in an era like this, where many large and small companies that initially used fingerprints to be absent or absent manually by admins have now switched to using online attendance. On the one hand, if you are still using manual attendance documents, it is very dangerous to lose or be damaged, therefore there is no web-based use. This attendance is connected to GPS so that the employee's location can be detected when absent. Therefore, Online Attendance in Real Time Sequential Search Algorithm Using Web-Based GPS (Global Positioning System) Technology is very helpful or makes it easier for admins to recap the manpower whether he is not around the office or not. Attendance using this application is very efficient and time-saving and what often happens in small companies is that the employee is no longer there but the employee is not yet in the office, which is detrimental to the company and operations. To make a report using the Online Attendance method in Real Time, Sequential Searching Algorithm Using Web-Based GPS (Global Positioning System) Technology, which requires interviews, research methods, and libraries. Then the software uses the waterfall method which includes: Design, Needs Analysis, Testing, and then Implementation.

Algorithms for testing occurrences of length 4 patterns in permutations

In this paper linear time sequential and optimal parallel algorithms for testing pattern involvement for all length 4 permutations are described. This is an improvement as the previous best sequential algorithms, for most of these pattern require $$O(n\log n)$$ time. Our parallel algorithms can be implemented in $$O(\log n)$$ time with $$n/\log n$$ processors on the CREW PRAM model, or alternatively in $$O(\log \log \log n)$$ time with $$n/\log \log \log n$$ processors on a CRCW PRAM PRAM model. Parallel algorithm can also be implemented in constant time with $$n\log ^3 n$$ processors on a CRCW PRAM model. The previous best parallel algorithms were available for only some of these patterns and took $$O(\log n)$$ time with n processors on the CREW PRAM model.

Pulse signal detection in cognitive UWB system

According to the problem of cognitive ultra wide-band (UWB) spectrum sensing, a novel UWB pulse signal detection algorithm based on cumulative sum (CUSUM) test is proposed in this paper. Based on the analysis of the existing spectrum sensing schemes for cognitive UWB system, some obvious facts are obtained that it is difficult to detect UWB pulse signal with conventional spectrum sensing schemes, due to its low average signal to noise ratio (SNR), large bandwidth, and low duty ratio. In this paper the detection algorithm of signal distribution change, which is application of CUSUM test, is considered to be applied to cognitive UWB spectrum sensing. But CUSUM test request that the pre-change and the post-change distributions are i.i.d, which cannot be satisfied in the detection process of UWB pulse signal. Since there are two time domain descriptions on UWB pulse signal, namely one contains only noise and the other one contains pulse signal plus noise, the existing detection algorithm of signal distribution change cannot be directly applied to detect UWB pulse signal. Hence the uniform probability density function expression of UWB pulse signal is first deduced, then CUSUM test is applied to cognitive UWB spectrum sensing. The proposed algorithm is a time sequential detection algorithm, with low complexity and minimal detection delay, which is suitable to detect the low duty ratio signal. Its performance is evaluated through theoretical analysis and numerical simulations. It is shown that this algorithm outperforms the conventional energy detection algorithm and conquers SNR wall phenomenon.

The Hamiltonian problem on distance-hereditary graphs

In this paper, we first present an O ( n + m ) -time sequential algorithm to solve the Hamiltonian problem on a distance-hereditary graph G, where n and m are the number of vertices and edges of G, respectively. This algorithm is faster than the previous best known algorithm for the problem which takes O ( n 2 ) time. We also give an efficient parallel implementation of our sequential algorithm. Moreover, if G is represented by its decomposition tree form, the problem can be solved optimally in O ( log n ) time using O ( ( n + m ) / log n ) processors on an EREW PRAM.

An Analysis of Totally Clairvoyant Scheduling

Traditional scheduling models assume that the execution time of a job in a periodic job-set is constant in every instance of its execution. This assumption does not hold in real-time systems wherein job execution time is known to vary. A second feature of traditional models is their lack of expressiveness, in that constraints more complex than precedence constraints (for instance, relative timing constraints) cannot be modeled. Thirdly, the schedulability of a real-time system depends upon the degree of clairvoyance afforded to the dispatcher. In this paper, we shall discuss Totally Clairvoyant Scheduling, as modeled within the E-T-C scheduling framework (Subramani, 2002). We show that this instantiation of the scheduling framework captures the central issues in a real-time flow-shop scheduling problem and devise a polynomial time sequential algorithm for the same. The design of the polynomial time algorithm involves the development of a new technique, which we term Mutable Dynamic Programming. We expect that this technique will find applications in other areas of system design, such as Validation and Software Verification. We also introduce an error-minimizing performance metric called Violation Degree and establish that optimizing this metric in a Totally Clairvoyant Scheduling System is NP-Hard.

An optimal parallel algorithm for solving all-pairs shortest paths problem on circular-arc graphs

The shortest-paths problem is a fundamental problem in graph theory and finds diverse applications in various fields. This is why shortest path algorithms have been designed more thoroughly than any other algorithm in graph theory. A large number of optimization problems are mathematically equivalent to the problem of finding shortest paths in a graph. The shortest-path between a pair of vertices is defined as the path with shortest length between the pair of vertices. The shortest path from one vertex to another often gives the best way to route a message between the vertices. This paper presents anO(n2) time sequential algorithm and anO(n2/p+logn) time parallel algorithm on EREW PRAM model for solving all pairs shortest paths problem on circular-arc graphs, wherep andn represent respectively the number of processors and the number of vertices of the circular-arc graph.

Maximum weight k-independent set problem on permutation graphs

Based on a Directed Acyclic Graph approach, an O(kn 2) time sequential algorithm is presented to solve the maximum weight k-independent set problem on weighted-permutation graphs. The weights considered here are all non-negative and associated with each of the n vertices of the graph. This problem has many applications in practical problems like k-machines job scheduling problem, k-colourable subgraph problem, VLSI design and routing problem.

Fast Parallel Reordering and Isomorphism Testing of k -Trees

In this paper two problems on the class of k -trees, a subclass of the class of chordal graphs, are considered: the fast reordering problem and the isomorphism problem. An O(log 2n) time parallel algorithm for the fast reordering problem is described that uses O(nk(n-k)/\kern -1ptlog n) processors on a CRCW PRAM proving membership in the class NC for fixed k . An O(nk(k+1)!) time sequential algorithm for the isomorphism problem is obtained representing an improvement over the O(n2k(k+1)!) algorithm of Sekharan (the second author) [10]. A parallel version of this sequential algorithm is presented that runs in O(log 2n) time using O((nk((k+1)!+n-k))/log n) processors improving on a parallel algorithm of Sekharan for the isomorphism problem [10]. Both the sequential and parallel algorithms use a concept introduced in this paper called the kernel of a k -tree.

The optimal sequential and parallel algorithms to compute all hinge vertices on interval graphs

If the distance between two vertices becomes longer after the removal of a vertexu, thenu is called a hinge vertex. In this paper, a linear time sequential algorithm is presented to find all hinge vertices of an interval graph. Also, a parallel algorithm is presented which takesO(n/P + logn) time usingP processors on an EREW PRAM.

A cost optimal parallel algorithm for computing force field in [formula omitted]-body simulations on a CREW PRAM

We consider the following force field computation problem: given a cluster of n particles in three-dimensional space, compute the force exerted on each particle by the other particles. Depending on different applications, the pairwise interaction could be either gravitational or Lennard–Jones. In both cases, the force between two particles vanishes as the distance between them approaches to infinity. Since there are n(n−1)/2 pairs, direct method requires Θ(n 2) time for force evaluation, which is very expensive for astronomical simulations. In 1985 and 1986, two famous Θ(n logn) time hierarchical tree algorithms were published by Appel (SIAM J. Sci. Statist. Comput. 6 (1985) 85–103) and by Barnes and Hut (Nature, 324 (1980) 446 – 449), respectively. In a recent paper, we presented a linear time algorithm which builds the oct tree bottom-up and showed that Appel's algorithm can be implemented in Θ(n) sequential time. In this paper, we present an algorithm which computes the force field in Θ( logn) time on a Θ(n/ log n) processor CREW PRAM. A key to this optimal parallel algorithm is replacing a recursive top-down force calculation procedure of Appel by an equivalent non-recursive bottom-up procedure. Our parallel algorithm also yields a new Θ(n) time-sequential algorithm for force field computation.

An Efficient Algorithm for Finding a Maximum Weight k-Independent Set on Trapezoid Graphs

The maximum weight k-independent set problem has applications in many practical problems like k-machines job scheduling problem, k-colourable subgraph problem, VLSI design layout and routing problem. Based on DAG (Directed Acyclic Graph) approach, an O(kn2) time sequential algorithm is designed in this paper to solve the maximum weight k-independent set problem on weighted trapezoid graphs. The weights considered here are all non-negative and associated with each of the n vertices of the graph.

Efficient algorithmic learning of the structure of permutation groups by examples

This paper discusses learning algorithms for ascertaining membership, inclusion, and equality in permutation groups. The main results are randomized learning algorithms which take a random generator set of a fixed group G ≤ S n as input. We discuss randomized algorithms for learning the concepts of group membership, inclusion, and equality by representing the group in terms of its strong sequence of generators using random examples from G. We present O( n 3 log n) time sequential learning algorithms for testing membership, inclusion and equality. The running time is expressed as a function of the size of the object set. ( G ≤ S n can have as many as n! elements.) Our bounds hold for all input groups. We also introduce limited parallelism, and our lower processor bounds make our algorithms more practical. Finally, we show that learning two-groups is in class NC by reducing the membership, inclusion, and inequality problems to solving linear systems over GF(2). We present an O(log 3 n) time learning algorithm using n ω processors for learning two-groups from examples (where n × n matrix product takes logarithmic time using n ω processors).

Optimal Computing the Chessboard Distance Transform on Parallel Processing Systems

Thedistance transform(DT) is an image computation tool which can be used to extract the information about the shape and the position of the foreground pixels relative to each other. It converts a binary image into a grey-level image, where each pixel has a value corresponding to the distance to the nearest foreground pixel. The time complexity for computing the distance transform is fully dependent on the different distance metrics. Especially, the more exact the distance transform is, the worse execution time reached will be. Nowadays, quite often thousands of images are processed in a limited time. It seems quite impossible for a sequential computer to do such a computation for the distance transform in real time. In order to provide efficient distance transform computation, it is considerably desirable to develop a parallel algorithm for this operation. In this paper, based on the diagonal propagation approach, we first provide anO(N2) time sequential algorithm to compute thechessboard distance transform(CDT) of anN×Nimage, which is a DT using the chessboard distance metrics. Based on the proposed sequential algorithm, the CDT of a 2D binary image array of sizeN×Ncan be computed inO(logN) time on the EREW PRAM model usingO(N2/logN) processors,O(log logN) time on the CRCW PRAM model usingO(N2/log logN) processors, andO(logN) time on the hypercube computer usingO(N2/logN) processors. Following the mapping as proposed by Lee and Horng, the algorithm for the medial axis transform is also efficiently derived. The medial axis transform of a 2D binary image array of sizeN×Ncan be computed inO(logN) time on the EREW PRAM model usingO(N2/logN) processors,O(log logN) time on the CRCW PRAM model usingO(N2/log logN) processors, andO(logN) time on the hypercube computer usingO(N2/logN) processors. The proposed parallel algorithms are composed of a set of prefix operations. In each prefix operation phase, only increase (add-one) operation and minimum operation are employed. So, the algorithms are especially efficient in practical applications.

On testing consecutive-ones property in parallel

The consecutive-ones property problem has many important applications in the field of discrete algorithms, including the physical mapping problem in computational molecular biology. A (0, 1)-matrix is said to satisfy the consecutive-ones property if there is a permutation of the rows of the matrix such that in each column all non-zero entries are adjacent. The problem of determining such a permutation, if one exists, is the consecutive-ones property problem. The classic algorithm for solving this problem is a linear time sequential algorithm of Booth and Lueker (1976) which is known to be based on the PQ-tree data structure. In this paper we present a new algorithm for this problem using a divide-and-conquer method that employs a graph-theoretic data structure known as Tutte decomposition, i.e., decomposition of graphs into 3-connected components. Our algorithm enjoys the property that it efficiently parallelizes using the standard PRAM parallel computational model, while avoiding the complex implementations associated with PQ-trees. Our algorithm is more work efficient than previous parallel solutions, improving on the known processor bounds.

Near-Linear Time Construction of Sparse Neighborhood Covers

This paper introduces a near-linear time sequential algorithm for constructing a sparse neighborhood cover. This implies analogous improvements (from quadratic to near-linear time) for any problem whose solution relies on network decompositions, including small edge cuts in planar graphs, approximate shortest paths, and weight- and distance-preserving graph spanners. In particular, an O(log n) approximation to the k-shortest paths problem on an n-vertex, E-edge graph is obtained that runs in $\soh{n + E + k}$ time.

Fast Distributed Algorithms for Brooks-Vizing Colourings (Extended Abstract)

Fast Distributed Algorithms for Brooks-Vizing Colourings (Extended Abstract)

An optimal EREW PRAM algorithm for minimum spanning tree verification

We present a deterministic parallel algorithm on the EREW PRAM model to verify a minimum spanning tree of a graph. The algorithm runs on a graph with n vertices and m edges in O( log n) time and O( m + n) work. The algorithm is a parallelization of King's linear time sequential algorithm for the problem.

Proximity problems for points on a rectilinear plane with rectangular obstacles

We consider the following four problems for a setS ofk points on a plane, equipped with the rectilinear metric and containing a setR ofn disjoint rectangular obstacles (so that distance is measured by a shortest rectilinear path avoiding obstacles inR): (a) find aclosest pair of points inS, (b) find anearest neighbor for each point inS, (c) compute the rectilinearVoronoi diagram ofS, and (d) compute a rectilinearminimal spanning tree ofS. We describeO ((n+k) log(n+k))-time sequential algorithms for (a) and (b) based onplane-sweep, and the consideration of geometrically special types of shortest paths, so-calledz-first paths. For (c) we present anO ((n+k) log(n+k) logn)-time sequential algorithm that implements a sophisticateddivide-and-conquer scheme with an addedextension phase. In the extension phase of this scheme we introduce novel geometric structures, in particular so-calledz-diagrams, and techniques associated with the Voronoi diagram. Problem (d) can be reduced to (c) and solved inO ((n+k) log(n+k) logn) time as well. All our algorithms arenear-optimal, as well as easy to implement.

Parallel Threshold Voting

Voting on large collections of input objects is becoming increasingly important in data fusion, signal and image processing applications, learning algorithms, and distributed computing. To achieve high speed in voting, the multiple processing resources typically available in such applications should be utilized; hence the need for parallel voting algorithms. We develop efficient parallel algorithms for threshold voting which generalize and extend previous work on both sequential threshold voting and parallel majority voting. Our discussion centers on unweighted threshold (m-out-of-n) voting. However, we observe that under certain conditions, the results can be extended to efficient weighted threshold voting. We show how a known O(n)-time sequential algorithm for m-out-of-n voting can be parallelized through a simple divide-and-conquer strategy. When m = θ(n), the resulting algorithm has O(log 2 n) time complexity on n-processor PRAM and hypercubic computers and O(k 2 n 1/k ) time complexity on a k-dimensional mesh with n processors. We also analyze the time complexity of the algorithm for m = o(n) and its special case of m = θ(1).

Expander codes

Using expander graphs, we construct a new family of asymptotically good, linear error-correcting codes. These codes have linear time sequential decoding algorithms and logarithmic time parallel decoding algorithms that use a linear number of processors. We present both randomized and explicit constructions of these codes. Experimental results demonstrate the good performance of the randomly chosen codes.