Showing papers in "Nordic Journal of Computing in 1998"

Partitioning graphs into generalized dominating sets

Abstract: We study the computational complexity of partitioning the vertices of a graph into generalized dominating sets. Generalized dominating sets are parameterized by two sets of nonnegative integers σ and ρ which constrain the neighborhood N(υ) of vertices. A set S of vertices of a graph is said to be a (σ, ρ)-set if ∀υ ∈ S : |N(υ) ∩ S| ∈ σ and ∀υ n ∈ S : |N(υ) ∩ S| ∈ ρ. The (k, σ, ρ)-partition problem asks for the existence of a partition V1, V2, ..., Vk of vertices of a given graph G such that Vi, i = 1, 2, ...,k is a (σ, ρ)-set of G. We study the computational complexity of this problem as the parameters σ, ρ and k vary.

Propagating differences: an efficient new fixpoint algorithm for distributive constraint systems

Abstract: Integrating semi-naive fixpoint iteration from deductive data bases [3, 2, 4] as well as continuations into worklist-based solvers, we derive a new application independent local fixpoint algorithm for distributive constraint systems. Seemingly different efficient algorithms for abstract interpretation like those for linear constant propagation for imperative languages [16] as well as for control-flow analysis for functional languages [12] turn out to be instances of our scheme. Besides this systematizing contribution we also derive a new efficient algorithm for abstract OLDT-resolution as considered in [14, 15, 24] for Prolog.

Higher-order value flow graphs

Abstract: The concepts of value and control flow graphs are important for program analysis of imperative programs. An imperative value flow graph can be constructed by a single pass over the program text. No similar concepts exist for higher-order languages: we propose a method for constructing value flow graphs for typed higher-order functional languages. A higher-order value flow graph is constructed by a single pass over an explicitly typed program. By using standard methods, single-source and single-use value flow problems can be answered in linear time and all-sources-all-uses can be answered in quadratic time (in the size of the flow graph, which is equivalent to the size of the explicitly typed program). On simply typed programs, the precision of the resulting analysis is equivalent to closure analysis. In practice, it is a reasonable assumption that typed programs are only bigger than their untyped equivalent by a constant factor, hence this is an asymptotic improvement over previous algorithms.We extend the analysis to handle polymorphism, sum types and recursive types. As a consequence, the analysis can handle (explicit) dynamically typed programs. The analysis is polyvariant for polymorphic definitions.

Computing a threaded quadtree from the Delaunay triangulation in linear time

Abstract: The quadtree in this paper is a variant in which two nodes are threaded (linked) if they represent equal-sized squares that are sufficiently close to each other. Given the Delaunay triangulation, it is shown that the threaded quadtree can be computed in linear time and space. It is also described how the threaded quadtree can be used to answer certain types of non-trivial range queries in constant time per query, which has applications, for example, in computing the greedy triangulation, the complete linkage clustering, and a constant-factor approximation of minimum weight triangulation. These queries ask for links to and information concerning the contents of growing ranges, including values of functions based on these contents.

Analysis of linear hashing revisited

Abstract: In this paper we characterize several expansion techniques used for linear hashing and we present how to analyze any linear hashing technique that expands based on local events or that mixes local events and global conditions. As an example we give a very simple randomized expansion technique, which is easy to analyze and implement. Furthermore, we obtain the analysis of the original hashing technique devised by Litwin, which was unsolved until now, comparing it to the later and more widely used version of Larson's. We also analyze one hybrid technique. Among other results, it is shown that the control function used by Litwin does not produce a good storage utilization, matching known experimental data.

On the Euclidean 3-matching problem

Abstract: In the 3-matching problem (3MP) we want to partition a set of n = 3l points into l disjoint subsets, each consisting of three points (called triplets), and to minimize the total cost of the triplets The problem is related to the well-known weighted 2-matching, 3-dimensional assignment and p-median problems We consider a Euclidean 3MP (E3MP) where the cost cijk of a triplet (i, j, k) is the sum of the lengths of the two shortest edges of the triangle (i, j, k) The problem has several related applications in the optimization of manufacturing operationsWe show that the general 3MP is NP-complete and give several methods to calculate lower bounds for the E3MP The exact solution by branch-and-bound technique is possible for small instances For large problem instances we have to apply approximative solution algorithms Local search-based heuristics augmented with ideas from tabu-search, simulated annealing and genetic algorithms worked well in our tests

Bounded fan-out multimessage multicasting

Abstract: We consider Multimessage Multicasting over the n processor complete (or fully connected) static network (MMc). We present a fast approximation algorithm with an improved approximation bound for problem instances with small fan-out (maximum number of processors receiving any given message), but arbitrary degree d, where d is the maximum number of messages that each processor may send or receive. These problem instances are the ones that arise in practice, since the fan-out restriction is imposed by the applications and the number of processors available in commercial systems.Our algorithm is centralized and requires all the communication information ahead of time. Applications where this information is available include iterative algorithms for solving linear equations and most dynamic programming procedures. The Meiko CS-2 machine as well as other computer systems whose processors communicate via dynamic networks will also benefit from our results at the expense of doubling the number of communication phases.

On introducing higher order functions in ABEL

Abstract: We discuss how the 1'st order specification and programming language ABEL could be extended with higher order functions. Several issues arise, related to subtyping, parameterization, strictness of generators and defined functions, and to the choice between lambda expressions and currying. The paper can be regarded as an exercise in language design: how to introduce higher order functions under the restrictions enforced by (1'st order) ABEL. A technical result is a soundness proof for covariant subtype replacement, useful when implementing data types under volume constraints imposed by computer hardware.

The power- p Steiner tree problem

Abstract: This paper introduces the power-p Steiner tree problem, which is to find a geometric Steiner tree that minimizes the sum of the edge lengths each raised to the p power. A number of results are presented on computing optimal and approximate power-p Steiner trees. Specifically, a linear-time numerical algorithm is presented for computing optimal Euclidean power-2 Steiner trees with respect to a given topology, and the algorithm is proved to be numerically stable. It is conjectured, and strong evidence given, that the power-p Steiner tree problem is not finitely solvable for p ≥ 5. Finally, bounds are given on the power-p Steiner ratio, which measures the quality of a minimum spanning tree as an approximation of an optimal power-p Steiner tree.

Subtyping and constructive specification

Abstract: The use of subtyping is explored in the context of a style of constructive specification. The intention is to enhance expressiveness and strengthen syntactic controls. The resulting specification style is part of a wide spectrum language, ABEL, developed at the Oslo University. A concept of signature completeness is presented, as well as a completion algorithm. Some results relating to weak, strong, and optimal typing are proved.

Building a bridge between pointer aliases and program dependences

Abstract: In this paper we present a surprisingly simple reduction of the program dependence problem to the may-alias problem. While both problems are undecidable, providing a reduction between them has great practical importance. Program dependence information is used extensively in compiler optimizations, automatic program parallelizations, code scheduling for super-scale machines, and software engineering tools such as code slicers. When working with languages that support pointers and references, these systems are forced to make very conservative assumptions. This leads to many superfluous program dependences and limits compiler performance and the usability of software engineering tools. Fortunately, there are many algorithms for computing conservative approximations to the may-alias problem. The reduction has the important property of always computing conservative program dependences when used with a conservative may-alias algorithm. We believe that the simplicity of the reduction and the fact that it takes linear time may make it practical for realistic applications.

Higher-order value flow graphs

Abstract: The concepts of value and control flow graphs are important for program analysis of imperative programs. An imperative value flow graph can be constructed by a single pass over the program text. No...

Source-to-source translation of visual languages

Abstract: In this paper we study the problem of translation between visual languages. Languages with a visual syntax are currently in wide use, due to the popularity of different kinds of diagrams used especially in software analysis, design, and animation. Unlike conventional textual languages, visual languages are still quite immature with regard to the formalisms for their specification and automatic implementation. As a consequence, the current diagram editors are usually implemented with ad hoc solutions on a weak methodological foundation. This makes it hard to develop sophisticated diagram manipulators, such as meaning-preserving transformators between two different styles of diagrams. To overcome this problem, we present a solid method for the transformation between diagrams, or more generally, for the source-to-source translation between two visual languages. The method is based on a mapping between atomic relational grammars for the two languages, and on considering translation as a parse tree transformation process. We also present the underlying technique of producing a parse tree for a visual language specified with an atomic relational grammar.

Parametric permutation routing via matchings

Abstract: The problem of routing permutations on graphs via matchings is considered, and we present a general algorithm which can be parameterized by different heuristics This leads to a framework which makes the analysis simple and local

On the communication complexity of strong time-optimal distributed algorithms

Abstract: In this paper we introduce the notion of time optimality in the strong sense and we investigate the communication complexity of strong time-optimal distributed algorithms. We show that a strong time-optimal algorithm solving the MST problem on networks with n nodes and m links interchanges at least (m-n)2 messages. We also present an Θ(m2) bound on communication complexity for strong time-optimal algorithms solving the gossip problem. As a consequence, similar results can be shown for other interesting problems on arbitrary networks, such as electing a leader, determining the median and the center, computing the diameter and others.