Class Of Data Structures Research Articles

Distributed Finite-Element Analysis on Network of Workstations—Implementation and Applications

The implementation of distributed algorithms for the finite-element analysis of structures developed in a 1995 paper by Adeli and Kumar is presented here. A common class of object-oriented data structures has been developed for generation and display of data distribution among the workstations and interprocess communication scheme. The algorithms presented are robust and versatile and have been applied to analysis of large structures with complicated and unstructured topology. In spite of the high latency and low bandwidth of the ethernet networks, an overall parallelization efficiency in the range of 75–90% is obtained on a cluster of six IBM RS/6000 workstations for large structural models with a few thousand elements. Research suggests that with the emergence of high-speed communication networks, workstation clusters are likely to emerge as an effective alternative to high-performance computing in structural engineering due to their cost/performance advantage over the current generation of supercomputers.

Verifying definite iteration over data structures

Methods are presented for verifying loops which iterate over elements of data structures. This verification is done in the functional style developed by Mills and others, in which code is verified against the function that the code is intended to compute. The methods allow the verifier to concentrate on the essential computation performed on each element of the structure, and separate out such concerns as data-structure access and termination so that they do not need to be verified again for every loop in the program. The methods are applicable to a large class of data structures and iterations over them.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A top-down approach to teaching programming

Programming is traditionally taught using a bottom-up approach, where details of syntax and implementation of data structures are the predominant concepts. The top-down approach proposed focuses instead on understanding the abstractions represented by the classical data structures without regard to their physical implementation. Only after the students are comfortable with the behavior and applications of the major data structures do they learn about their implementations or the basic data types like arrays and pointers that are used. This paper discusses the benefits of such an approach and how it is being used in a Computer Science curriculum.

Search costs in quadtrees and singularity perturbation asymptotics

Quadtrees constitute a classical data structure for storing and accessing collections of points in multidimensional space. It is proved that, in any dimension, the cost of a random search in a randomly grown quadtree has logarithmic mean and variance and is asymptotically ditributed as a normal variable. The limit distribution property extends to quadtrees of all dimensions a result only known so far to hold for binary search trees. The analysis is based on a technique of singularity perturbation that appears to be of some generality. For quadtrees, this technique is applied to linear differential equations satisfied by interventing bivariate generating functions

Inexpensive teaching techniques with rich rewards

A brief report on several teaching techniques that have rewards that far outweigh their costs. Experiences with four techniques are discussed: a "Pause" during lectures, student submission of exam questions, group projects, and a technique for learning students' names. These experiences are largely in the context of a Data Structures class, but are applicable to most lecture-oriented classes.

World-wide algorithm animation

This paper reports on an innovative use of the WWW at the University of Geneva. Indeed, until now, the web has mostly been used to make information publicly available, whether directly in documents, or through search engines querying external databases. With the availability of forms, we are now starting to see WWW viewers used to input information, e.g. to order a pizza or give one's opinion about some topic. In the Computer Science department, as a semester project for the Software Engineering class, we are now implementing an experiment to allow first year students to have not only on-line access to a hypertextual version of the book used in the Data Structures class, but also to “animate” the algorithms that are described in the book. That is, the students can run, on the server, the program (or program segment) and interact with the execution to put breakpoints in the code, display the contents of variables and advance execution either step by step, or until a breakpoint is met, in much the same way as with a symbolic debugger. To do this required the development of a whole set of tools to facilitate, and even automate, the preparation of the algorithms to allow them to be started and controlled from a WWW client like Mosaic. It also required designing a mechanism to have the server spawn subprocesses to execute the algorithms and have the server query the appropriate subprocess for what has to be displayed next, based on the user's queries. This paper will describe the technical solutions that had to be designed to make this remote control feasible. Even though the project described in this paper has educational purposes, many of the solutions described can prove useful in very different contexts.

Distributing a search tree among a growing number of processors

Databases are growing steadily, and distributed computer systems are more and more easily available. This provides an opportunity to satisfy the increasingly tighter efficiency requirements by means of distributed data structures. The design and analysis of these structures under efficiency aspects, however, has not yet been studied sufficiently. To our knowledge, a single scalable, distributed data structure has been proposed so far. It is a distributed variant of linear hashing with uncontrolled splits, and, as a consequence, performs efficiently for data distributions that are close to uniform, but not necessarily for others. In addition, it does not support queries that refer to the linear order of keys, such as nearest neighbor or range queries. We propose a distributed search tree that avoids these problems, since it inherits desirable properties from non-distributed trees. Our experiments show that our structure does indeed combine a guarantee for good storage space utilization with high query efficiency. Nevertheless, we feel that further research in the area of scalable, distributed data structures is dearly needed; it should eventually lead to a body of knowledge that is comparable with the non-distributed, classical data structures field.

Approaching classical algorithms in APL2

Classical algorithms and data structures as made popular by D.E. Knuth's "The Art of Computer Programming" have been largely ignored so far by APL2-programmers. This scepsis was understandable to a certain degree in the era of APL, but has lost its justification with the rise of APL2 and similar APL-successors. First the essence of classical algorithms as well as the principal ways of data structuring and accessing are reexamined. Then it is shown how pseudocodes or implementations of classical algorithms can be transfered one-to-one into APL2 almost automatically and often with an acceptable resulting performance. But, in general, the better way consists in maintaining only the general design principle behind a classical algorithm and combining it with the elegant and efficient specific possibilities of APL2. Both approaches are explained and illustrated by means of a typical classical algorithm from picture processing.

Corner-stitched tiles with curved boundaries (circuit layout)

Two generalizations of the classic corner-stitched data structure for planar polygonal layouts to geometrics including circles or arbitrary curved shapes are introduced and analyzed. Such an extended data structure can be built with just the additional space required to store the more complicated curved boundaries. Alternatively, the definition of the curved shapes may also be based on geometrical area mapping similar to those used in finite-element methods. The tradeoffs between different encoding schemes that minimize either overall data storage needs or the complexity of individual tiles are discussed. The topology of the linkage of tiles by the corner-stitching pointers is equivalent to that of simpler patterns with trapezoidal tiles, but the various tests and operations running on this data structure may become considerably more complicated, and the achievable runtimes will be highly implementation dependent.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Abstract description of pointer data structures

Even though impressive progress has been made in the area of optimizing and parallelizing array-based programs, the application of similar techniques to programs using pointer data structures has remained difficult. Unlike arrays which have a small number of well-defined properties, pointers can be used to implement a wide variety of structures which exhibit a much larger set of properties. The diversity of these structures implies that programs with pointer data structures cannot be effectively analyzed by traditional optimizing and parallelizing compilers.In this paper we present a new approach that leads to the improved analysis and transformation of programs with recursively defined pointer data structures. Our approach is based on a mechanism for the Abstract Description of Data Structures (ADDS). ADDS is a simple extension to existing imperative languages that allows the programmer to explicitly describe the important properties of a large class of data structures. These abstract descriptions may be used by the compiler to achieve more accurate program analysis in the presence of pointers, which in turn enables and improves the application of numerous optimizing and parallelizing transformations. We present ADDS by describing various data structures; we discuss how such descriptions can be used to improve analysis and debugging; and we supply three important transformations enabled by ADDS.

Parsers in ML

We present the operational semantics of streams and stream matching as discussed in. Streams are data structures such as lists, but with different primitive operations. Streams not only provide an interface to usual imput/output channels, but may used as a data structure per se , holding any kind of element. A special pattern matching construct is dedicated to streams and the actual matching process will be called parsing . The primary parsing semantics that we propose here is predictive parsing, i.e. recursive descent semantics with a one token look-ahead: although this choice seems to restrict us to the recognition of LL9(1) languages, we show by examples that full functionality and parameter passing allow us to write parsers for complex languages. The operational semantics of parsers is given by transforming parsers into regular functions. We introduce a non-strict semantics of streams by translating stream expression into more classical data structures; we also investigate different sharing mechanisms for some of the stream operations.

A characterization of heaps and its applications

In this paper we present a new view of a classical data structure, the heap . We view a heap on n elements as an ordered collection of ⌜log 2 ( n + 1)⌝ substructures of sizes 2 i with i in {0, …, ⌈log 2 ( n )⌉}. We use the new view in the design of an algorithm for splitting a heap on n elements into two heaps on k and n − k elements, respectively. The algorithm requires O (log 2 ( n )) comparisons, improving the previous bound of O ( k ) comparisons for all but small values of k , i.e., for k log 2 ( n ). We also present a new and conceptually simple algorithm for merging heaps of sizes n and k into one heap of size n + k in O( log (n) ∗ log (k)) comparisons.

Circular programs and self‐referential structures

AbstractA circular program creates a data structure whose computation depends upon itself or refers to itself. The technique is used to implement the classic data structures circular and doubly‐linked lists, threaded trees and queues, in a functional programming language. These structures are normally thought to require updateable variables found in imperative languages. For example, a functional program to perform the breadth‐first traversal of a tree is given. Some of the examples result in circular data structures when evaluated. Some examples are particularly space‐efficient by avoiding the creation of intermediate temporary structures which would otherwise later become garbage. Lastly, the technique can be applied in an imperative language to give an elegant program.

A class of data structures for 2‐D and 3‐D adaptive mesh refinement

AbstractA ‘family’ of tree data structures for adaptive mesh refinement is described and details concerning the associated logic are provided. The data structures encompass triangular elements and quadrilateral elements in two dimensions and quadrilateral bricks in three dimensions. Furthermore, both linear (bilinear) and quadratic (biquadratic) element types, respectively, are developed. Representative refinement results are given for the bilinear, trilinear and biquadratic types and associated performance studies made for the refinement procedure.

On the dynamization of data structures

In this paper we present a simple dynamization method that preserves the query and storage costs of a static data structure and ensures reasonable update costs. In this method, the majority of data elements are maintained in a single data structure, and the updates are handled using “smaller” auxiliary data structures. We analyze the query, storage, and amortized update costs for the dynamic version of a static data structure in terms of a functionf, such thatf(n)<n, that bounds the sizes of the auxiliary data structures (wheren is the number of elements in the data structure). The conditions onf for minimal (with respect to asymptotic upper bounds) amortized update costs are then obtained. The proposed method is shown to be particularly suited for the cases where the merging of two data structures is more efficient than building the resultant data structure from scratch. Its effectiveness is illustrated by applying it to a class of data structures that have linear merging cost; this class consists of data structures such as Voronoi diagrams, K-d trees, quadtrees, multiple attribute trees, etc.

Should computer science examinations contain “programming” problems?

The purpose of many computer science courses is to enhance the programming skills of the student, including the ability to design and implement appropriate algorithms. In such courses, examinations should therefore contain problems which test for algorithmic skills. In particular, there should be problems which require the student to write small sections of code, usually in the form of a subprogram. Students often perceive these questions as “programming” problems; however, it is more accurate to state that these are algorithmic problems, since such questions primarily measure algorithmic skills. In addition, since such exam problems address topics which are a part of the course content (e.g. stacks, queues, and tables in a data structures class), the student's knowledge of these topics is also tested and reinforced. This paper discusses how examination questions which test algorithmic skills have been implemented in a data structures course at Northeast Louisiana University. Arguments both for and against using such test questions are discussed, as well as the proper format and amount of this type of problem. The results of a survey of data structures students at Northeast concerning this topic is also presented. There has been relatively little discussion on the topic of computer science examinations in the literature. It is hoped that the publication and presentation of this paper will stimulate dialogue in this area among academicians.

An Algorithm for Constructing a Quadtree from Polygonal Regions

AbstractQuadtrees are a class of hierarchical data structures particularly suitable for the representation of images in a compact form. In this paper a new algorithm is described which builds up the quadtree corresponding to polygonal multiply connected regions starting from their boundary representation.

Matching the task to an image processing architecture

Several different computer architectures have been suggested or built to overcome the Von Neumann bottleneck. Particularly in image processing, data structures and algorithm organization may benefit from a good match with the new architectures. Such a match may be defined as the degree of exploitation of the system resources (including time) to obtain the specific solution. A diagram that shows the existing match between classes of machines, data structures, and computational structures is given in this paper. A comparison of the performance of extreme architectures on a limited number of benchmarks, chosen from the most popular IP tasks, concludes this work.

Containment defines a class of recursive data structures

Containment defines a class of recursive data structures

Axioms for multilevel objects

A set of axioms for structured objects of data is presented. In the structured objects components and levels are distinguished. Change of level is the result of a special application operator, components are accessible by successive selections. The set of access paths is also axiomatized. The set of axioms is uniform in the sense that features of various known classes of datastructures are combined.