ppxscal/embedding_network huggingface dataset:
Hypercube implementation of the simplex algorithm
Authors: C. B. Stunkel, D. A. Reed
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

Large, sparse, linear systems of equations arise frequently when constructing mathematical models of natural phenomena. Most often, these linear systems are fully constrained and can be solved via direct or iterative techniques. However, one important problem class requires solutions to underconstrained linear systems that maximize some objective function. These linear optimization problems are natural formulations of many business plans and often contain hundreds of equations with thousands of variables. Historically, linear optimization problems have been solved via the simplex method. Despite the excellent performance of the simplex method, the size of the optimization problems and the frequency of their solution make linear optimization a computationally taxing endeavor. This paper examines the performance of parallel variants of the simplex algorithm on the Intel iPSC, a message-based parallel system. Linear optimization test data are drawn from commercial sources and represent realistic problems. Analysis shows that the speedup obtained is sensitive to both the structure of the underlying data and the data partitioning.
Some comments on term-ordering in Gröbner basis computations
Authors: W. Y. Sit
Venue: ACM SIGSAM Bulletin (1989)

As is well-known, both the theoretical properties of Gr ouml;bner basis and the efficiency of Gr ouml;bner basis computations using Buchberger's algorithm depend on a particular choice of term-ordering (see Buchberger, [1987] and B ouml;ge, et al, [1986]). While all admissible term-orderings has been characterized (Robbiano, [1985] and [1988]; Weispfenning, [1987]), the term-orderings that are commonly used in the literature and in computer algebra systems do not yet have a unified terminology. Thus we have total-degree ordering, purely lexicographical ordering (Buchberger, [1985]), lexicographical ordering (Buchberger, [1976]; Bayer and Stillman, [1987]), reverse lexicographical ordering (Jenks, [1984]; Bayer and Stillman, [1987]), and inverse graduated term-ordering and inverse lexicographical term-ordering (B ouml;ge, et al [1986]). Some other authors have used these terms without defining them, and since the same terminology may actually mean different orderings, a reader has to guess at the correct interpretation. Thus a researcher who wants to implement an algorithm based on a theoretical result which depends on a particular term-ordering may inadvertently use a different term-ordering. Worse yet, a user of such a program may not even be aware of the wrong term-ordering used. I think this problem should be brought to the attention of the Gr ouml;bner basis research community.
Comparing test data adequacy criteria
Authors: S. N. Weiss
Venue: ACM SIGSOFT Software Engineering Notes (1989)

Test data adequacy criteria have been compared in a multitude of ways in the literature, ranging from the relative difficulty of satisfying them to the relative probability that test sets that satisfy them will expose errors in programs. Each method of comparison gives rise to an ordering of criteria, many of which differ significantly from the others. We investigate the various methods of comparing criteria, and show how the induced orderings are related. There are presently no methods of comparison that are based on the cost of using criteria; we propose a formal model of cost comparison of criteria. We categorize methods of comparison as being satisfiability based, correctness based, or complexity based.
Application of splay trees to data compression
Authors: D. W. Jones
Venue: Communications of the ACM (1988)

The splay-prefix algorithm is one of the simplest and fastest adaptive data compression algorithms based on the use of a prefix code. The data structures used in the splay-prefix algorithm can also be applied to arithmetic data compression. Applications of these algorithms to encryption and image processing are suggested.
On the relations computable by a class of concurrent automata
Authors: Eugene W. Stark
Venue: Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

We consider monotone input/output automata, which model a usefully large class of dataflow networks of indeterminate (or nonfunctional) processes. We obtain a characterization of the relations computable by these automata, which states that a relation R : X &rarr; 2Y (viewed as a &ldquo;nondeterministic function&rdquo;) is the input/output relation of an automaton iff there exists a certain kind of Scott domain D, a continuous function F : X &rarr; [D &rarr; Y] and a continuous function G : X &rarr; P(D), such that R(&aelig;) = F(&aelig;)&dagger;(G(&aelig;)) for all inputs &aelig; &egr; X. Here P denotes a certain powerdomain operator, and &dagger; denotes the pointwise extension to the powerdomain of a function on the underlying domain. An attractive feature of this result is that it specializes to two subclasses of automata, determinate automata, for which G is single-valued, and semi-determinate automata, for which G is a constant function. A corollary of the latter result is the impossibility of implementing &ldquo;angelic merge&rdquo; by a network of determinate processes and &ldquo;infinity-fair merge&rdquo; processes.
Local generalized Hermite interpolation by quartic C2 space curves
Authors: Jörg Peters
Venue: ACM Transactions on Graphics (TOG) (1989)

This paper develops and explains the construction of a piecewise quartic space curve that interpolates positional, tangent, and curvature data. The construction is local and explicit; that is, it does not involve the solution of equations. If only positional data are known, then the tangent and curvature data can he derived by simple local default rules. Another option is to reduce the degree of the curve or minimize the a-norm of its derivative by solving a diagonally dominant, banded, linear system.
Representation of logic functions by if-then clauses
Authors: P. K. Chiu
Venue: ACM SIGARCH Computer Architecture News (1989)

In this short paper, an alternative representation of logic functions is proposed. Instead of using Boolean expressions to represent logic functions, a set of if-then clauses is used. It is shown how a Boolean expression can be translated to the equivalent form in general. This representation of logic functions speeds up the logic simulation and solves the deadlock problem in logic simulation using concurrent processes such as OCCAM.
Process control with the G2 real-time expert system
Authors: Robert Moore, Paul Lindenfilzer, Lowell Hawkinson, Bill Matthews
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

The Gensym real-time expert system G2 integrates dynamic models and rules to combine analytic and heuristic knowledge representation. The inference engine can reason about object connectivity and can use generic forms of knowledge, interpreted for specific instances in the domain. Designed for process control and related applications, G2 allows the process engineer to implement and manage the expert system. A network architecture allows hierarchical or co-operating expert systems in the plant. The first Expert Control System using G2 is described. The Reliable Water Company in Boston has implemented G2 for control and on-line diagnostics for a water purification process. The system was first demonstrated in June 1987, in prototype form, purifying water from the Boston Harbor. Delivery versions are now being deployed.
Walking on an electric treadmill while performing VDT office work
Authors: N. Edelson, J. Danoffz
Venue: ACM SIGCHI Bulletin (1989)

The physiological and psychological health problems associated with sedentary office work are well documented, but their solution has proved elusive. In this study a specially designed office permitted the comparison of conventional word processing (sedentary condition) to word processing performed while walking on an electric treadmill at 1.4 to 2.8 km/hr (active condition). Five subjects after several days of practice produced two test trials each consisting of six 20-minute intervals of word processing. For the sedentary condition the subjects were seated, during all six intervals. For the active condition, treadmill-walking and seated intervals were alternated. Variables measured included word processing performance score, stress and arousal indices, and body complaint count. The first of these was tested with a repeated ANOVA and Newman-Keuls post hoc, and the latter three with correlated t-tests. No significant differences were found between the two conditions for performance or body complaints. Stress was significantly lower (p lt; .05), and arousal was higher but not quite significant (P lt; .07) for the active condition. We conclude that treadmill walking and routine word processing can be performed concurrently without a decrement in work performance, and that certain physiological and psychological benefits may result.
Automatic programming for streams II: transformational implementation
Authors: D. Barstow
Venue: Proceedings of the 10th international conference on Software engineering (1988)

&PHgr;NIX is an automatic programming system, now under development, for writing programs which interact with external devices through temporally-ordered streams of values. Abstract specifications are stated in terms of constraints on the values of input and output streams. The target language is the Stream Machine, a language which includes concurrently executing processes communicating and synchronizing through streams. &PHgr;NIX produces programs by repeatedly transforming abstract specifications through successively more concrete forms until concrete Stream Machine programs are produced. An example which &PHgr;NIX has successfully implemented involves three major steps: transforming the specification into an applicative expression, transforming the applicative expression into three imperative processes, and merging the processes into a single process. Each major step involves several other transformation steps that reformulate and simplify intermediate expressions.
Boundary Detection and Skeletonization with a Massively Parallel Architecture
Authors: M. Milgram, T. de Saint Pierre
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

A massively parallel architecture called TOSCA (tokens sending cellular automation) is presented that performs edge pixel detection and skeletonization in the image processing area. Each cell of this cellular automaton has a very reduced set of instructions and a very small amount of memory. The computation is based on token propagation, counting devices, and local processing. The skeletonization method is based on the Chamfer distance.
Supporting reverse execution for parallel programs
Authors: Douglas Z. Pan, Mark A. Linton
Venue: ACM SIGPLAN Notices (1989)

Parallel programs are difficult to debug because they run for a, long time and two executions may yield different results. Reverse execution, is a simple and powerful concept that solves both these problems. We are designing a tool for debugging parallel programs, called Recap, that provides the illusion of reverse execution using checkpoints and event recording and playback. During normal execution, Recap logs the results of system calls and shared memory reads: as well as the times that asynchronous events (signals) occur. Recap periodically checkpoints the state of a process by forking and suspending a new process. To reverse execute to a certain point in time, Recap continues the nearest checkpoint process forward in a self-contained environment, simulating all events using the log. We are implementing Recap as part of a larger environment for parallel program development.
Capability of current supercomputers for the computational fluid dynamics
Authors: K. Fujii, Y. Tamura
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

The computer code named LANS3D, one of the representative Navier-Stokes codes in Japan, is taken as a example and the capability of the current CFD technology is discussed. This code was developed for the numerical simulation of high-Reynolds number compressible flows. The algorithm used in this code and how it has been improved so far explain two important aspects of the computational fluid dynamics (CFD) codes: efficiency and accuracy. Some of the application examples show the capability of the code for engineering problems as well as physical problems. The benchmark test of the newest version of the code on supercomputers indicates that recent supercomputer improvement enables the code to be a strong engineering tool for the design purpose. At the same time, it is concluded that still more compiler improvement may lead to the best use of the supercomputers on the computational fluid dynamics.
Parallel thinning with two-subiteration algorithms
Authors: Zicheng Guo, Richard W. Hall
Venue: Communications of the ACM (1989)

Two parallel thinning algorithms are presented and evaluated in this article. The two algorithms use two-subiteration approaches: (1) alternatively deleting north and east and then south and west boundary pixels and (2) alternately applying a thinning operator to one of two subfields. Image connectivities are proven to be preserved and the algorithms' speed and medial curve thinness are compared to other two-subiteration approaches and a fully parallel approach. Both approaches produce very thin medial curves and the second achieves the fastest overall parallel thinning.
A Fast and Flexible Thinning Algorithm
Authors: P. S. P. Wang, Y. Y. Zhang
Venue: IEEE Transactions on Computers (1989)

A fast serial and parallel algorithm for thinning digital patterns is presented. The processing speed is faster than previous algorithms in that it reads pixels along the edge of the input pattern rather than all pixels in each iteration. Using this algorithm, an experiment is conducted and the patterns such as 'X', 'H', 'A', 'moving body', and 'leaf' are tested. The results show that this algorithm is faster, structure-preserving, and more flexible in that it can be done either sequentially or in parallel.
A simulation tool for teaching CPU design and microprogramming concepts
Authors: Y. S. Chua, C. Winton
Venue: ACM SIGAPL APL Quote Quad (1989)

Courses in computer architecture, among other things, must address issues of CPU design and microprogramming. Real environments, if even available, provide very specialized, vendor specific architecture solutions. Computer architecture for this reason is often approached without the benefit of any hands-on experience. Simulation obviously provides a means of exploring "new" architectures. However, simulation tools in the architecture area tend to be highly specialized, typically dictating CPU design and microprogramming organization. If engineering-level concerns of speed or timing considerations are not at issue, APL provides a uniquely effective base for building a general simulation tool to implement both mundane and exotic microprogrammable CPU designs. The authors have conceived and developed such an environment using APL. Both students and instructor can use the simulation toolkit to "implement" CPU designs or install an existing CPU architecture. The user can specify registers and function modules activated by bits in the microinstructions. CPU bus structures, the microprogram store, main memory and its access scheme are user-definable. An interface guides the construction of microcode. The simulation can be operated one instruction at a time, one microinstruction at time, or integral multiples of either. A student-ready version has been successfully class tested during the 1989 Spring semester.
Recalibrating Software Reliability Models
Authors: Sarah Brocklehurst, P. Y. Chan, Bev Littlewood, John Snell
Venue: IEEE Transactions on Software Engineering (1990)

There is no universally applicable software reliability growth model which can be trusted to give accurate predictions of reliability in all circumstances. A technique of analyzing predictive accuracy called the u-plot allows a user to estimate the relationship between the predicted reliability and the true reliability. It is shown how this can be used to improve reliability predictions in a very general way by a process of recalibration. Simulation results show that the technique gives improved reliability predictions in a large proportion of cases. However, a user does not need to trust the efficacy of recalibration, since the new reliability estimates produced by the technique are truly predictive and their accuracy in a particular application can be judged using the earlier methods. The generality of this approach suggests its use whenever a software reliability model is used. Indeed, although this work arose from the need to address the poor performance of software reliability models, it is likely to have applicability in other areas such as reliability growth modeling for hardware.
Debugging concurrent processes: a case study
Authors: J. M. Stone
Venue: Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation (1988)

We present a case study that illustrates a method of debugging concurrent processes in a parallel programming environment. It uses a new approach called speculative replay to reconstruct the behavior of a program from the histories of its individual processes. Known time dependencies between events in different processes are used to divide the histories into dependence blocks. A graphical representation called a concurrency map displays possibilities for concurrency among processes. The replay technique preserves the known dependencies and compares the process histories generated during replay with those that were logged during the original program execution. If a process generates a replay history that does not match its original history, replay backs up. An alternative ordering of events is created and tested to see if it produces process histories that match the original histories. Successively more controlled replay sequences are generated, by introducing additional dependencies. We describe ongoing work on tools that will control replay without reconstructing the entire space of possible event orderings. The case study presents a miniature example of shared-queue management that can be examined in detail. It demonstrates the replay technique and the construction and use of the concurrency map. Using our techniques, we detect a failure to which a standard algorithm for shared-queue management is susceptible.
Efficient dataflow analysis of logic programs
Authors: S. K. Debray
Venue: Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1988)

We investigate a framework for efficient flow analyses of logic programs. A major problem in this context is that unification can give rise to aliasing and dependencies between variables whose effects are difficult to predict, and which make sound flow analysis algorithms computationally expensive. We give a simple characterization of the class of flow analysis problems for which aliasing effects can be ignored without loss of soundness, and describe an efficient analysis procedure for this class of problems. The utility of our approach is illustrated by discussing its application to several analysis and optimization problems for logic programs. Our results are useful in the design of efficient flow analysis systems for logic programming languages.
The GPSS/PC student version
Authors: S. W. Cox
Venue: Proceedings of the 21st conference on Winter simulation (1989)

From its inception, GPSS/PC, itself, has always had features designed specifically to facilitate the mastery of the simulation environment by new users. Its basic design goals of visibility, control, and protection from unseen danger fit very nicely into the classroom.The GPSS/PC Student Version has been available to educational institutions at nominal cost, ever since Version 2 of GPSS/PC was released. It was designed to provide the visual interactive environment of GPSS/PC, including the error prevention and detection features, to students learning the GPSS language and/or simulation methodologies in general. Although the Student Version does not include the FORTRAN interface or the built-in spatial animation, it does include the animated graphics windows and is completely functional with respect to the simulation primitives of its big brother, the commercial version of GPSS/PC. In addition, its use of character mode graphics results in minimal hardware requirements in the laboratory yet retains the graphical user interface.Several recent improvements to the Student Version have improved its speed and power. Although the Student Version was never designed as a vehicle for advanced projects, users have occasionally requested that its capabilities be expanded. For this reason, in mid 1989, both speed and size limitations were somewhat relaxed.This paper presents the features and limitations of the current GPSS/PC Student Version, and discusses the advantages of the interactive and protective GPSS/PC simulation environment in the classroom.
A visual microprogramming system
Authors: T. Baba, H. Minakawa, K. Okuda
Venue: ACM SIGMICRO Newsletter (1988)

A visual microprogramming system has been developed to support all aspects of the microprogramming process for a microprogrammed computer. The user can specify microoperations on a displayed hardware configuration. A graphical microprogram list has also been designed to display several microinstructions on the screen. Optimization may also be done on the screen. A visual simulator graphically illustrates the execution of microoperations on the screen, while allowing the user to control the simulator by using several commands. Preliminary evaluation results are also presented.
Application of simulation for order sequencing in flow-shop production systems
Authors: Rolf Schmidt
Venue: Proceedings of the 21st annual symposium on Simulation (1988)

In many cases the functionality and performance of flow-shop production systems depends heavily on the selection of a suitable sequence of orders. The main objectives of order sequencing in production systems are minimization of set-up times, continuous and optimal use of capacities, reliability of delivery, minimization of stock and throughput time as well as avoidance of undue system states. The complexity of the task of order sequencing usually requires the employment of heuristic methods rather than analytical approaches. In this context computer simulation can be used for 1. testing and evaluation of rules for heuristic order sequencing applied to a given production system, 2. iterative optimization of partial order sequences and 3. realization of a closed-loop control system, in which the decision of the next job to be placed is made every time dependent on the actual state of the production system and its change tendencies. Integration of simulation programs within production control stations dealing with order sequencing problems thus allows to increase the performance of the production system as well as to make forecasts of future system states according to a chosen order sequence. In the following article the possibilities and limits of simulation employed to create optimal order sequences for flow-shop production systems will be outlined and discussed and some examples will be given.