ppxscal/embedding_network huggingface dataset:
The number of offspring as strategy parameter in hierarchically organized evolution strategies
Authors: Michael Herdy
Venue: ACM SIGBIO Newsletter (1993)

The evolution strategy, an algorithm imitating the effect of the biological evolution, has already been presented in this journal [B auml;ck92]. The basic algorithm described there uses a single population with a fixed number of parents and offspring. The present paper shows an extended algorithm with a higher imitative level of biological evolution. In this hierarchically organized evolution strategy there exist several populations being in competition with each other. These populations differ from each other by varied strategy parameters. The number of offspring is such a strategy parameter which is different in each population and it is shown that it can be adjusted adaptively with the proposed algorithm.After derivating the theoretical values for the optimal number of offspring for the two exemplary testfunctions hyperplane and hypersphere the simulation results for these testfunctions are shown.
Process and measurement support in SEEs
Authors: Christopher M. Lott
Venue: ACM SIGSOFT Software Engineering Notes (1993)

Software evolution processes are well-known to be difficult to manage. Some software engineering environments (SEEs) can use models of these processes to guide their enaction. A few of these SEEs can additionally collect and use measurement data to guide processes precisely. Measurement-based guidance is intended to improve the manageability of the guided processes. This paper contributes an overview of many process-centered SEEs, with special emphasis on those that support the systematic collection of process, product, and resource data for the purpose of process guidance.
Experiences building the open OODB query optimizer
Authors: José A. Blakeley, William J. McKenna, Goetz Graefe
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

This paper reports our experiences building the query optimizer for TI's Open OODB system. To the best of our knowledge, it is the first working object query optimizer to be based on a complete extensible optimization framework including logical algebra, execution algorithms, property enforcers, logical transformation rules, implementation rules, and selectivity and cost estimation. Our algebra incorporates a new materialize operator with its corresponding logical transformation and implementation rules that enable the optimization of path expressions. Initial experiments on queries obtained from the object query optimization literature demonstrate that our optimizer is able to derive plans that are as efficient as, and often substantially more efficient than, the plans generated by other query optimization strategies. These experiments demonstrate that our initial choices for populating each part of our optimization framework are reasonable. Our experience also shows that having a complete optimization framework is crucial for two reasons. First, it allows the optimizer to discover plans that cannot be revealed by exploring only the alternatives provided by the logical algebra and its transformations. Second, it helps and forces the database system designer to consider all parts of the framework and to maintain a good balance of choices when incorporating a new logical operator, execution algorithm, transformation rule, or implementation rule. The Open OODB query optimizer was constructed using the Volcano Optimizer Generator, demonstrating that this second-generation optimizer generator enables rapid development of efficient and effective query optimizers for non-standard data models and systems.
Text databases: a survey of text models and systems
Authors: Arjan Loeffen
Venue: ACM SIGMOD Record (1994)

Text models focus on the manipulation of textual data. They describe texts by their structure, operations on the texts, and constraints on both structure and operations. In this article common characteristics of machine readable texts in general are outlined. Subsequently, ten text models are introduced. They are described in terms of the datatypes that they support, and the operations defined by these datatypes. Finally, the models are compared.
Improving the performance of runtime parallelization
Authors: Shun-Tak Leung, John Zahorjan
Venue: ACM SIGPLAN Notices (1993)

When the inter-iteration dependency pattern of the iterations of a loop cannot be determined statically, compile time parallelization of the loop is not possible. In these cases, runtime parallelization [8] is the only alternative. The idea is to transform the loop into two code fragements: the inspector and the executor. When the program is run, the inspector examines the iteration dependencies and constructs a parallel schedule. The executor subsequently uses that schedule to carry out the actual computation in parallel. In this paper, we show how to reduce the overhead of running the inspector through its parallel execution. We describe two related approaches. The first, which emphasizes inspector efficiency, achieves nearly linear speedup relative to a sequential execution of the inspector, but produces a schedule that may be less efficient for the executor. The second technique, which emphasizes executor efficiency, does not in general achieve linear speedup of the inspector, but is guaranteed to produce the best achievable schedule. We present these techniques, show that they are correct, and compare their performance to existing techniques using a set of experiments. Because in this paper we are optimizing inspector time, but leaving the executor unchanged, the techniques we present have most dramatic effect when the inspector must be run for each invocation of the source loop. In a companion paper [3], we explore techniques that build upon those developed here to also improve executor performance.
An implementation of multiple modulus arithmetic and its comparison to floating point arithmetic
Authors: T. M. Rao, Lawrence Helber
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

Multiple-modulus arithmetic, which allows error-free computation for rational inputs, is implemented in a software package called ZIP. Experimentation is carried out comparing floating point and multi-mod arithmetic.
Semiboolean SQS-skeins
Authors: Andreas J. Guelzow
Venue: Journal of Algebraic Combinatorics: An International Journal (1993)

We will present a counter example to the conjecture that the class of boolean SQS-skeins is defined by the equation q(x, u, q(y, u, z)) &equals; q(q(x, u, y), u, z ). The SQS-skeins satisfying this equation will be seen to be exactly those SQS-skeins that correspond to Steiner quadruple systems whose derived Steiner triple systems are all projective geometries.
Knowledge-based security control for on-line database transaction processing systems
Authors: V. K. Murthy, E. V. Krishnamurthy
Venue: ACM SIGSAC Review (1994)

This paper considers the interrelationships between knowledge-based security, concurrency and recoverability in online database transaction processing systems (OLTP). We describe how OLTP can permit the users to carry out the desired actions, and concurrently activate scrutinizing transactions that identify the users with respect to their biometrical or other characteristics stored in a secure knowledge database. A finite state machine model is used to design protocols for recovery, under security breaches. It is shown that the best way to achieve concurrency and recovery in OLTP is through shadowing and strict-scheduling in conjunction with certification locking or timestamping. We must, however, bear in mind that security and concurrency have conflicting requirements and at best we can achieve a compromise between them.
Separating stages in the continuation-passing style transformation
Authors: Julia L. Lawall, Olivier Danvy
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

The continuation-passing style (CPS) transformation is powerful but complex. Our thesis is that this transformation is in fact compound, and we set out to stage it. We factor the CPS transformation into several steps, separating aspects in each step: (1) Intermediate values are named; (2) Continuations are introduced; (3) Sequencing order is decided and administrative reductions are performed. Step 1 determines the evaluation order (e.g., call-by-name or call-by-value). Step 2 isolates the introduction of continuations and is expressed with local, structure-preserving rewrite rules &mdash; a novel aspect standing in sharp contrast with the usual CPS transformations. Step 3 determines the ordering of continuations (e.g., left-to-right or right-to-left evaluation) and leads to the familiar-looking continuation-passing terms. Step 2 is completely reversible and Steps 1 and 3 form Galois connections. Together they lead to the direct style (DS) transformation of our earlier work (including first-class continuations): (1) Intermediate continuations are named and sequencing order is abstracted; (2) Second-class continuations are eliminated; (3) Administrative reductions are performed. A subset of these transformations can leverage program manipulation systems: CPS-based compilers can modify sequencing to improve e.g., register allocation; static program analyzers can yield more precise results; and overspecified CPS programs can be rescheduled. Separating aspects of the CPS transformation also enables a new programming style, with applications to nondeterministic programming. As a byproduct, our work also suggests a new continuation semantics for unspecified sequencing orders in programming languages (e.g., Scheme).
Long non-crossing configurations in the plane
Authors: Noga Alon, Sridhar Rajagopalan, Subhash Suri
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

We study some geometric maximization problems in the Euclidean plane under the non-crossing constraint. Given a set V of 2n points in general position in the plane, we investigate the following geometric configurations using straight-line segments and the Euclidean norm: (i) longest non-crossing matching, (ii) longest non-crossing hamiltonian path, (iii) longest non-crossing spanning tree. We propose simple and efficient algorithms to approximate these structures within a constant factor of optimality. Somewhat surprisingly, we also show that our bounds are within a constant factor of optimality even without the non-crossing constraint. For instance, we give an algorithm to compute a non-crossing matching whose total length is at least 2/&pgr; of the longest (possibly crossing) matching, and show that the ratio 2/&pgr; between the non-crossing and crossing matching is the best possible. Perhaps due to their utter simplicity, our methods also seem more general and amenable to applications in other similar contexts.
Drawing compound digraphs and its application to an idea organizer (abstract)
Authors: Kozo Sugiyama
Venue: ACM SIGACT News (1993)

An upward drawing of an acyclic digraph is a planar straight-line drawing with the additional requirement that all the edges flow in the same direction, e.g., from bottom to top. The literature on the problem of constructing upward drawings of important classes of digraphs is surveyed. First, it is show that there is a family of binary trees with n vertices requiring Omega;(nlogn) area for any upward drawing; moreover, that bound is tight, i.e. each binary tree with n vertices can be drawn with O(n logn) area. Second, motivated by the elegant H-tree layout algorithm for constructing non-upward drawings of complete binary trees, an algorithm is presented for constructing an upward drawing of a complete binary tree with n vertices in O(n) area. This result is extended to the drawings of Fibonacci trees. Third, it is shown that the area requirement of upward drawings of series-parallel digraphs crucially depends on the choice of planar embedding. Also, parallel and sequential drawing algorithms are presented that are optimal with respect to both the time complexity and to the area achieved. Several results show that while series-parallel digraphs have a rather simple and well understood combinatorial structure, naive drawing strategies lead to drawings with exponential area, and clever algorithms are needed to achieve optimal area.
Asymptotic performance of a buffer model in a data sharing environment
Authors: Avi Bittan, Yaakov Kogan, Philip S. Yu
Venue: Proceedings of the 1994 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1994)

The performance of a transaction processing system is very sensitive to the buffer hit probability. In a data sharing environment where multiple computing nodes are coupled together with direct access to shared data on disks, buffer coherency needs to be maintained such that if a data granule is updated by a node, the old copies of this granule present in the buffer of other nodes must be invalidated. The buffer invalidation phenomenon reduces the buffer hit probability in a multi-node environment. After the buffer reaches a certain size, the buffer hit probability will remain constant regardless of further increase in buffer size due to the buffer invalidation effect. This puts an upper limit on the achievable buffer hit probability. Thus the selection of appropriate buffer size is one of the critical issues in a data sharing environment. In this paper, we develop an asymptotic analysis of the Markov model for a buffer in the data sharing environment. Important relations between buffer size, number of nodes, write-probability and the size of the database to the buffer hit probability had been found in all range of system parameters. A simple expression is obtained for the maximum achievable buffer hit probability and also for the maximum usable buffer size. Various properties of the maximum achievable buffer hit probability and usable buffer size are derived for a skewed access workload. The accuracy of the asymptotic method is validated by numerous case studies.
Static single assignment for explicitly parallel programs
Authors: Harini Srinivasan, James Hook, Michael Wolfe
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

We describe and prove algorithms to convert programs which use the Parallel Computing Forum Parallel Sections construct into Static Single Assignment (SSA) form. This proces allows compilers to apply classical scalar optimization algorithms to explicitly parallel programs. To do so, we must define what the concept of dominator and dominance frontier mean in parallel programs. We also describe how we extend SSA form to handle parallel updates and still preserve the SSA properties.
A Novel Feature Recognition Neural Network and its Application to Character Recognition
Authors: Basit Hussain, M. R. Kabuka
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1994)

Presents a feature recognition network for pattern recognition that learns the patterns by remembering their different segments. The base algorithm for this network is a Boolean net algorithm that the authors developed during past research. Simulation results show that the network can recognize patterns after significant noise, deformation, translation and even scaling. The network is compared to existing popular networks used for the same purpose, especially the Neocognitron. The network is also analyzed as regards to interconnection complexity and information storage/retrieval.
Using statistical sampling for query optimization in heterogeneous library information systems
Authors: Gregory D. Speegle, Michael J. Donahoo
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

Query optimization in heterogeneous database systems is not always possible since the component DBMS may not have the ability to transmit necessary information. However, these systems need query optimization because the cost of transmitting large quantities of data across diverse databases is very high. We propose a query strategy which uses hypothesis testing to determine which of two sets of data are larger. Our experiments show that this strategy is very likely to select the smaller set when the sampling results fall outside a region of uncertainty we call the &ldquo;grey zone.&rdquo; This provides query optimization without transmission of database statistics.
Parametric Module Allocation on Partial k-Trees
Authors: D. Fernández-Baca, A. Medepalli
Venue: IEEE Transactions on Computers (1993)

The problem of allocating modules to processors in a distributed system to minimize total costs when the underlying communication graph is a partial k-tree and all costs are linear functions of a real parameter t is considered. It is shown that if the number of processors is fixed, the sequence of optimum assignments that are obtained as t varies from zero to infinity can be constructed in polynomial time. As an auxiliary result, a linear time separator algorithm for k-trees is developed. The implications of the results for parametric versions of the weighted vertex cover, independent set, and 0-1 quadratic programming problems on partial k-trees are discussed.
Fast algorithms for generating discrete random variates with changing distributions
Authors: Sanguthevar Rajasekaran, Keith W. Ross
Venue: ACM Transactions on Modeling and Computer Simulation (TOMACS) (1993)

One of the most fundamental operations when simulating a stochastic discrete-event dynamic system is the generation of a nonuniform discrete random variate. The simplest form of this operation can be stated as follows: Generate a random variable X that is distributed over the integers 1,2,&hellip;,n such that P(X=i) = ai/(a1 +&hellip;+an), where ai's are fixed nonnegative numbers. The well-known &ldquo;alias algorithm&rdquo; is available to accomplish this task in O(1) time. A more difficult problem is to generate variates for X when the ai's are changing with time. We present three rejection-based algorithms for this task, and for each algorithm we characterize the performance in terms of acceptance probability and the expected effort to generate a variate. We show that, under fairly unrestrictive conditions, the long-run expected effort is O(1). Applications to Markovian queuing networks are discussed. We also compare the three algorithms with competing schemes appearing in the literature.
Pen computing (abstract): the new frontier
Authors: S. Jerrold Kaplan
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

While all types of computers are ultimately Turing machines, this &ldquo;reduction-and-abstraction&rdquo; obscures the way people actually experience computing. About every 10 years, a new type of machine is invented that changes our understanding of computation. From the mysterious glass house mainframes of the 1960s, ministered by white-coated experts, to today's friendly personal computers, our sense of the role of computing in our lives has undergone a dramatic transformation. The next wave of this evolution is the &ldquo;pen computer.&rdquo; A small group of early pioneers has quietly redefined how most people will experience computation in the future, and refocused what we will do with this power. The pen computer derives its heritage from pen and paper, rather than from the typewriter, as personal computers do. It can be carried and used as a folder or notebook would, rather than as a piece of office equipment in a box. These new social characteristics allow a pen computer to be used in settings where keyboard devices are inappropriate or disruptive. Data is entered by handwriting, sketching, and scribbling, rather than typing, pointing, and clicking. Images are manipulated directly on a visually active surface, rather than remotely. The subjective experience of using a pen computer is unique and utterly personal. This talk will attempt to present the new face that computing will have for future users.
Using genetic algorithms to generate Steiner triple systems
Authors: Stephen J. Hartley, Aaron H. Konstam
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

Steiner systems, particularly triple systems, are usually generated by mathematicians using techniques from the theory of groups and quasi-groups. When pencil-and-paper enumeration becomes infeasible, mathematicians have used computers to carry out exhaustive searches. This paper presents some results of using genetic algorithms, which do not use exhaustive search, to generate Steiner systems. A specialized mutation operator was effective in generating Steiner triple systems. Future research will focus on improving the genetic algorithm to generate higher order Steiner systems whose existence is not currently known.
User involvement in the design process: why, when how?
Authors: C. Dennis Allen, Don Ballman, Vivienne Begg, Harold H. Miller-Jacobs, Michael Muller, Jakob Nielsen, Jared Spool
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

For years the CHI community has championed the importance of the user in system development. As many of us develop systems, we find that the concept of user involvement is not so easy to implement. Does one always strive to involve the user in the design process? Are there situations when the users should not be involved? What if the user is reluctant to change? How is user involvement handled when the user claims to know all the answers and wants to design the entire interface his or her way? What if the users, or even potential users are not available? How can user involvement be accomplished under these developmental restrictions? User Involvement, therefore, may be a goal - not a given, and how to effect user involvement is not as straight forward as the text books convey! To assist the process of user interface development, many techniques have been developed such as Heuristic Evaluation, Participatory Design, Cognitive Walk Throughs, Task Analysis and Rapid Prototyping. These techniques vary considerably in the extent of user involvement that they require. This panel will attempt to match the technique with the degree of user involvement that the developer is faced with or can achieve. The issues discussed in this session are important to the entire user interface community. Developers will be happy to hear that they are not alone; others have similar problems with users. They will learn which of the techniques are best suited for each development situation. Methodologists will gain greater insight into the breadth and depth of working with, and attempting to satisfy various types of users. They may be able to better refine the technologies we now have available to meet the needs of user interface developers. Members of the audience will be invited to participate as developers and methodologists.
A synergistic approach to specifying simple number independent layouts by example
Authors: Scott E. Hudson, Chen-Ning Hsi
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

A grid-based technique to specify simple number independent layouts by example is described. This technique was originally developed to support layout specification for a parallel program visualization system but can be applied to aid other simple graphical layout tasks as well. The technique works by allowing the user to construct an example layout using a grid-based interaction technique. This example can then be generalized into a layout algorithm which can be applied to create layouts of any size. However, rather than simply choosing the &ldquo;best&rdquo; generalization, the system described here takes a synergistic approach. New examples from a set of alternative generalizations are presented to the user so that they can guide and control the generalization process. This provides more understanding and control of the generalization to be constructed from only one small example.