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

An Algorithm for the General Petri Net Reachability Problem

Abstract: An algorithm is presented for the general Petri net reachability problem. It is based on a generalization of the basic reachability tree construction which is made symmetric with respect to the ini...

Generating language-based environments

Abstract: This thesis concerns the design of interactive, language-based programming environments that use knowledge of a programming language to provide functions based on the structure and meaning of programs. The goal of the research is a system-constructor to enable editors for different languages to be created easily. The most challenging aspect of such a system is the design of the semantic component, because a language-based editor performs static semantic analysis when a program is altered in order to detect erroneous constructions or to prevent illegal modifications. For efficiency, this should be performed incrementally, re-using as much old information as possible; therefore, a major focus of my research concerns a model of editing for which it is possible to perform incremental semantic analysis efficiently. In this model, a program is represented as an attributed tree in which all attributes have consistent values; programs are modified by tree operations such as pruning, grafting, and deriving. After each modification, some of the attributes require new values; incremental semantic analysis is performed by updating attribute values to again make them all consistent. The thesis presents several algorithms for this process that are asymptotically optimal in time. The chief disadvantage of attribute grammars is that they use large amounts of storage. The thesis discusses three aspects of utilizing storage efficiently in such systems. One way to reduce the amount of storage used is to reduce the number of atttribute values retained at any stage of attribute evaluation. The thesis establishes two results concerning this idea: it presents one algorithm for evaluating an n-attribute tree that never saves more than $O(\sqrt{n}$ attribute values, and it presents a second algorithm that never saves more than $O(\log n)$ attribute values. A second method for reducing the amount of storage is to share the space used for storing attributes whose values are complex data structures; the thesis presents a very general method for such sharing that can be applied to attributes of many types. Finally, the thesis describes how, by restricting the class of attribute grammars, it is possible to reduce the amount of storage overhead required for updating trees in optimal time.

A null-object detection algorithm for constructive solid geometry

Abstract: Constructive solid geometry (CSG) is the primary scheme used for representing solid objects in many contemporary solid modeling systems. A CSG representation is a binary tree whose nonterminal nodes represent Boolean operations and whose terminal nodes represent primitive solids. This paper deals with algorithms that operate directly on CSG representations to solve two computationally difficult geometric problems—null-object detection (NOD) and same-object detection (SOD). The paper also shows that CSG trees representing null objects may be reduced to null trees through the use of a new concept called primitive redundancy, and that, on average, tree reduction can be done efficiently by a new technique called spatial localization. Primitive redundancy and spatial localization enable a single complex instance of NOD to be converted into a number of simpler subproblems and lead to more efficient algorithms than those previously known.

Method and apparatus for generating hierarchical displays

Abstract: Method and apparatus are described for drawing tree structures on output displays and on printed output reports. The tree structures include complete illustration of nodes and branches connecting the same, and further provides display or printing of data associated with the various nodes. The central node of the tree may be arbitrarily selected by redrawing the structure to focus on the root node of the tree or on the arbitrarily selected central node. For economic use of display space, a skeletal display may be provided in which only the nodes descendent from the central node of interest are shown with the associated data, the remaining nodes being displayed in skeletal format only. The tree structure may be applied to a descision making algorithm, and may be used to provide a number of alternatives useful for attaining a desired goal, and for evaluating the various alternatives.

Method for generating and displaying tree structures in a limited display area

Abstract: There is disclosed a method for constructing and displaying tree structures with automated data processing equipment. A focused view of a portion of the tree is provided to enable an operator to perform editing and evaluating functions on the tree. The focused view presents a view of this portion of the tree structure with a geometry different than what would be used if the entire structure were to be portrayed. This provides a view with sufficient resolution to be highly readable. In the preferred embodiment, the focused view is comprised of a focus node of the tree, its parent node along with the branch connecting the parent node and the focus node, the sibling branches of the connecting branch, all successor nodes of the focus node, and the branches connecting the successor nodes to the focus node.

How to assemble tree machines

Abstract: : Many researchers have proposed that ensembles of processing elements be organized as trees. This paper explores how large tree machines can be assembled efficiently from smaller components. A principal constraint considered is the limited number of external connections from an integrated circuit chip. We also explore the emerging capability of restructurable VLSI which allows a chip to be customized after fabrication. The authors give a linear-area chip of m processors and only four off-chip connections which can be used as the sole building block to construct an arbitrarily large complete binary tree. They also present a restructurable linear-area layout of m processors with O(lg m) pins that can realize an arbitrary binary tree of any size. This layout is based on a solution to the graph-theoretic problem: Given a tree in which each vertex is either black or white, determine how many edges need be cut in order to bisect the tree into equal-size components, each containing exactly half the black and half of the white vertices. These ideas extend to more general graphs using separator theorems or bifurcators. (Author)

3DPO's strategy for matching three-dimensional objects in range data

Abstract: A strategy for recognizing and locating three-dimensional objects in range data is presented. The strategy combines information derived from models of the objects and edges and surfaces detected in the data to efficiently match objects. Given a set of objects to be found, the set of object features are partitioned into subsets having similar intrinsic properties. An ordered tree of features to be considered is set up for each subset. These search trees are designed to maximize the use of the information as it is obtained and minimize the time required to recognize objects. A detailed example of this approach being used to recognize moderately complex castings in a jumble is presented.

Log Bucking and Lumber Manufacturing Using Dynamic Programming

Abstract: The process of converting a tree into finished lumber involves several interrelated steps. The two of greatest potential for improvement are cutting the felled tree into shorter logs (called bucking the tree) and sawing the bucked logs into lumber. Unlike previous work in the area, this paper considers the two activities together as a single production system. The model allows for variations in tree shape and quality which could be recorded by modern electronic scanners. Among the principal techniques used in the paper are dynamic programming for both bucking and sawing, and a procedure for calculating the distance between two polyhedral sets in R2. Computational experience is reported on trees with representative defect patterns, taper, and sweep.

A Tree-Matching Algorithm Based on Node Splitting and Merging

Abstract: An algorithm that computes the best matching of two trees is described The degree of mismatch, ie, the distance, is measured in terms of the number of node splitting and merging operations required The proposed tree distance is a more appropriate measurement of structural defonnation than the tree distance measure in terms of the number of insertions, deletions, and substitutions of tree nodes, as defined in previous studies An algorithm that uses a divide-and-conquer strategy is presented The analysis shows that the time complexity is O(NM2) where N and Al are the number of nodes of the two trees, respectively The algorithm has been implemented on a VAX 11/780

Efficient Prolog memory management for flexible control strategies

Abstract: A Prolog interpreter can be viewed as a process that searches a tree in order to produce the sets of terms at certain successful leaves. It does this by constructing the set of terms for each node in the tree. Moving from one node to another requires (re)construction of the set of terms at that node. The choice of representation of sets of terms influences the kind of tree search that can be supported.

Dynamics of flexible bodies in tree topology - A computer oriented approach

Abstract: An approach suited for automatic generation of the equations of motion for large mechanical systems (i.e., large space structures, mechanisms, robots, etc.) is presented. The system topology is restricted to a tree configuration. The tree is defined as an arbitrary set of rigid and flexible bodies connected by hinges characterizing relative translations and rotations of two adjoining bodies. The equations of motion are derived via Kane's method. The resulting equation set is of minimum dimension. Dynamical equations are imbedded in a computer program called TREETOPS. Extensive control simulation capability is built in the TREETOPS program. The simulation is driven by an interactive set-up program resulting in an easy to use analysis tool.

A Linear-Time Algorithm for Maxisum Facility Location on Tree Networks

Abstract: This paper treats a topic in “obnoxious facility location,” namely the problem of locating a single facility in an n-vertex tree network so as to maximize the sum of its weighted distances from the vertices. It is shown that use of a suitable data structure permits a solution algorithm with computational effort O(n), an improvement over the O(n2) required by a previously indicated procedure.

Analysis of speedup in distributed algorithms

Abstract: We present and analyze several practical parallel algorithms for multicomputers. Chapter four presents two distributed algorithms for implementing alpha-beta search on a tree of processors. Each processor is an independent computer with its own memory and is connected by communication lines to each of its nearest neighbors. Measurements of the first algorithm's performance on the Arachne distributed operating system are presented. For each algorithm, a theoretical model is developed that predicts speedup with arbitrarily many processors. Chapter five shows how locally-defined iterative methods give rise to natural multicomputer algorithms. We consider two interconnection topologies, the grid and the tree. Each processor (or terminal processor in the case of a tree multicomputer) engages in serial computation on its region and communicates border values to its neighbors when those values become available. As a focus for our investigation we consider the numerical solution of elliptic partial differential equations. We concentrate on the Dirichlet problem for Laplace's equation on a square region, but our results can be generalized to situations involving arbitrarily shaped domains (of any number of dimensions) and elliptic equations with variable coefficients. Our analysis derives the running time of the grid and the tree algorithms with respect to per-message overhead, per-point communication time, and per-point computation time. The overall result is that the larger the problem, the closer the algorithms approach optimal speedup. We also show how to apply the tree algorithms to non-uniform regions. A large-network algorithm solves a problem of size N on a network of N processors. Chapter six presents a general method for transforming large-network algorithms into quotient-network algorithms, which solve problems of size N on networks with fewer processors. This transformation allows algorithms to be designed assuming any number of processing elements. The implementation of such algorithms on a quotient network results in no loss of efficiency, and often a great savings in hardware cost.

Lighting system for artificial Christmas tree

Abstract: An electrical lighting system for a tree especially adapted to an artificial Christmas tree having removable limbs. The system includes electrical conducting distribution straps or bands which may be wrapped around and secured to a tree trunk at selected levels. Each of the distribution bands has prong means and electric lead and plug means for interconnecting the bands along the tree trunk and a plurality of spaced apertures for insertion of male electrical plugs around each of the bands on the tree trunk. Also included are electrical branch circuits having a plurality of sockets and bulbs for mounting on each of the removable tree limbs, each of the circuits having a male plug connectible with the spaced apertures on the nearest distribution band for supplying electricity from the band to the branch circuit. After the bands and the branch circuits are installed on the tree trunk and removable tree limbs, the bands and branch circuits may remain on the trunk and limbs when the trunk and limbs are disassembled for storage purposes.

The Representation of Three-Way Proximity Data by Single and Multiple Tree Structure Models

Abstract: Models for the representation of proximity data (similarities/dissimilarities) can be categorized into one of three groups of models: continuous spatial models, discrete nonspatial models, and hybrid models (which combine aspects of both spatial and discrete models). Multidimensional scaling models and associated methods, used for the spatial representation of such proximity data, have been devised to accommodate two, three, and higher-way arrays. At least one model/method for overlapping (but generally non-hierarchical) clustering called INDCLUS (Carroll and Arabic 1983) has been devised for the ease of three-way arrays of proximity data. Tree-fitting methods, used for the discrete network representation of such proximity data, have only thus far been devised to handle two-way arrays. This paper develops a new methodology called INDTREES (for individual Differences in TREE Structures) for fitting various (discrete) tree structures to three-way proximity data. This individual differences generalization is one in which different individuals, for example, are assumed to base their judgments on the same family of trees, but are allowed to have different node heights and/or branch lengths. We initially present an introductory overview focussing on existing two-way models. The INDTREES model and algorithm are then described in detail. Monte Carlo results for the INDTREES fitting of four different three-way data sets are presented. In the application, a single ultrametric tree is fitted to three-way proximity data derived from intention-to-buy-data for various brands of over-the-counter pain relievers for relieving three common types of maladies. Finally, we briefly describe how the INDTREES procedure can be extended to accommodate hybrid modelling, as well as to handle other types of applications.

A logical reconstruction of Prolog II

Abstract: Colmerauer has proposed a theoretical model for Prolog II based on tree rewriting rather than logic. In this paper, we show that Prolog II can be regarded as a logic programming language.

Algorithms for the Conversion of Quadtrees to Rasters

Abstract: A number of algorithms are presented for obtaining a raster representation for an image given its quadtree The algorithms are given in an evolutionary manner starting with the straightforward top-down approach that visits each run in a row in succession starting at the root of the tree The remaining algorithms proceed in a manner akin to an inorder tree traversal All of the algorithms are analyzed and an indication is given as to when each is preferable The execution time of all of the algorithms is shown to be proportional to the sum of the heights of the blocks comprising the image

Ultrametric tree representations of incomplete dissimilarity data

Abstract: The least squares algorithm for fitting ultrametric trees to proximity data originally proposed by Carroll and Pruzansky and further elaborated by De Soete is extended to handle missing data. A Monte Carlo evaluation reveals that the algorithm is capable of recovering an ultrametric tree underlying an incomplete set of error-perturbed dissimilarities quite well.

Systolic tree acceptors

Abstract: Introduction des automates systoliques pour VLSI comme accepteurs avec un grand degre de parallelisme. On concentre l'attention sur les automates d'arbres