IV.6 - MAINTAINING WINGED-EDGE MODELS

Halfedge data structures (HDS) are fundamental in representing combinatorial geometric structures, useful for representing any planar structures such as plane graphs and planar maps, polyhedral surfaces and boundary representations (BREPs), two-dimensional views of a three dimensional scene, etc. Many variants have been proposed in the literature, starting with the winged-edge data structure of Baumgart[2], the DCEL of [15,9], the quad-edge data structure [11], the halfedge data structure [18,12, and refs. therein]. They have been proposed in various frameworks (references too many to give here): Plane structures: including planar maps for GIS, 2D Boolean modeling, 2D graphics, scienti.c computations, computer vision. The requirements on HDS are that that some edges may be in.nite (e.g., Voronoi diagrams), or border edges (e.g., for bounded polygonal domains), it may include holes in the facets (planar maps), and that if so, one of the connected boundary cycle is distinguished as the outer boundary (the others are inner holes). Boundary representation of three-dimensional solids: including Brep representation, solid modeling, polyhedral surfaces, 3D graphics. The requirements here vary slightly: holes may still be allowed, but there is no need to distinguish an outer boundary, in.nite edges are not always useful but border edges might need to be allowed.

To leverage modern hardware platforms to their fullest, more and more database systems embrace compilation of query plans to native code. In the research community, there is an ongoing debate about the best way to architect such query compilers. This is perceived to be a difficult task, requiring techniques fundamentally different from traditional interpreted query execution. In this dissertation, we contribute to this discussion by drawing attention to an old but underappreciated idea known as Futamura projections, which fundamentally link interpreters and compilers. Guided by this idea, we demonstrate that efficient query compilation can actually be very simple, using techniques that are no more difficult than writing a query interpreter in a high-level language. We first develop LB2: a high-level query compiler implemented in this style that is competitive with the best compiled query engines both in sequential and parallel execution on the standard TPC-H benchmark. Query engines process a variety of data types and structures including text, spatial, graphs, etc. Several spatial and graph engines are implemented as extensions to relational query engines to leverage optimized memory, storage, and evaluation. Still, the performance of these extensions is often stymied by the interpretive nature of the underlying data management, generic data structures, and the need to execute domain-specific external libraries. On that basis, compiling spatial and graph queries to native code is a desirable avenue to mitigate existing limitations and improve performance. To support compiling spatial queries, we extend the LB2 main-memory query compiler with spatial predicates, indexing structures, and spatial operators. To support compiling graph queries, we extend LB2 with graph data structures and operators. The spatial extension matches the performance of hand-written code and outperforms relational query engines and map-reduce extensions. Similarly, the graph extension matches, and sometimes outperforms, low-level graph engines.

This paper introduces data structures as applied to computer graphics. Design criteria for computer graphics data structures are discussed, followed by a comparison of general-purpose and tailored graphic data structures. A general graphic data structure is introduced as an example of a structure meeting the preceding criteria. The L6language is then examined as a tool for implementing the above data structure, and is compared to a few other language systems.

In recent years, the analysis and evaluation of manufacturing systems’ behaviour and their performance became essential. Discrete event simulation (DES) as a digital enterprise technology is an effective tool both in production related decision support processes and in structure or performance analysis of manufacturing systems. Building a DES model of a manufacturing system is a difficult task and requires special competence. Reducing the efforts spent on draft simulation is the aim of an ongoing research which is presented in the paper. The developed framework simplifies and accelerates the process of model building. A production oriented implementation of the ANSI/ISA-95 standard was used by the proposed modelling methodology to define a generic data structure supporting the creation of models without specific knowledge related to the simulation software applied. The data structure enables the development and application of proprietary simulation engines tailored for specific problems. On the other hand, numerous objective tests containing simulation model validation methods are also announced through a well-described example problem. By this method, several validating key performance indicators (KPIs) were tested, and it was indirectly determined whether the simulation model adequately represents the behaviour of the real system. The automatic simulation model generation in our approach enables using different simulation tools and presented through the examples of both commercial and self-developed software.

This paper contains some first steps towards a theory of complexity in the area of computations on more general data structures. Special structures are studied which show a highly pathological behaviour as regards complexity theory. Then we define what it means for a structure to be well-designed and treat examples of such structures.

Probabilistic modeling of lexicalized grammars is difficult because these grammars exploit complicated data structures, such as typed feature structures. This prevents us from applying common methods of probabilistic modeling in which a complete structure is divided into sub-structures under the assumption of statistical independence among sub-structures. For example, part-of-speech tagging of a sentence is decomposed into tagging of each word, and CFG parsing is split into applications of CFG rules. These methods have relied on the structure of the target problem, namely lattices or trees, and cannot be applied to graph structures including typed feature structures. This article proposes the feature forest model as a solution to the problem of probabilistic modeling of complex data structures including typed feature structures. The feature forest model provides a method for probabilistic modeling without the independence assumption when probabilistic events are represented with feature forests. Feature forests are generic data structures that represent ambiguous trees in a packed forest structure. Feature forest models are maximum entropy models defined over feature forests. A dynamic programming algorithm is proposed for maximum entropy estimation without unpacking feature forests. Thus probabilistic modeling of any data structures is possible when they are represented by feature forests. This article also describes methods for representing HPSG syntactic structures and predicate-argument structures with feature forests. Hence, we describe a complete strategy for developing probabilistic models for HPSG parsing. The effectiveness of the proposed methods is empirically evaluated through parsing experiments on the Penn Treebank, and the promise of applicability to parsing of real-world sentences is discussed.

We propose an abstract data type for freezable data structures. A frozen data structure is immutable. In contrast to general immutable data structures, freezable data structures can be mutated efficiently until they are frozen. Our abstract data type relies on the Carrier-Rider Pattern and information hiding in a module.

Understanding program execution and analyzing algorithm efficiency are essential yet challenging tasks for students and developers. The system provides a multi-panel interface consisting of a code editor, a node-based graphical visualization of execution flow, and a step-by-step textual explanation of program behavior. The proposed system processes the input code only after it is fully written and syntactically correct, ensuring accurate parsing and reliable output. Once validated, the system will identify control structures such as loops, conditional statements, and recursion, and generate a node-based execution graph that illustrates the program flow dynamically. Each node represents a computational step, enabling users to trace execution in a structured and visual manner. In addition, the system incorporates an automated complexity analyzer that determines time complexity (e.g., ) and space complexity (e.g., ) based on detected patterns and nesting levels. The visualizer supports both general Java programs and Data Structures and Algorithms (DSA), making it suitable for educational, debugging, and analytical purposes. Unlike existing tools, the proposed system integrates node-based visualization, real-time execution tracing, and automated complexity analysis in a single platform supporting both general Java programs and DSA problems.

OBDD's are the state-of-the-art data structure for Boolean function manipulation. Basic tasks of Boolean manipulation such as equivalence test, satisfiability test, tautology test and single Boolean synthesis steps can be performed efficiently in terms of fixed ordered OBDD's. The bottleneck of most OBDD-applications is the size of the represented Boolean functions since the total computation merely remains tractable as long as the OBDD-representations remain of reasonable size. Since it is well known that OBDD's are restricted FBDD's (free BDD's, i.e., BDD's that test, on each path, each input variable at most once), and that FBDD-representations are often much more (sometimes even exponentially more) concise than OBDD-representations. We propose to work with a more general FBDD-based data structure. We show that FBDD's of a fixed type provide, similar as OBDD's of a fixed variable ordering, canonical representations of Boolean functions, and that basic tasks of Boolean manipulation can be performed in terms of fixed typed FBDD's similarly efficient as in terms of fixed ordered OBDD's. In order to demonstrate the power of the FBDD-concept we show that the verification of the circuit design for the hidden weighted bit function proposed Bryant can be carried out efficiently in terms of FBDD's while this is, for principal reasons, impossible in terms of OBDD's.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The growing interest in analysis of surgical video through machine learning has led to increased research efforts; however, common methods of annotating video data are lacking. There is a need to establish recommendations on the annotation of surgical video data to enable assessment of algorithms and multi-institutional collaboration. Four working groups were formed from a pool of participants that included clinicians, engineers, and data scientists. The working groups were focused on four themes: (1) temporal models, (2) actions and tasks, (3) tissue characteristics and general anatomy, and (4) software and data structure. A modified Delphi process was utilized to create a consensus survey based on suggested recommendations from each of the working groups. After three Delphi rounds, consensus was reached on recommendations for annotation within each of these domains. A hierarchy for annotation of temporal events in surgery was established. While additional work remains to achieve accepted standards for video annotation in surgery, the consensus recommendations on a general framework for annotation presented here lay the foundation for standardization. This type of framework is critical to enabling diverse datasets, performance benchmarks, and collaboration.

Structural analysis on massively parallel computers

A reference architecture for Engineering Data Control (EDC) in capital plant manufacture

The Integrated tokamak modelling taskforce was set up to provide the European scientific community with simulation tools for preparing and analysing discharges of fusion experiments. We will report on recent progress made on the taskforce project on equilibrium and linear stability. A generic data structure has been devised to describe the geometry of a machine and physical processes in the discharge. This data structure is used to interface all individual analysis program within the taskforce. One of the analysis tools, the equilibrium code EFIT__ITM, based on the EFIT code written by L. L. Lao, has been completely rewritten in order to make it suitable for the ITM. It has algorithm enhancements to increase execution speed, and the ability to treat anisotropic pressure and deviation from axisymmetry. The reconstruction code is now completely independent of the machine description. First results on veriflcation and validation of the new tool are presented.

We study an order-preserving general purpose data structure for binary data, the LPC-trie. The structure is a compressed trie, using both level and path compression. The memory usage is similar to that of a balanced binary search tree, but the expected average depth is smaller. The LPC-trie is well suited to modem language environments with efficient memory allocation and garbage collection. We present an implementation in the Java programming language and show that the structure compares favorably with a balanced binary search tree.

Type classes have been well-established as a powerful tool to write generic algorithms and data structures while escaping vexing limitations of subtyping with respect to extensibility, binary methods, and partial abstractions. Unfortunately, type classes are typically inadequate to express run-time polymorphism and dynamic dispatch, two features considered central to object-oriented systems. This paper explains how to alleviate this problem in Scala. We present existential containers, a form of existential types bounded by type classes rather than types, and explain how to implement them using Scala’s existing features.