Showing papers on "Tree (data structure) published in 1986"

Planar point location using persistent search trees

Abstract: A classical problem in computational geometry is the planar point location problem. This problem calls for preprocessing a polygonal subdivision of the plane defined by n line segments so that, given a sequence of points, the polygon containing each point can be determined quickly on-line. Several ways of solving this problem in O(log n) query time and O(n) space are known, but they are all rather complicated. We propose a simple O(log n)-query-time, O(n)-space solution, using persistent search trees. A persistent search tree differs from an ordinary search tree in that after an insertion or deletion, the old version of the tree can still be accessed. We develop a persistent form of binary search tree that supports insertions and deletions in the present and queries in the past. The time per query or update is O(log m), where m is the total number of updates, and the space needed is O(1) per update. Our planar point location algorithm is an immediate application of this data structure. The structure also provides an alternative to Chazelle's "hive graph" structure, which has a variety of applications in geometric retrieval.

Energy savings with trees

Abstract: In conventional buildings, trees increase, decrease, or have little effect on energy use depending on general climate, building type, tree species, and tree location. Tree arrangements that save energy provide shade primarily for east and west walls and roofs and wind protection from the direction of prevailing winter winds. Particularly for buildings specially designed to use solar energy and those with solar collectors. it is important to place tree crowns so they do not block sun from collectors and south walls. But conventional houses also benefit from winter sun. Deciduous trees provide better year-round shade than conifers, but do reduce solar energy significantly even without leaves. In winter, reductions in solar energy on south walls by a deciduous tree may be greater than reductions by the same tree in summer. Hence, growth rate and crown shape are important criteria in selecting shade trees, and the placement of trees around the house is important. A summary of research data suggests that the maximum potential annual effect of trees on energy use in conventional houses Is about 20 to 25% compared to the same house in the open.

Rotation distance, triangulations, and hyperbolic geometry

Abstract: A rotation in a binary tree is a local restructuring that changes the tree into another tree. Rotations are useful in the design of tree-based data structures. The rotation distance between a pair of trees is the minimum number of rotations needed to convert one tree into the other. In this paper we establish a tight bound of In 6 on the maximum rotation distance between two A2-node trees for all large n, using volumetric arguments in hyperbolic 3-space. Our proof also gives a tight bound on the minimum number of tetrahedra needed to dissect a polyhedron in the worst case, and reveals connections 1 This is a revised and expanded version of a paper that appeared in the 18th Annual ACM Symposium on Theory of Computing, [9]. 2 Partial support provided by DARPA, ARPA order 4976, amendment 19, monitored by the Air Force Avionics Laboratory under contract F33615-87-C-1499, and by the National Science Foundation under grant CCR-8658139. 3 Partial support provided by the National Science Foundation under grant DCR-8605962. 4 Partial support provided by the National Science Foundation under grants DMR-8504984 and DCR8505517.

S-tree: a dynamic balanced signature index for office retrieval

Abstract: The signature approach is an access method for partial-match retrieval which meets many requirements of an office environment. Signatures are hash coded binary words derived from objects stored in the data base. They serve as a filter for retrieval in order to discard a large number of nonqualifying objects. In an indexed signature method the signatures of objects stored on a single page are used to form a signature for that page. In this paper we describe a new technique of indexed signatures which combines the dynamic balancing of B-trees with the signature approach. The main problem of appropriate splitting is solved in a heuristic way. Operations are described and a simple performance analysis is given. The analysis and some experimental results indicate a considerable performance gain. Moreover, the new S-tree approach supports a clustering on a signature basis. Further remarks on adaptability complete this work.

On the Computation of the Transitive Closure of Relational Operators

Abstract: Query processing in the presence of recursively defined views usually involves some form of iteration. For example, computing the transitive closure of a tree involves iterating N times, where N is the depth of the tree, each time computing pairs of vertices that are one edge further apart than the pairs produced in the previous iteration. Applying a divide and conquer technique we devise algorithms that need a logarithmic number of iterations. Assuming that we are looking for complete materializations of the recursively defined relations we show both through analytical and experimental results that this approach is in many cases superior in performance than the Niteration algorithm

Distributed Routing Algorithms for Broadcasting and Personalized Communication in Hypercubes

Abstract: High communication bandwidth in standard technologies is more expensive to realize than a high rate of arithmetic or logic operations. The effective utilization of communication resources is crucial for good overall performance in highly concurrent systems. In this paper we address two different communication problems in Boolean n-cube configured multiprocessors: 1) broadcasting, i.e., distribution of common data from a single source to all other nodes, and 2) sending personalized data from a single source to all other nodes. The well known spanning tree algorithm obtained by bit-wise complementation of leading zeroes (referredto as the SBT algorithm for Spanning Binomial nee) is compared with an algorithm using multiple spanning binomial trees (MSBT). The MSBT dgorithm offers a potential speed-up over the SBT dgorithm by afactor of log2 N. We also present a balanced #panning tree algorithm (BST) that offers a lower complexity than the SBT algorithm for Case 2. The potential improvement is by a factor of 3 log2 N. The analysis takes into account the size of the data sets, the communication bandwidth, and the overhead in communication. We also provide some experimental data for the Intel iPSC'd7.

Fast constructive-solid geometry display in the pixel-powers graphics system

Abstract: We present two algorithms for the display of CSG-defined objects on Pixel-Powers, an extension of the Pixel-Planes logic-enhanced memory architecture, which calculates for each and every pixel on the screen (in parallel) the value of any quadratic function in the screen coordinates (x,y). The first algorithm restructures any CSG tree into an equivalent, but possibly larger, tree whose display can be achieved by the second algorithm. The second algorithm traverses the restructured tree and generates quadratic coefficients and opcodes for Pixel-Powers. These opcodes instruct Pixel-Powers to generate the boundaries of primitives and perform set operations using the standard Z-buffer algorithm.Several externally-supplied CSG data sets have been processed with the new tree-traversal algorithm and an associated Pixel-Powers simulator. The resulting images indicate that good results can be obtained very rapidly with the new system. For example, the commonly used MBB test part (at right) with 24 primitives is translated into approximately 1900 quadratic equations. On a Pixel-Powers system running at 10MHz (the speed at which our current Pixel-Planes memories run), the image should be rendered in about 7.5 milliseconds.

A Tree System Approach for Fingerprint Pattern Recognition

Abstract: The purpose of this paper is to demonstrate how a syntactic approach and, in particular, a tree system may be used to represent and classify fingerprint patterns. The fingerprint impressions are subdivided into sampling squares which are preprocessed and postprocessed for feature extraction. A set of regular tree languages is used to describe the fingerprint patterns and a set of tree automata is used to recognize the coded patterns. In order to infer the structural configuration of the encoded fingerprints, a grammatical inference system is developed. This sytem utilizes a simple procedure to infer the numerous substructures and relies on a reachability matrix and a man-machine interactive technique for the inference of complex structures. The 92 fingerprint impressions were used to test the proposed approach. A set of 193 tree grammars was inferred from each sampling square of the 4 × 4 sampling matrix which is capable of generating about 2 × 1034 classes for the fingerprint patterns.

Hierarchical net list derivation system

Abstract: A binary tree is created from flat part list and synonym output files and a component library. Each tree record includes a part, type, full path name, and net functional description for each primary net of each block and for each component in that block. The hierarchical coupling of these records and the primary net descriptions in each record supply all of the information necessary to extract a hierarchical net list.

Method of overlaying virtual tree networks onto a message passing parallel processing network

Abstract: A method of overlaying onto a parallel processing network configured as an initial hierarchical tree one or more other virtual trees for concurrently performing parallel processing operations via each tree Tree connect messages identifying a second tree are transmitted from leaf nodes of the initial tree that are to become members of the second tree to a root node of the initial tree Status information is updated at each node in response to the transmittal and receipt of a connect message Acknowledge messages are transmitted from the root node of the initial tree to the leaf nodes of the second tree in response to receipt of the connect messages from the leaf nodes Status information is updated at each node in response to the transmittal and receipt of an acknowledge message The second tree is established when all of its leaf nodes have received an acknowledge message At this time, individual nodes of the second tree may be addressed by messages containing the identity of the second tree

Space Division for Ray Tracing in CSG

Abstract: A system of Constructive Solid Geometry (CSG) enables an engineering designer to compose threedimensional shapes by combining simpler ones. Definitions of such objects are represented by tree structures or directed acyclic graphs. Most existing systems convert this representation to a more conventional boundary representation of the solids in order to render pictures from the model. More recently, a number of systems have been described that render the pictures directly from the CSG structure. We describe such a system. We render a scene by ray tracing from a directed acyclic graph. This process is made efficient for large models by using an adaptive method of space division to reduce the number of intersection calculations needed.

Method for obtaining information in an expert system

Abstract: A method for use in an expert system which selectively allows the system to avoid asking the user a question by providing the answer to that question based on related information that may have been previously attained in the system The method involves providing an action attribute that can be attached to any node in the rule tree The attribute is assigned to a node in the tree which provides an answer to a class question based on processing various other dependent nodes When the answer is obtained, the action attribute then causes all other nodes in the rule base referencing the same class question to be set to the same answer The user is therefore only requested to supply information as a last resort

Remote attribute updating for language-based editors

Abstract: A major drawback to the use of attribute grammars in language-based editors has been that attributes can only depend on neighboring attributes in a program's syntax tree. This paper concerns new attribute-grammar-based methods that, for a suitable class of grammars, overcome this fundamental limitation. The techniques presented allow the updating algorithm to skip over arbitrarily large sections of the tree that more straightforward updating methods visit node by node. These techniques are then extended to deal with aggregate values, so that the attribute updating procedure need only follow dependencies due to a changed component of an aggregate value. Although our methods work only for a restricted class of attribute grammars, satisfying the necessary restrictions should not place an undue burden on the writer of the grammar.

The logic of distributed protocols: preliminary report

Abstract: A propositional logic of distributed protocols is introduced which includes both the logic of knowledge and temporal logic. Phenomena in distributed computing systems such as asynchronous time, incomplete knowledge by the computing agents in the system, and game-like behavior among the computing agents are all modeled in the logic. Two versions of the logic, the linear logic of protocols (LLP) and the tree logic of protocols (TLP) are investigated. The main result is that the set of valid formulas in LLP is undecidable.

Reliability Analysis of Networks with Capacity-Constraints and Failures at Branches & Nodes

Abstract: A new method for reliability analysis of stochastic flow networks is proposed. Nodes as well as branches can have limited capacities and can fail. The method builds a branching tree. The tree-nodes are the disjoint terms of a symbolic reliability expression. The paper shows how to find the probability function and mean of the network performance. The method is both simple and effective. The minimal paths or cutsets are not needed explicitly. On a computer the memory effort is very low ? it increases only quadratically with the number of failing elements. The method can be modified reasonably for other reliability problems.

Steiner Tree Problem

Abstract: Consider an undirected graph G, each of its edges is labeled with a distance. Let S be a specified subset of nodes of G. The Steiner tree problem is to find a tree of G that spans S with minimal total distance on its edges. The nodes in the set S are called Steiner points.

Multiple Storage Quad Trees: A Simpler Faster Alternative to Bisector List Quad Trees

Abstract: A bisector list quad tree is a quad tree which stores objects intersecting more than one quad on horizontal and vertical bisector lists. This is the form of quad tree originally proposed by Kedem for organizing boxes and polygons in a plane so that one can quickly find the objects intersecting an arbitrary window. A multiple storage quad tree is a quad tree which stores pointers to objects intersecting more than one quad in all of the quads that they intersect. This paper describes and analyzes multiple storage quad trees. It is shown that multiple storage quad trees can be efficient in storage space, often using less than 25 percent more space than a simple list of the objects. That is, the tree nodes and other pointers combined often use less than 25 percent of the space needed to store the object descriptions. It is also shown that using multiple-storage quad trees makes possible very rapid searches for the objects intersecting a small window. In most cases fewer than 10 nodes must be examined per object found in the window. Finally, multiple storage quad trees and the algorithms which operate on them are found to be very simple and intuitive.

Improved hierarchical bit-vector compression in document retrieval systems

Abstract: The “concordance” of an information retrieval system can often be stored in form of bit-maps, which are usually very sparse and should be compressed. Hierarchical bit-vector compression consists of partitioning a vector vi into equi-sized blocks, constructing a new bit-vector vi+1 which points to the non-zero blocks in vi, dropping the zero-blocks of vi, and repeating the process for vi+1. We refine the method by pruning some of the tree branches if they ultimately point to very few documents; these document numbers are then added to an appended list which is compressed by the prefix-omission technique. The new method was thoroughly tested on the bit-maps of the Responsa Retrieval Project, and gave a relative improvement of about 40% over the conventional hierarchical compression method.

Distributed Recovery in Fault-Tolerant Multiprocessor Networks

Abstract: A methodology for characterizing dynamic distributed recovery in fault-tolerant multiprocessor systems is developed using graph theory. Distributed recovery, which is intended for systems with no central supervisor, depends on the cooperation of a set of processors to execute the recovery function, since each processor is assumed to have only a limited amount of information about the system as a whole. Facility graphs, whose nodes denote the system components (processors), and whose edges denote interconnection between components, are used to represent multiprocessor systems, and error conditions. A general distributed recovery strategy R, which allows global recovery to be achieved via a sequence of local actions, is given. R recovers the system in several steps in which different nodes successively act as the local supervisor. R is specialized for two important classes of systems: loop networks and tree networks. For each of these cases, fault-tolerant designs and their associated distributed recovery strategies, which allow recovery from up to k faults within a specified number of steps, are presented.