ppxscal/embedding_network huggingface dataset:
Using linear congruential generators for parallel random number generation
Authors: M. J. Durst
Venue: Proceedings of the 21st conference on Winter simulation (1989)

Linear congruential random number generators are widely used in simulation and Monte Carlo calculations. Because they are very fast, and because they have minimal state space, they remain attractive for use in parallel computing environments. We discuss their use as a source for many streams of pseudo-random numbers. Many authors have discussed splitting the stream of a single CRNG into many substreams; we show spectral calculations for this scheme and compare randomly and regularly spaced selection of starting points. Several authors have suggested using a common multiplier for all streams and a unique additive constant for each. The discrepancies of such schemes are no better than for splitting schemes; we show how they are in a sense equivalent. We also consider the use of distinct multipliers for each stream. Good multipliers are abundant for large enough moduli, but little is known about the multidimensional behavior of such generators. We discuss the use of improvement techniques and larger moduli to overcome the limitations of linear congruential generators.
Speech and gestures for graphic image manipulation
Authors: A. G. Hauptmann
Venue: ACM SIGCHI Bulletin (1989)

An experiment was conducted with people using gestures and speech to manipulate graphic images on a computer screen. A human was substituted for the recognition devices. The analysis showed that people strongly prefer to use both gestures and speech for the graphics manipulation and that they intuitively use multiple hands and multiple fingers in all three dimensions. There was surprising uniformity and simplicity in the gestures and speech. The analysis of these results provides strong encouragement for future development of integrated multi-modal interaction systems.
Principal Warps: Thin-Plate Splines and the Decomposition of Deformations
Authors: F. L. Bookstein
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The decomposition of deformations by principal warps is demonstrated. The method is extended to deal with curving edges between landmarks. This formulation is related to other applications of splines current in computer vision. How they might aid in the extraction of features for analysis, comparison, and diagnosis of biological and medical images in indicated.
Misconceptions About Real-Time Computing: A Serious Problem for Next-Generation Systems
Authors: John A. Stankovic
Venue: Computer (1988)

The author defines real-time computing and states and dispels the most common misconceptions about it. He discusses the fundamental technical issues of real-time computing. He examines specification and verification, scheduling theory, operating systems, programming languages and design methodology, distributed databases, artificial intelligence, fault tolerance, architectures, and communication.
Geographic information systems (GIS) for microcomputers
Authors: Roger Wheate
Venue: ACM SIGUCCS Newsletter (1989)

At The University of Calgary, courses in Geographic Information Systems are offered in the departments of Geography and Surveying Engineering and the Faculty of Environmental Design. In this article. Roger Wheate describes how the development of the microcomputer as a standard has made this technology accessible to a wide body of users and provides details about the software currently available.
An Ethernet compatible low cost/high performance communication solution
Authors: I. Chlamtac, A. Herman
Venue: Proceedings of the ACM workshop on Frontiers in computer communications technology (1987)

The LAN-HUB is a new local area network designed to combine the properties of several existing LAN standards to provide highly reliable communication at a relatively lower cost per station, improve network capacity/delay performance and increase the LAN user's flexibility in configuring his network. The LAN-HUB network is configured around the CODEX 4320 LAN-HUB communication controllers which allow up to eight Ethernet/IEEE 802.3 stations to transparently share one network transceiver or RF Modem. Each LAN-HUB controller executes a fair, collision free, arbitration among its local stations attached to its LAN ports, using a patented collision avoidance algorithm. The HUB's rear panel further provides a Network port which can be attached to a standard 802.3 transceiver, to another HUB or terminated in a loop back mode. The HUBs, thus, allow stations to be organized in a standalone star network, in a &ldquo;cascading&rdquo; star configuration, or as an integrated bus/star network. When organized as star or cascaded star networks, the HUB controllers provide highly reliable and controlled, collision free, bandwidth allocation suitable for applications such as CPU room clusters. Alternately, in a bus configuration the HUBs support an Ethernet type bus network, with random access channel control. In the latter configuration the HUBs provide a lower cost/higher performance solution for bursty traffic users, since they reduce cabling requirements, decrease cost by sharing each transceiver among several LAN stations and improve network throughput/delay performance by eliminating local collisions. The LAN-HUB is thus effective in creating a local communication solution with a significant degree of flexibility in choosing the network layout and the type of service, random or deterministic, provided to the network users.
K-Way Bitonic Sort
Authors: T. Nakatani, S.-T. Huang, B. W. Arden, S. K. Tripathi
Venue: IEEE Transactions on Computers (1989)

The k-way bitonic sort algorithm, a generalization of K.E. Batcher's bitonic sort algorithm (1968), is presented. This variation of the algorithm is based on a k-way decomposition instead of a two-way decomposition. It is proven that Batcher's bitonic sequence decomposition theorem still holds with this multiway decomposition. This leads to applications of sorting networks with bitonic sorters of arbitrary or mixed sizes.
An Entity-Relationship Programming Language
Authors: A. Malhotra, H. M. Markowitz, Y. Tsalalikhin, D. P. Pazel, L. M. Burns
Venue: IEEE Transactions on Software Engineering (1989)

The syntax for an integrated E-R programming language is presented. The problems that arise when a query language is embedded in a general-purpose programming language are discussed. Other E-R languages are also discussed. The requirements for the language and a syntax for an E-R model in which entity sets are mutually disjoint and each entity type has a unique, perhaps multiattribute, key are presented. The syntax for a more limited model restricted to binary relationships between entity types and without attributes is presented. Some implementation considerations are discussed.
Distributed Execution of Recovery Blocks: An Approach for Uniform Treatment of Hardware and Software Faults in Real-Time Applications
Authors: K. H. Kim, Howard O. Welch
Venue: IEEE Transactions on Computers (1989)

The concept of distributed execution of recovery blocks is examined as an approach for uniform treatment of hardware and software faults. A useful characteristic of the approach is the relatively small time cost it requires. The approach is thus suitable for incorporation into real-time computer systems. A specific formulation of the approach that is aimed at minimizing the recovery time is presented, called the distributed recovery blocks scheme. The DRB scheme is capable of effecting forward recovery while handling both hardware and software faults in a uniform manner. An approach to incorporating the capability for distributed execution of recovery blocks into a load-sharing multiprocessing scheme is also discussed. Two experiments aimed at testing the execution efficiency of the scheme in real-time applications have been conducted on two different multimicrocomputer networks. The results clearly indicate the feasibility of achieving tolerance of hardware and software faults.
How to write parallel programs: a guide to the perplexed
Authors: Nicholas Carriero, David Gelernter
Venue: ACM Computing Surveys (CSUR) (1989)

We present a framework for parallel programming, based on three conceptual classes for understanding parallelism and three programming paradigms for implementing parallel programs. The conceptual classes are result parallelism, which centers on parallel computation of all elements in a data structure; agenda parallelism, which specifies an agenda of tasks for parallel execution; and specialist parallelism, in which specialist agents solve problems cooperatively. The programming paradigms center on live data structures that transform themselves into result data structures; distributed data structures that are accessible to many processes simultaneously; and message passing, in which all data objects are encapsulated within explicitly communicating processes. There is a rough correspondence between the conceptual classes and the programming methods, as we discuss. We begin by outlining the basic conceptual classes and programming paradigms, and by sketching an example solution under each of the three paradigms. The final section develops a simple example in greater detail, presenting and explaining code and discussing its performance on two commercial parallel computers, an 18-node shared-memory multiprocessor, and a 64-node distributed-memory hypercube. The middle section bridges the gap between the abstract and the practical by giving an overview of how the basic paradigms are implemented. We focus on the paradigms, not on machine architecture or programming languages: The programming methods we discuss are useful on many kinds of parallel machine, and each can be expressed in several different parallel programming languages. Our programming discussion and the examples use the parallel language C-Linda for several reasons: The main paradigms are all simple to express in Linda; efficient Linda implementations exist on a wide variety of parallel machines; and a wide variety of parallel programs have been written in Linda.
Encapsulating interactive behaviors
Authors: B. A. Myers
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Wings for the mind (1989)

Although there has been important progress in models and packages for the output of graphics to computer screens, there has been little change in the way that input from the mouse, keyboard and other input devices is handled. New graphics standards are still using a ten year old model even though it is widely accepted as inadequate, and most modern window managers simply return a stream of device-dependent input events. This paper presents a new model for how input devices can be handled for highly-interactive, direct manipulation, graphical user interfaces. This model encapsulates interactive behaviors into a few &ldquo;interactor&rdquo; object types. Application programs can then create instances of these interactor objects, and the details of the handling of the input devices are separated from the application and from the output graphics.
Computing the Aspect Graph for Line Drawings of Polyhedral Objects
Authors: Z. Gigus, J. Malik
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

An algorithm for computing the aspect graph for polyhedral objects is described. The aspects graph is a representation of three-dimensional objects by a set of two-dimensional views. The set of viewpoints on the Gaussian sphere is partitioned into regions such that in each region the qualitative structure of the line drawing remains the same. At the boundaries between adjacent regions are the accidental viewpoints where the structure for the line drawing changes. It is shown that for polyhedral objects there are two fundamental visual events: (1) the projections of an edge and a vertex coincide; and (2) the projections of three nonadjacent edges intersect at a point. The geometry of the object is reflected in the locus of the accidental viewpoints. The algorithm computes the partition together with a representative view for each region of the partition.
(ISEF): an integrated industrial-strength software engineering framework
Authors: Shaye Koenig
Venue: ACM SIGSOFT Software Engineering Notes (1988)

ISEF is an environment for programming-in-the-large that integrates disparate software engineering principles, methods and tools into an industrial-strength, automated software development framework. Projects using ISEF have reported increased software quality, improved software manageability and decreased software production costs. This paper presents the basic principles and mechanisms that enable ISEF to achieve environment/process integration as well as integration within the environment itself, describes the ISEF approach to software development, provides comparisons with related work, and reports on experience in using ISEF.
Teaching introductory and advanced computer graphics using micro-computers
Authors: G. S. Owen
Venue: ACM SIGCSE Bulletin (1989)

In the past few years there have been significant advances in both the computational and graphics capabilities of micro-computers. In graphics the standard (for the IBM compatible world) has advanced from the Computer Graphics Adapter (CGA) through the Enhanced Graphics Adapter (EGA) to the present Video Graphics Array (VGA). With the multiple color capability of the VGA, images can be constructed which use graphics shading algorithms. This allows us to teach more advanced concepts in introductory courses and even to teach some topics in advanced courses using these machines. In this paper I will discuss how these hardware improvements have allowed for changes in our introductory graphics course and also our experience in teaching an advanced course using these machines.
Reading to write
Authors: Raymond P. Polivka
Venue: ACM SIGAPL APL Quote Quad (1990)

Teaching a programming language offers many challenges. Foremost, of course, is the question of how to present the material. Part of any presentation are the drills and exercises. Frequently, after the content has been presented, the student is asked to write a program. This is much akin to asking a student, who has just been exposed to the grammar and some vocabulary of a new language, to write an essay in that language. This paper will discuss several alternate approaches in presenting exercises to develop the proficiency of a student in the use of a programming language.
Software maintenance documentation
Authors: R. Glass
Venue: Proceedings of the 7th annual international conference on Systems documentation (1989)

When technical writers speak of software documentation, they usually speak of user manuals. Certainly there is reason for them to. User manuals produced by software people (and I am proud to count myself as a software person!) have often been so bad that a whole industry has sprung up to publish books containing information needed to supplement traditional developer-written user manuals. Technical writers have played a key role in that industry. But there is much more to software technical documentation than user manuals. Concepts are prepared and documented; requirements are derived and written into specifications; designs are created and recorded in design documents; test plans and results are documented in special test documents; and finally the as-built product is described in maintenance manuals [Glass 88]. This paper is about software maintenance documentation. Although user manuals have been perhaps the most spectacular failure in software documentation, maintenance manuals may well be the most costly. Software maintenance consumes well over half of the typical software budget [Glass 81]. Of the maintenance tasks, more time is spent on understanding the software than on any other [Fjelsted 79]. The purpose of software maintenance documentation is to help software maintainers with that (enormously expensive) understanding. The state of the practice of software maintenance documentation is abysmal. There are two extremes, neither of which is satisfactory - either no software maintenance documentation is written at all because of schedule and budget pressures during development, or too much documentation is written and as the software product evolves during maintenance the documentation, because of its bulk, is allowed to become out of date and therefore worthless. In either case, the result is that there is no usable documentation to support the software maintainer. This finding is now new. Over 15 years ago [Ridge 73] stated &ldquo;There is virtual unanimity in the computer industry on the importance of software [maintenance] documentation &hellip; despite this fact, it is the first of the cargo to be jettisoned on a floundering project.&rdquo; The situation has changed little over the years. In [Sasso 89], a software maintainer is quoted as saying &ldquo;I'm going to assume this is typical maintenance documentation, not worth the paper it's written on.&rdquo; Fortunately, there are some trends at work that may counter this problem.
Improvements to an Algorithm for Equipartitioning
Authors: W. Gale, S. Das, C. T. Yu
Venue: IEEE Transactions on Computers (1990)

Modifications to a clustering algorithm in which objects are adaptively partitioned into clusters of equal size are described. The object migration automaton has the advantage of being conceptually simple and easy to implement. Unfortunately, the algorithm may exhibit slow convergence speed and in some cases may not converge at all. The algorithm is modified to provide remedies to these conditions. Through experimental results, the modifications are shown to yield a substantial speedup in convergence (while maintaining 100% accuracy), especially as the number of objects to be partitioned increases.
The logic of propagation in the inscape environment
Authors: D. Perry
Venue: Proceedings of the ACM SIGSOFT '89 third symposium on Software testing, analysis, and verification (1989)

The Inscape Environment research project addresses issues in supporting the development of large systems by large numbers of programmers. One aspect of this research is the &ldquo;constructive use&rdquo; of formal module interface specifications - that is, given that you have formal specifications, what can you do with them. In Inscape, the specifications form the basis for providing an environment that is knowledgeable about the process of developing and evolving software systems, an environment that works in symbiosis with the programmer to develop and evolve a software system. In this discussion, I present how Inscape uses operation specifications (based on Hoare's input/output predicate approach) as the basis for synthesizing the interfaces for such complex languages statements as sequence, selection and iteration. In each of these statements, the synthesized interface is a function of the component interfaces. I first present the basic rules for interface specification use and the logical framework for interface propagation and error detection. I then define the rules for propagating the interfaces for sequence, selection, iteration and operation. Finally, I define notions of &ldquo;implementation completeness and correctness&rdquo;.
A dynamic hierarchical subdivision algorithm for computing Delaunay triangulations and other closest-point problems
Authors: Oscar Palacios-Velez
Venue: ACM Transactions on Mathematical Software (TOMS) (1990)

A new, dynamic, hierarchical subdivision and recursive algorithm for computing Delaunay triangulations is presented. The algorithm has four main steps: (1) location of the already formed triangle that contains the point (2) identification of other adjoining triangles whose circumcircle contains the point (3) formation of the new triangles, and (4) database update. Different search procedures are analyzed. It is shown that the &ldquo;oriented walk&rdquo; search, when the total number of points is less than 417 or when the points are presorted by distance or coordinates. The algorithm has point-deletion capabilities which are discussed in detail.
Beating the I/O bottleneck: a case for log-structured file systems
Authors: John Ousterhout, Fred Douglis
Venue: ACM SIGOPS Operating Systems Review (1989)

CPU speeds are improving at a dramatic rate, while disk speeds are not. This technology shift suggests that many engineering and office applications may become so I/O-limited that they cannot benefit from further CPU improvements. This paper discusses several techniques for improving I/O performance, including caches, battery-backed-up caches, and cache logging. We then examine in particular detail an approach called log-structured file systems, where the file system's only representation on disk is in the form of an append-only log. Log-structured file systems potentially provide order-of-magnitude improvements in write performance. When log-structured file systems are combined with arrays of small disks (which provide high bandwidth) and large main-memory file caches (which satisfy most read accesses), we believe it will be possible to achieve 1000-fold improvements in I/O performance over today's systems.
Unification in primal algebras, their powers and their varieties
Authors: Tobias Nipkow
Venue: Journal of the ACM (JACM) (1990)

This paper examines the unification problem in the class of primal algebras and the varieties they generate. An algebra is called primal if every function on its carrier can be expressed just in terms of the basic operations of the algebra. The two-element Boolean algebra is the simplest nontrivial example: Every truth-function can be realized in terms of the basic connectives, for example, negation and conjunction. It is shown that unification in primal algebras is unitary, that is, if an equation has a solution, it has a single most general one. Two unification algorithms, based on equation-solving techniques for Boolean algebras due to Boole and Lo&uml;wenheim, are studied in detail. Applications include certain finite Post algebras and matrix rings over finite fields. The former are algebraic models for many-valued logics, the latter cover in particular modular arithmetic. Then unification is extended from primal algebras to their direct powers, which leads to unitary unification algorithms covering finite Post algebras, finite, semisimple Artinian rings, and finite, semisimple nonabelian groups. Finally the fact that the variety generated by a primal algebra coincides with the class of its subdirect powers is used. This yields unitary unification algorithms for the equational theories of Post algebras and p-rings.