Showing papers on "Interval tree published in 1996"

Full reconstruction of Markov models on evolutionary trees: Identifiability and consistency

Abstract: A Markov model of evolution of characters on a phylogenetic tree consists of a tree topology together with a specification of probability transition matrices on the edges of the tree. Previous work has shown that, under mild conditions, the tree topology may be reconstructed, in the sense that the topology is identifiable from knowledge of the joint distribution of character states at pairs of terminal nodes of the tree. Also, the method of maximum likelihood is statistically consistent for inferring the tree topology. In this article we answer the analogous questions for reconstructing the full model, including the edge transition matrices. Under mild conditions, such full reconstruction is achievable, not by using pairs of terminal nodes, but rather by using triples of terminal nodes. The identifiability result generalizes previous results that were restricted either to characters having two states or to transition matrices having special structure. The proof develops matrix relationships that may be exploited to identify the model. We also use the identifiability result to prove that the method of maximum likelihood is consistent for reconstructing the full model.

System and method for construction of a data structure for indexing multidimensional objects

Abstract: An apparatus and a method for constructing a multidimensional index tree which minimizes the time to access data objects and is resilient to the skewness of the data. This is achieved through successive partitioning of all given data objects by considering one level at a time starting with one partition and using a top-down approach until each final partition can fit within a leaf node. Subdividing the data objects is via a global optimization approach to minimize the area overlap and perimeter of the minimum bounding rectangles covered by each node. The current invention divides the index construction problem into two subproblems: the first one addresses the tightness of the packing (in terms of area, overlap and perimeter) using a small fan out at each index node and the other one handles the fan out issue to improve index page utilization. These two stages are referred to as binarization and compression. The binarization stage constructs a binary tree such that the entries in the leaf nodes correspond to the spatial data objects. The compression stage converts the binary tree into a tree for which all but the leaf nodes and the parent nodes of all leaf nodes have branch factors of M. In the binarization stage, a weighting or skew factor is used to achieve flexibility in determining the number of data objects to be included in each of the partitions to obtain a tree structure with desirable query performance. Thus the index tree constructed is not required to be height balanced. This provides a means to trade-off imbalance in the index tree in order to reduce the number of pages which need to be accessed in a query.

On the boosting ability of top-down decision tree learning algorithms

Abstract: We analyze the performance of top?down algorithms for decision tree learning, such as those employed by the widely used C4.5 and CART software packages. Our main result is a proof that such algorithms areboostingalgorithms. By this we mean that if the functions that label the internal nodes of the decision tree can weakly approximate the unknown target function, then the top?down algorithms we study will amplify this weaks advantage to build a tree achieving any desired level of accuracy. The bounds we obtain for this amplification show an interesting dependence on thesplitting criterionused by the top?down algorithm. More precisely, if the functions used to label the internal nodes have error 1/2??as approximations to the target function, then for the splitting criteria used by CART and C4.5, trees of size (1/?)O(1/?2?2)and (1/?)O(log(1/?)/?2)(respectively) suffice to drive the error below?. Thus (for example), a small constant advantage over random guessing is amplified to any larger constant advantage with trees of constant size. For a new splitting criterion suggested by our analysis, the much stronger bound of (1/?)O(1/?2)which is polynomial in 1/?) is obtained, which is provably optimal for decision tree algorithms. The differing bounds have a natured explanation in terms of concavity properties of the splitting criterion. The primary contribution of this work is in proving that some popular and empirically successful heuristics that are base on first principles meet the criteria of an independently motivated theoretical model.

The Buffer Tree: A New Technique for Optimal I/O Algorithms

Abstract: In this paper we develop a technique for transforming an internal-memory tree data structure into an external-memory structure. We show how the technique can be used to develop a search tree like structure, a priority queue, a (one-dimensional) range tree and a segment tree, and give examples of how these structures can be used to develop efficient I/O algorithms. All our algorithms are either extremely simple or straightforward generalizations of known internal-memory algorithms - given the developed external data structures. We believe that algorithms relying on the developed structure will be of practical interest due to relatively small constants in the asymptotic bounds.

Improved limited discrepancy search

Abstract: We present an improvement to Harvey and Ginsberg's limited discrepancy search algorithm, which eliminates much of the redundancy in the original, by generating each path from the root to the maximum search depth only once. For a complete binary tree of depth d, this reduces the asymptotic complexity from O(d+2/2 2d) to O(2d). The savings is much less in a partial tree search, or in a heavily pruned tree. The overhead of the improved algorithm on a complete b-ary tree is only a factor of b/(b - 1) compared to depth-first search. While this constant factor is greater on a heavily pruned tree, this improvement makes limited discrepancy search a viable alternative to depth-first search, whenever the entire tree may not be searched. Finally, we present both positive and negative empirical results on the utility oflimited discrepancy search, for the problem of number partitioning.

Optimal isosurface extraction from irregular volume data

Abstract: A method is proposed which supports the extraction of isosurfaces from irregular volume data, represented by tetrahedral decomposition, in optimal time. The method is based on a data structure called interval tree, which encodes a set of intervals on the real line, and supports efficient retrieval of all intervals containing a given value. Each cell in the volume data is associated with an interval bounded by the extreme values of the field in the cell. All cells intersected by a given isosurface are extracted in O(m+log h) time, with m the output size and h the number of different extreme values (min or max). The implementation of the method is simple. Tests have shown that its practical performance reflects the theoretical optimality.

Efficient External-Memory Data Structures and Applications

Abstract: In this thesis we study the Input/Output (I/O) complexity of large-scale problems arising e.g. in the areas of database systems, geographic information systems, VLSI design systems and computer graphics, and design I/O-efficient algorithms for them. A general theme in our work is to design I/O-efficient algorithms through the design of I/O-efficient data structures. One of our philosophies is to try to isolate all the I/O specific parts of an algorithm in the data structures, that is, to try to design I/O algorithms from internal memory algorithms by exchanging the data structures used in internal memory with their external memory counterparts. The results in the thesis include a technique for transforming an internal memory tree data structure into an external data structure which can be used in a batched dynamic setting, that is, a setting where we for example do not require that the result of a search operation is returned immediately. Using this technique we develop batched dynamic external versions of the (one-dimensional) range-tree and the segment-tree and we develop an external priority queue. Following our general philosophy we show how these structures can be used in standard internal memory sorting algorithms and algorithms for problems involving geometric objects. The latter has applications to VLSI design. Using the priority queue we improve upon known I/O algorithms for fundamental graph problems, and develop new efficient algorithms for the graph-related problem of ordered binary-decision diagram manipulation. Ordered binary-decision diagrams are the state-ofthe-art data structure for boolean function manipulation and they are extensively used in large-scale applications like logic circuit verification. Combining our batched dynamic segment tree with the novel technique of externalmemory fractional cascading we develop I/O-efficient algorithms for a large number of geometric problems involving line segments in the plane, with applications to geographic informations systems. Such systems frequently handle huge amounts of spatial data and thus they require good use of external-memory techniques. We also manage to use the ideas in the batched dynamic segment tree to develop “on-line” external data structures for a special case of two-dimensional range searching with applications to databases and constraint logic programming. We develop an on-line external version of the segment tree, which improves upon the previously best known such structure, and an optimal on-line external version of the interval tree. The last result settles an important open problem in databases and I/O algorithms. In order to develop these structure we use a novel balancing technique for search trees which can be regarded as weight-balancing of B-trees. Finally, we develop a technique for transforming internal memory lower bounds to lower bounds in the I/O model, and we prove that our new ordered binary-decision diagram manipulation algorithms are asymptotically optimal among a class of algorithms that include all know manipulation algorithms.

A Kolmogorov-Smirnoff Metric for Decision Tree Induction

Abstract: In 1977, Friedman demonstrated that Kolmogorov-Smirnoff distance could be employed effectively as a test selection metric for decision tree induction. We revisit this metric and modify it to handle multiple classes within a single tree, and to be sensitive to missing data values. Empirical results for a large sample of learning tasks, comparing this metric to the gain ratio metric, show a highly significant reduction in tree size and expected number of tests for classification, without a significant change in classification accuracy.

The suffix Tree of a Tree and Minimizing Sequential Transducers

Abstract: This paper gives a linear-time algorithm for the construction of the suffix tree of a tree. The suffix tree of a tree is used to obtain an efficient algorithm for the minimization of sequential transducers.

Accuracy of neighbor joining for n-taxon trees

Abstract: A Monte Carlo approach was used to estimate the accuracy of a given tree reconstruc- tion method for any number of taxa. In this procedure, we sampled randomly over all possible bifurcating trees assigning substitution rates (branch lengths) to each edge from an exponential distribution to obtain a biologically sensible maximal observed distance. Three different sets of trees were studied: the unrestricted tree space, the biologically meaningful tree space as intro- duced by Nei et al. (1995, Science 267:253-254), and the population data tree space. We used this technique to elucidate the performance of neighbor joining as a function of the number of taxa, assuming that distances are uncorrected and sequences evolve according to the Jukes-Cantor model. The accuracy of neighbor joining decreases almost exponentially with the number of taxa. However, the rate of decrease depends on the tree space studied. Although the accuracy decreases towards zero, the similarity, i.e., the number of partitions that are identical between model tree and reconstructed tree, is in all cases studied much higher than the value expected for two ran- domly chosen trees. Although the probability of recovering the true tree is dramatically influenced by sequence length, the average similarity does not decrease substantially if branch lengths are not too short. (Assigning edge lengths; Felsenstein zone; finite sequence length; Jukes-Cantor model; Monte Carlo sampling; neighbor joining.) A great deal of work has been put into studies on the accuracy of tree reconstruc- tion methods based on DNA or amino acid sequences, where accuracy is understood as the ability of a reconstruction method to recover the true branching pattern (to- pology) of the underlying tree from a giv- en data set. If one wants to understand the accuracy of various tree building methods, in principle, one has to consider the whole space of trees, i.e., all possible topologies with all possible assignments of edge lengths. More formally, let T n be the set of all nondegenerate binary trees with n leaves (taxa, species, sequences). The size of Tn rapidly increases with n, and the number of trees \Tn\ = 1-3-5- .. . -(2n — 5). Each tree T eTn has exactly 2n - 3 branch- es, and each branch is assigned a number of substitutions between zero and infinity. We denote with T n the space of all differ- ent tree topologies plus assignments of edge lengths. If one wants to understand the behavior of a tree reconstruction meth- od for a given evolutionary model, one therefore ought to study the entire space T n or an appropriately defined region thereof.

Tree data structures for N-body simulation

Abstract: In this paper, we study data structures for use in N-body simulation. We concentrate on the spatial decomposition tree used in particle-cluster force evaluation algorithms such as the Barnes-Hut algorithm. We prove that a k-d tree is asymptotically inferior to a spatially balanced tree. We show that the worst case complexity of the force evaluation algorithm using a k-d tree is /spl Theta/(nlog/sup 3/nlogL) compared with /spl Theta/(nlogL) for an oct-tree. (L is the separation ratio of the set of points.) We also investigate improving the constant factor of the algorithm, and present several methods which improve over the standard oct-tree decomposition. Finally, we consider whether or not the bounding box of a point set should be "tight", and show that it is only safe to use tight bounding boxes for binary decompositions. The results are all directly applicable to practical implementations of N-body algorithms.

Efficient lossless compression of trees and graphs

Abstract: Summary form only given, as follows. Data compression algorithms have been widely used in many areas to meet the demand of storage and transfer of large size data. Most of the data compression algorithms regard the input as a sequence of binary numbers and represent the compressed data also as a binary sequence. However, in many areas such as programming languages (e.g. LISP and C) and compiler design, it is more desirable to have a compression algorithm which compresses a data structure while keeping a similar structure of the original data in the compressed form. In addition to reducing storage space, such compression also has the benefit of efficiently executing various operations (e.g. searching) in the compressed form. We study the problem of compressing a non-binary data structure (e.g. tree, undirected and directed graphs) in an efficient way while keeping a similar structure in the compressed form. To date, there has been no proven optimal algorithm for this problem. We use the idea of building LZW tree in LZW compression to compress a binary tree generated by a stationary ergodic source. The tree is parsed into subtrees using breadth first search and an optimal dictionary is constructed with each index pointing to a distinct subtree. We replace the parsed subtrees by dictionary indices to formed the compressed tree. We also extend our tree compression algorithm to compress undirected and directed acyclic graphs.

Balanced spanning trees in complete and incomplete star graphs

Abstract: Efficiently solving the personalized broadcast problem in an interconnection network typically relies on finding an appropriate spanning tree in the network. In this paper, we show how to construct in a complete star graph an asymptotically balanced spanning tree, and in an incomplete star graph a near-balanced spanning tree. In both cases, the tree is shown to have the minimum height. In the literature, this problem has only been considered for the complete star graph, and the constructed tree is about 4/3 times taller than the one proposed in this paper.

Generating t -ary trees in parallel

Abstract: We present a cost-optimal parallel algorithm for generating t-ary trees. Using a known inversion table representation, our algorithm generates all tree sequences in lexicographic order. It uses a linear array of n processors (where n is the number of nodes in the tree), each having a constant number of registers (each storing an integer of size at most tn), and each being responsible for producing one element of a given tree sequence.

Geometric tree matching with applications to 3D lung structures

Abstract: We provide an ejjicient algorithm for the rooted binary tree isomorphism problem under the operation of graph minors (restricted version). This arwes as a result of corresponding lung volumes during different phases of breathing and in comparing normal and diseased lungs. Given two rooted binary trees T1 = (Vl, El, WI ) and T2 = (V., E2, W2 ) (W’I, W2 correspond to 3’D coordinates WI, W2 : V– > R3) as inputs, we want to obtain a oneto-one matching function f of nodes in T1 to T2 such that the edges emanating from V1 in TI map to edgedisjoint paths emanating from f(vl ) in T2. In addition to this topology match, WI and W2 are used to closely match the geometric properties of these trees i.e. the Euclidean proximity of mapped nodes, similar values m edge lengths and angles between adjacent edges. In general, nodes in Tz can be viewed as a non-uniform displacement (spheres of varying radii) of nodes in T1. If we consider only the topology match of TI and Tz (i, e. mapping edges of TI to edge-disjoint paths in T2 without considering WI and W2), we provide a O(IV1 I * IV2 I) dynamzc programming solution to the existence of function f. This is equivalent to checking if TI and T2 are isomorphic under graph minors. Since there could exist exponential number of distinct trees of T2 that can be reduced to TI under graph minors, we reduce this search space by incorporating the geometric constraints into our matching algorithm. T1 and T2 are computed by a twopass central axis algorithm on lung volumes.

Descendants in heap ordered trees or a triumph of computer algebra

Abstract: A heap ordered tree with n nodes (\size n") is a planted plane tree together with a bijection from the nodes to the set f1;:::;ng which is monotonically increasing when going from the root to the leaves. We consider the number of descendants of the node j in a (random) heap ordered tree of size n j. Precise expressions are derived for the probability distribution and all (factorial) moments. AMS Subject Classication. 05A15 (primary) 05C05 (secondary)

An efficient index structure for spatial databases

Abstract: In this paper, the authors propose an efficient spatial data structure called the Multi-R tree. The Multi-R tree is an improvement of the R-tree, R+-tree and R*-tree, and can be used as an index structure for spatial databases. The Multi- R tree improves performance by distributing spatial objects into several data spaces instead of one data space in the Rtree, the R+-tree or the R*-tree. Each data space is associated with a tree in the Multi-R tree. The structure of the Multi-R tree eliminates the node redundancy which appears in the R+-tree at leaf level and keeps disjoint intermediate rectangles. A set of new algorithms for the Multi-R tree is also proposed and implemented. Three popular spatial data structures, the R-tree, R+-tree and R*-tree, are implemented based on the algorithms given in original literature to be compared with the Multi-R tree. An experimental performance analysis for four implemented structures is given with various types of testing data sets: random data, uniformly distributed data, VLSI layout data and TIGER/Line file. Namely, the number of disk accesses and actual response time for each of those four data structures to process a query are compared. Construction times, space utilization and actual memory sizes of the four data structures are also given. Results show that the Multi-R tree requires fewer disk accesses and less processing time than the R-tree, R+-tree and the R*-tree do for a deletion operation and answering a range query in most cases except for a point query or a range query with very small size. In the cases of a point query or small size query processing, the performance of the Multi-R tree is still better than the performances of the Rtree and R*-tree but slightly worse than the R+-tree. Thus, the Multi-R tree may be used as an efficient index structure for spatial databases, e.g., geographical information system, CAD, and VLSI etc.

Cost-radius balanced spanning/Steiner trees

Abstract: The most crucial factor that degrades a high speed VLSI is the signal propagation delay in a routing tree. It is estimated additively by the amount of the source-to-sink path length and total length. To design a routing tree in which these two are balancingly small, we propose an algorithm to construct a spanning tree, by which a tree is constructed in a hybrid way of the Minimum-Tree and Shortest-Path Tree algorithms. The idea is extended to finding such a rectilinear Steiner tree. Experiments are given to show how the source-to-sink path length and total length are balanced and small.

Method and device for generating constructive solid geometry display of plural bodies

Abstract: PROBLEM TO BE SOLVED: To easily and automatically convert a voxel display of a surface or body to a CSG(constructive solid geometry) display of a body by optimizing a new CSG tree as to respective bodies and replacing one CSG tree with the new CSG tree SOLUTION: Data regarding a body are stored in a memory 30 and compared with the CSG structure that the system generates A central processor 20 executes a specific process with the relation with the stored body data In this case, a starting group is generated and then respective trees are optimized and evaluated; and a tree which is selected at random is deformed at random, locally optimized, and evaluated When the deformed tree is better than the existing tree, the deformed tree replaces the original tree For reseeding, the trees are classified by their scores and a half of a tree which has a wrong score is replaced with a tree which has a good score COPYRIGHT: (C)1997,JPO

Binary tree structure with end of path flags stored with path arc's

Abstract: Arrangement of fields in binary tree nodes provides a minimal storage encoding storing fixed and variable length keys in factored form in a multilevel tree. A locating method, and apparatus embodying that method, directed by an argument key, which may or may not be stored in the tree, traces a path following arcs upward or downward between nodes in said binary tree, starting from the top node or any other node, until it finds either the argument key or the delta arc where said argument key would be inserted into said tree. The novel binary tree encoding also provides for path tracing starting at a data backpointer field, which allows accessing of neighboring data entries in collating sequence order.

Geometric analysis of dynamic three-dimensional tree structures

Abstract: Three-dimensional (3-D) tree structures occur in human anatomy as pulmonary trees in the lung, coronary arterial trees in the heart, and cerebral vascular trees in the brain. Geometric measurements such as branch angles, branch lengths, branch points and branch cross-sectional area of these tree volumes are clinically essential to evaluate the function of normal and diseased states. In case of lungs, one needs to match these dynamically varying tree volumes which change in branch topology and geometry during breathing, in order to assess the relative change in measurements. This thesis focuses on the geometric analysis of lung tree structures. It provides algorithms to segment them, computes geometric measurements on segmented tree volumes, and provides algorithms that match two similar tree volumes. This thesis provides automated algorithms to segment the 3-D airway and vascular trees in the lung using tools from mathematical morphology. Size and shape-based morphological operators and a priori geometric knowledge of lung trees is used to segment them. These algorithms have been adapted to segment cerebral arterial trees. To facilitate geometric measurements, the segmented tree volume is reduced to a 3-D Central Axis Tree, using a central axis algorithm. The branch topology is obtained using 3-D region growing techniques. At each branch bifurcation, the 3-D branch point and three direction vectors that best approximate the branch axes are computed using a non-linear optimization formulation. The computed measurements were verified on 3-D tree models that simulate lung tree volumes. Since corresponding two tree volumes is cumbersome, geometric tree matching algorithms that match their central axis trees are presented. In the rooted binary tree topology match, a new $O(\vert V\sb1\vert\ \*\ \vert V\sb2\vert)$ dynamic programming algorithm that matches edges in tree $T\sb1$ = ($V\sb1, E\sb1)$ to edge-disjoint paths in tree $T\sb2$ = ($V\sb2, E\sb2)$ was developed, wherein, $T\sb1$ and $T\sb2$ are central axis trees obtained from contracted and expanded lung volumes respectively. By incorporating geometric constraint, such as, branch point proximity with the topology match, robust matching algorithm was obtained. In case of rooted general tree topology match, a $O(\vert V\sb1\vert\ \*\ \vert V\sb2\vert\sp{1.5})$ algorithm was designed. The results of segmentation, central axis and matching algorithms are discussed on volumetric images of a dog lung, obtained by Computed Tomography.

Parallel construction of binary trees with near optimal weighted path length

Abstract: We present parallel algorithms to construct binary trees with almost optimal weighted path length Specifically, assuming that weights are normalized (to sum up to one) and error refers to the (absolute) difference between the weighted path length of a given tree and the optimal tree with the same weights, we present anO (logn)-time andn(log lognl logn)-EREW-processor algorithm which constructs a tree with error less than 018, andO (k logn log*n)-time andn-CREW-processor algorithm which produces a tree with error at most l/nk, and anO (k2 logn)-time andn2-CREW-processor algorithm which produces a tree with error at most l/nk As well, we describe two sequential algorithms, anO(kn)-time algorithm which produces a tree with error at most l/nk, and anO(kn)-time algorithm which produces a tree with error at most $$1/2^{n2^k }$$ The last two algorithms use different computation models

A tree matching chip

Abstract: Tree matching is an important problem used for 3D object recognition in image understanding and vision systems. It is also used in the design of on-line interpreter systems as well as code optimization in compilers. The objective of tree matching is to find the set of nodes at which a pattern tree matches a subject tree. Recently, two linear systolic array algorithms have been proposed by the authors. In this paper, we propose an improved approach wherein the the systolic algorithm is based on a linear array of fixed size independent of the problem size and larger strings are partitioned and processed based on the array size. Also, the architecture is simplified by moving the logic for processing variables in each PE to a single PE attached at the end. The systolic algorithm and architecture have been verified through simulation using the Cadence design tools.

An average case analysis of a greedy algorithm for the on-line Steiner tree problem

Abstract: This paper gives the average distance analysis for the Euclidean tree constructed by a simple greedy but efficient algorithm of the on-line Steiner tree problem. The algorithm accepts the data one by one following the order of input sequence. When a point arrives, the algorithm adds the shortest edge, between the new point and the points arriving already, to the previously constructed tree to form a new tree. We first show that, given n points uniformly on a unit disk in the plane, the expected Euclidean distance between a point and its j th (1 ≤ j ≤ n − 1) nearest neighbor is less than or equal to ( 5 3 )√ j n when n is large. Based upon this result, we show that the expected length of the tree constructed by the on-line algorithm is not greater than 4.34 times the expected length of the minimum Steiner tree when the number of input points is large.

A new method for updating and rebalancing tree-type main memory dictionaries

Abstract: The most important methods for balancing search trees are periodical rebuilding of the whole tree, which takes Ω(N) time, and rebalancing the tree during each update operation, in O(logN) time. Recently, a new method called relaxed balancing has been proposed in which balancing and updates are uncoupled. Updates only leave balance information in the tree, thus enabling rebalancing later. In this paper, new algorithms for updating and rebalancing the tree, based on using the relaxed balance information, are given. It is shown that if M updates are performed in a red-black tree with N keys, the tree can be rebalanced in O(M log (N + M)) time. If the tree is originally empty, the rebalancing is performed in O(M) time.