Showing papers on "Binary tree published in 1990"

Automata on Infinite Objects.

Abstract: Publisher Summary This chapter focuses on finite automata on infinite sequences and infinite trees. The chapter discusses the complexity of the complementation process and the equivalence test. Deterministic Muller automata and nondeterministic Buchi automata are equivalent in recognition power. Any nonempty Rabin recognizable set contains a regular tree and shows that the emptiness problem for Rabin tree automata is decidable. The chapter discusses the formulation of two interesting generalizations of Rabin's Tree Theorem and presents some remarks on the undecidable extensions of the monadic theory of the binary tree. A short overview of the work that studies the fine structure of the class of Rabin recognizable sets of trees is also presented in the chapter. Depending on the formalism in which tree properties are classified, the results fall in three categories: monadic second-order logic, tree automata, and fixed-point calculi.

Communication complexity of PRAMs

Abstract: We propose a model for the concurrent read exclusive write PRAM that captures its communication and computational requirements. For this model, we present several results, including the following:

Application of heuristic search and information theory to sequential fault diagnosis

Abstract: The problem of constructing optimal and near-optimal test sequences to diagnose permanent faults in electronic and electromechanical systems is considered. The test sequencing problem is formulated as an optimal binary AND/OR decision tree construction problem, whose solution is known to be NP-complete. The approach used is based on integrated concepts from information theory and heuristic AND/OR graph search methods to subdue the computational explosion of the optimal test-sequencing problem. Lower bounds on the optimal cost-to-go from the information-theoretic concepts of Huffman coding and entropy are derived. These lower bounds ensure that an optimal solution is found using the heuristic AND/OR graph search algorithms; they have made it possible to obtain optimal test sequences to problems that are intractable with traditional dynamic programming techniques. In addition, a class of test-sequencing algorithms that provide a tradeoff between solution quality and complexity have been derived using the epsilon -optimal and limited search strategies. >

Efficient binary space partitions for hidden-surface removal and solid modeling

Abstract: We consider schemes for recursively dividing a set of geometric objects by hyperplanes until all objects are separated. Such abinary space partition, or BSP, is naturally considered as a binary tree where each internal node corresponds to a division. The goal is to choose the hyperplanes properly so that the size of the BSP, i.e., the number of resulting fragments of the objects, is minimized. For the two-dimensional case, we construct BSPs of sizeO(n logn) forn edges, while in three dimensions, we obtain BSPs of sizeO(n2) forn planar facets and prove a matching lower bound of ?(n2). Two applications of efficient BSPs are given. The first is anO(n2)-sized data structure for implementing a hidden-surface removal scheme of Fuchset al. [6]. The second application is in solid modeling: given a polyhedron described by itsn faces, we show how to generate anO(n2)-sized CSG (constructive-solid-geometry) formula whose literals correspond to half-spaces supporting the faces of the polyhedron. The best previous results for both of these problems wereO(n3).

A node-positioning algorithm for general trees

Abstract: Drawing a tree consists of two stages: determining the position of each node, and actually rendering the individuals nodes and interconnecting branches. The algorithm described in this paper is concerned with the first stage: given a list of nodes, an indication of the hierarchical relationship among them, and their shape and size, where should each node be positioned for optimal aesthetic effect? This algorithm determines the positions of the nodes for any arbitrary general tree. It is the most desirable positioning with respect to certain widely-accepted heuristics. The positioning, specified in x, y co-ordinates, minimizes the width of the tree. In a general tree, there is no limit on the number of offspring per node; this contrasts with binary and ternary trees, for example, which are trees with a limit of two and three offspring per node. This algorithm operates in time O(N), where N is the number of nodes in the tree. Previously, most tree drawings have been positioned by the sure hand of a human graphic designer. Many computer-generated positionings have been either trivial or contained irregularities. Earlier work by Wetherell and Shannon1 and Tilford,2 upon which this algorithm builds, failed to position the interior nodes of some trees correctly. The algorithm presented here correctly positions a tree's node using only two passes. It also handles several practical considerations: alternative orientations of the tree, variable node sizes and out-of-bounds conditions. Radack,3 also building on Tilford's work, has solved this same problem with a different algorithm which makes four passes.

Navigational techniques to improve the display of large two-dimensional spaces

Abstract: Often the components of a problem can be arrayed on a two-dimensional information space—for example, as an abstract tree or hypertext—far too large to fit onto a computer display. With current navigational techniques it is often difficult for users to keep track of their location or to move rapidly to remote locations in the space. We implemented two similar direct-manipulation techniques, both of which use a map window—a miniature of the entire information space—with a wire-frame box to aid users in remembering their location. The first technique allows the user to rapidly roam over the information space by moving the location of the wire-frame box. The second allows for zooming as well as roaming. A controlled experiment compared the above techniques to scroll bars for determining whether a target word was in a large balanced binary tree of words. The experiment also examined the merit of the map window. Map windows significantly improved user performance, and the roam and zoom techniques were ...

Neural trees: a new tool for classification

Abstract: The authors propose a new classifier based on neural network techniques. The ‘network’ consists of a set of perceptrons functionally organized in a binary tree (‘neural tree’). The learning algorithm is inspired from a growth algorithm, the tiling algorithm, recently introduced for feedforward neural networks. As in the former case, this is a constructive algorithm, for which convergence is guaranteed. In the neural tree one distinguishes the structural organization from the functional organization: each neuron of a neural tree receives inputs from, and only from, the input layer; its output does not feed into any other neuron, but is used to propagate down a decision tree. The main advantage of this approach is due to the local processing in restricted portions of input space, during both learning and classification. Moreover, only a small subset of neurons have to be updated during the classification stage. Finally, this approach is easily and efficiently extended to classification in a multiclass probl...

Reconfigurable signal processor

Abstract: An interconnection scheme among the processing elements ("PEs") of a multiprocessor computing architecture realizes, through PE reconfiguration, both fault tolerance and a wide variety of different processing topologies including binary trees and linear systolic arrays. By using a novel variant on a tree expansion scheme, the invention also allows for arbitrary up-sizing of the PE count to build virtually any size of tree network, with each size exhibiting same high degree of fault tolerance and reconfigurability. The invention may be practiced with 4-port PEs arrayed in a module comprising a 4×4 board-mounted PE lattice. Each PE has four physical ports, which connect to the similar ports of its lattice neighbors. Each PE has an internal capability to be configured to route signals to or from any of its neighbors. Thus, for tree topologies, any of the four neighbors of a given PE may be selected as the parent of the given PE; and any or all of the remaining three neighboring PEs may be selected as the child(ren) PEs. The PE ports are configured under the control of a remote host, which establishes an initial desired PE topology. The operability of the PEs is tested, and information on faulty PEs or communications paths is used to enable or disable nodes as necessary by revising the PE port configurations. The nodes thus are reorganized and can run or continue running, on a degraded basis.

Fuzzy multiple-input maximum and minimum circuits in current mode and their analyses using bounded-difference equations

Abstract: Multiple-input maximum and minimum circuits in current mode are proposed. The operation of these circuits is formulated using simultaneous bounded-difference equations. The exact analyses are performed by solving the bounded-difference equations. The accuracy of these circuits is better than the accuracy of binary tree realizations using two-input max/min circuits because no accumulation of errors occurs; furthermore, the operation speed is higher than the speed of the binary tree realization. The proposed circuits consist of only MOS transistors and are compatible with standard MOS fabrication processes. These circuits are useful building blocks for a real-time fuzzy controller and a fuzzy computer. >

Drawing dynamic trees

Abstract: A tree-drawing algorithm that addresses the weaknesses of current approaches to constructing graphical user interfaces is presented. Present algorithms either do not let you draw tree nodes of varying shapes and sizes or they draw such trees in a way that does not produce trees as compact as they could be, which is especially important when diagramming a large system. Also, they cannot reuse layout information when the trees changes, so after every change the layout must be recomputed and the tree redrawn. The main difference between these traditional approaches and the author's approach is that his algorithm is more geometric. Unlike other algorithms, it uses an explicit representation of node and subtree contours, and it stores every contour as a polygon. It has three advantages over traditional algorithms. It allows one to draw trees with nodes of any polygonal shape compactly. The data structure supports insert and delete operations on subtrees. It is simple to implement, yet flexible. >

Analytic variations on the common subexpression problem

Abstract: Any tree can be represented in a maximally compact form as a directed acyclic graph where common subtrees are factored and shared, being represented only once. Such a compaction can be effected in linear time. It is used to save storage in implementations of functional programming languages, as well as in symbolic manipulation and computer algebra systems. In compiling, the compaction problem is known as the “common subexpression problem” and it plays a central role in register allocation, code generation and optimisation. We establish here that, under a variety of probabilistic models, a tree of size n has a compacted form of expected size asymptotically $$C\frac{n}{{\sqrt {\log n} }},$$ where the constant C is explicitly related to the type of trees to be compacted and to the statistical model reflecting tree usage. In particular the savings in storage approach 100% on average for large structures, which overperforms the commonly used form of sharing that is restricted to leaves (atoms).

A new tree type data structure with homogeneous nodes suitable for a very large spatial database

Abstract: A new dynamic data structure for spatial retrieval called a GBD tree is proposed. The GBD tree is systematically constructed using homogeneous nodes with a small amount of extra data called a DZ expression which plays an important role in efficient multiway recursive division of N-dimensional space. On the GBD tree, CPU cost during insertion and deletion is much smaller than on an R-tree, while attaining higher spatial retrieval efficiency. >

On the distribution of lengths of evolutionary trees

Abstract: This paper presents the results of the authors’ investigation of a combinatorial problem arising from the study of evolutionary trees. In graph theoretic terms it can be expressed as a problem of colouring vertices of a binary tree. For a given colouring of the pendant vertices of a binary tree there is a simple algorithm for assigning colours to internal vertices minimising the number of edges of the tree whose end vertices have differing colours. This minimal number is called the length of the tree. The question posed is: For given numbers of pendant vertices of assigned colours, how many trees of a particular length can be constructed on those vertices? This question is answered in two special cases. Answers to this problem are needed to establish the distribution of lengths of evolutionary trees, by which the significance of the maximum parsimony principle for selecting evolutionary trees can be judged.

The arc tree: an approximation scheme to represent arbitrary curved shapes

Abstract: This paper introduces the arc tree, a hierarchical data structure to represent arbitrary curved shapes. The arc tree is a balanced binary tree that represents a curve of length l such that any subtree whose root is on the kth tree level is representing a subcurve of length l 2 k . Each tree level is associated with an approximation of the curve; lower levels correspond to approximations of higher resolution. Based on this hierarchy of detail, queries such as point search or intersection detection and computation can be solved in a hierarchical manner. Algorithms start out near the root of the tree and try to solve the queries at a very coarse resolution. If that is not possible, the resolution is increased where necessary. We describe and analyze several such algorithms to compute a variety of set and search operators. Various related approximation schemes to represent curved shapes are also discussed.

Unique binary search tree representations and equality-testing of sets and sequences

Abstract: : Given an ordered universe U, we study the problem of representing each subset of U by a unique binary search tree so that dictionary operations can be performed efficiently. We exhibit representations that permit the execution of dictionary operations in optimal time when the dictionary is sufficiently sparse or sufficiently dense. We apply unique representations to obtain efficient data structures for maintaining a collection of sets/sequences under queries that test the equality of a pair of objects. In the process, we devise an interesting method for maintaining a dynamic, sparse array.

Embeddings of treelike graphs into 2-dimensional meshes

Abstract: In the following we present embeddings of complete binary trees, pyramids and X-trees into 2-dimensional meshes. The presented embeddings achieve optimal expansion with congestion 2 for trees and congestion 6 for X-trees, and constant expansion ≤3 with congestion 3 for pyramids. The dilations are shown to be near optimal.

Block colouring schemes for the SOR method on local memory parallel computers

Abstract: We introduce the concept of a block colouring which we use to obtain parallel versions of the SOR method. Block colourings are particularly well suited for banded linear systems and finite difference discretizations. We show that on a local memory parallel computer block colour SOR often induces less communicational overhead than the traditional multicolour SOR method. This is confirmed by numerical experiments with two simple examples on a 64-processor binary tree computer.

Fast multiplier design using redundant signed-digit numbers

Abstract: A high speed multiplier design is presented using redundant binary signed-digit number representation internally while the input operands and the output product are in two's complement form. The design of a carry free redundant binary signed-digit (RBSD) adder cell is presented. The multiplication algorithm uses bit-pair recording to generate the partial products. The partial products are added in the form of a binary tree using carry free RBSD adder cells. The regular structure of these adder cells results in a multiplier design that is suitable for VLSI implementation. The increased speed is achieved through the carry free addition of partial products using redundant signed-digit numbers. The use of a recoding scheme will reduce the number of rows of partial products by a factor of two. The proposed multiplier design has a multiplication time of order O(log2 n) and area-time complexity of order O(n2 log2 n) for a word length of n.

Quick Recovery of Embedded Structures in Hypercube Computers

Abstract: We investigate the design of fault-tolerant embedding functions of application graphs into hypercubes with the aim of minimizing the recovery cost and performance degradation due to faults. The recovery cost is measured by the number of node-state changes or recovery steps. Performance is measured by the dilation of the embedding, which is the maximum distance between the embedded images of two nodes that are adjacent in the application graph. The basic idea is to embed application graphs so that spare nodes are always close to failed nodes whenever reconfiguration occurs. We develop 1FT and 2-FT embeddings for paths, even-length loops, meshes, toruses and complete binary trees into hypercubes. Embeddings with higher fault tolerance are also obtained for meshes and toruses. The processor utilization of these embeddings is reasonably high and most of them take the minimum number of recovery steps.

Comparison between entropy net and decision tree classifiers

Abstract: A class of hierarchical feedforward layered neural networks, called entropy nets, has been proposed to overcome the difficulty of the credit assignment problem and to introduce the self-configurable capability in the design and training of artificial neural networks. These networks are based on mapping binary decision trees into a three-layer structure. The authors report the results of an experimental study comparing the classification performance of the decision tree and the entropy-net classifiers. In addition to the consistently better performance of the entropy net with respect to the decision-tree classifier, it is observed that the entropy net is able to achieve its highest performance level in far fewer iterations than commonly required in the nonhierarchical feedforward networks trained using backpropagation. The reason for this lies in the coarse learning achieved during the binary tree development

Dynamic processor allocation in hypercube computers

Abstract: Fully recognizing various subcubes in a hypercube computer efficiently is nontrivial due to the specific structure of the hypercube. We propose a method with much less complexity than the multiple-GC strategy in generating the search space, while achieving complete subcube recognition. This method is referred to as a dynamic processor allocation scheme because the search space generated is dependent upon the dimension of the requested subcube dynamically, rather than being predetermined and fixed. The basic idea of this strategy lies in collapsing the binary tree representations of a hypercube successively so that the nodes which form a subcube but are distant would be brought close to each other for recognition. The strategy can be implemented efficiently by using shuffle operations on the leaf node addresses of binary tree representations. Extensive simulation runs are carried out to collect experimental performance measures of interest of different allocation strategies. It is shown from analytic and experimental results that this strategy compares favorably in many situations to any other known allocation scheme capable of achieving complete subcube recognition.

The complexity of finding uniform emulations on paths and ring networks

Abstract: Uniform emulations are a method to obtain efficient, balanced simulations of large processor networks (guests) on smaller processor networks (hosts). Each uniform emulation has associated with it a constant c, called the computation factor, which is the size of the guest network divided by the size of the host network. In this paper we prove that the problem to decide whether a given connected graph (guest network) G can be uniformly emulated on a path or a ring network is NP-complete, even if G is required to be a binary tree. If the computation factor c is fixed, then these problems become solvable in polynomial time for arbitrary connected graphs G. However, if we keep the computation factor fixed at at least 4 or 2 for the path- or ring-version, respectively, but allow disconnected graphs G, then the problem again is NP-complete. Similar results are shown for directed graphs.

A parallel algorithm for 2-D DFT computation with no interprocessor communication

Abstract: A parallel algorithm is proposed for the two-dimensional discrete Fourier transform (2-D DFT) computation which eliminates interprocessor communications and uses only O(N) processors. The mapping of the algorithm onto architectures with broadcast and report capabilities is discussed. Expressions are obtained for estimating the speed performance on these machines as a function of the size N*N of the 2-D DFT, the bandwidth of the communications channel, the time for an addition, the time T(F/sub N/) for a single processing element to perform an N-point DFT, and the degree of parallelism. For single I/O channel machines that are capable of exploiting the full degree of parallelism of the algorithm, attainable execution times are as low as the time T(F/sub N/) plus the I/O time for data upload and download. An implementation on a binary tree computer is discussed. >