ppxscal/embedding_network huggingface dataset:
Solving the algebraic Riccati equation on a hypercube multiprocessor
Authors: J. D. Gardiner, A. J. Laub
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

A parallel algorithm for solving the algebraic Riccati equation is described and its performance on an Intel iPSC/d5 is reported. Three variations of the matrix sign function algorithm are compared. The best one showed efficiencies of about 60 percent on large problems.
On the difficulty of tetrahedralizing 3-dimensional non-convex polyhedra
Authors: J. Ruppert, R. Seidel
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

A number of different polyhedral decomposition problems have previously been studied, most notably the problem of triangulating a simple polygon. We are concerned with the tetrahedralization problem: decomposing a 3-dimensional polyhedron into a set of non-overlapping tetrahedra whose vertices are chosen from the vertices of the polyhedron. It has previously been shown that some polyhedra cannot be tetrahedralized in this fashion. We show that the problem of deciding whether a given polyhedron can be tetrahedralized is NP-complete, and hence likely to be computationally intractable. The problem remains NP-complete when restricted to the case of star-shaped polyhedra. Various versions of the question of how many Steiner points are needed to tetrahedralize a polyhedron also turn out to be NP-complete.
A manufacturing capacity planning experiment through functional workload decomposition
Authors: T. P. Lee
Venue: ACM SIGMETRICS Performance Evaluation Review (1988)

In this paper, we describe an experiment to evaluate a distributed architecture via functional database workload decomposition. A workload in a circuit pack assembly environment was decomposed and mapped onto a frontend/backend distributed computer architecture. To evaluate this distributed architecture, an operational model for capacity planning was devised, and performance and cost-effectiveness measures were chosen. Model parameters were estimated through benchmark experiments in a distributed system consisting of various super-microcomputers connected by a CSMA/CD local area network with INGRES as the database management system. The frontend/backend architecture consists of a backend data repository and analysis computer system and a few frontend computer systems dedicated for data collection and manufacturing process verification. Because of the significant software overhead in communication protocol and database processing, information exchange was batched between the backend and frontend systems to amortize such cost to improve overall system performance. Results of the experiments were analyzed to gain quantitative insight on the feasibility of such decomposition and its mapping onto the proposed architecture. With sufficient batching, the proposed distributed architecture not only has more overall system capacity, but also is more cost-effective than the typical centralized architecture. The approach described is applicable in more general contexts. Advantages of such distributed systems include the relative robustness of the distributed architecture under single point failure mode and the ease of capacity growth by upgrading the computer systems and/or by increasing the number of frontend systems.
A subset coloring algorithm and its applications to computer graphics
Authors: D. Rubinstein, J. Shallit, M. Szegedy
Venue: Communications of the ACM (1988)

We consider the following problem: we are given a diagram made up of intersecting circles, where each region is colored either black or white. We wish to display this diagram on a bitmap device, where we are allowed to (i) paint a given circle white and (ii) invert the colors within a given circle, changing white to black and vice versa. (These operations are frequently provided in graphics hardware or software.) We ask: using only these paint and invert operations, is it possible to draw the diagram? A generalization of this problem leads to an analogous coloring problem on a subset of the power set of n elements. We give a polynomial-time algorithm that answers the question above, and produces a "short" sequence of instructions to draw the diagram, if one exists. A simple modification of the algorithm permits us to handle the case where there are more colors than just black and white, and the colors are represented by bit strings. This corresponds to the conventions frequently used with color raster devices.
Convolution on Mesh Connected Multicomputers
Authors: S. Ranka, S. Sahni
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

An efficient parallel algorithm is presented for convolution on a mesh-connected computer with wraparound. The algorithm does not require a broadcast feature for data values, as assumed by previously proposed algorithms. As a result, the algorithm is applicable to both SIMD and MIMD meshes. For an N*N image and a M*M template, the previous algorithms take O(M/sup 2/q) time on an N*N mesh-connected multicomputer (q is the number of bits in each entry of the convolution matrix). The algorithms have complexity O(M/sup 2/r), where r=max (number of bits in an image entry, number of bits in a template entry). In addition to not requiring a broadcast capability, these algorithms are faster for binary images.
Hierarchical, modular modelling in DEVS-scheme
Authors: B. P. Zeigler, J. H. Hu, J. W. Rosenblit
Venue: Proceedings of the 21st conference on Winter simulation (1989)

This tutorial describes the features of DEVS-Scheme a knowledge based simulation environment for hierarchical, modular discrete event models. The attributes of DEVS-Scheme which distinguish it from conventional approaches are described in terms of a set of layers, each layer dependent on its predecessor to achieve its functionality.
Simulation modeling and analysis with INSIGHT: a tutorial
Authors: S. D. Roberts, M. A. Flanigan
Venue: Proceedings of the 21st conference on Winter simulation (1989)

The INSIGHT simulation language describes systems in a quick, simple, and compact fashion using a network representation. This description can be entered and simulated using novel interactive facilities that free the user from learning specific syntax. Statistics summarizing the simulation are produced automatically, but can be greatly enhanced by various input models and output analysis mechanisms. INSIGHT is available for most computers and is portable across machines. The language has been extensively applied and its scope of applications has ranged from manufacturing to service environments. Using INSIGHT, the process of simulation modeling and the results from the simulations combine to provide "insight" into problem solving.
Iterative Algorithms for Solution of Large Sparse Systems of Linear Equations on Hypercubes
Authors: C. Aykanat, F. Özgüner, F. Ercal, P. Sadayappan
Venue: IEEE Transactions on Computers (1988)

Finite-element discretization produces linear equations in the form Ax=b, where A is large, sparse, and banded with proper ordering of the variables x. The solution of such equations on distributed-memory message-passing multiprocessors implementing the hypercube topology is addressed. Iterative algorithms based on the conjugate gradient method are developed for hypercubes designed for coarse-grained parallelism. The communication requirements of different schemes for mapping finite-element meshes onto the processors of a hypercube are analyzed with respect to the effect of communication parameters of the architecture. Experimental results for a 16-node Intel 80386-based iPSC/2 hypercube are presented and discussed.
On Iterative Arrays for the Euclidean Algorithm Over Finite Fields
Authors: D. M. Mandelbaum
Venue: IEEE Transactions on Computers (1989)

Iterative arrays are described which implement the extended Euclidean algorithm over finite fields with characteristic two and are designed to have throughputs in the area of hundreds of megabits per second. A special form of the Euclidean algorithm is the basis of these arrays, which can be used for error decoding. The propagation time through the array is derived as a function of the degree of the input polynomials.
A direct execution architecture for Prolog?
Authors: M. Brady
Venue: Proceedings of the 22nd annual workshop on Microprogramming and microarchitecture (1989)

This paper describes work in progress on the development of a direct execution Prolog processor.
A Survey of Parallel Computer Architectures
Authors: Ralph Duncan
Venue: Computer (1990)

An attempt is made to place recent architectural innovations in the broader context of parallel architecture development by surveying the fundamentals of both newer and more established parallel computer architectures and by placing these architectural alternatives in a coherent framework. The primary emphasis is on architectural constructs rather than specific parallel machines. Three categories of architecture are defined and discussed: synchronous architectures, comprising vector, SIMD (single-instruction-stream, multiple-data-stream) and systolic machines; MIMD (multiple-instruction-stream, multiple-data-stream) with either distributed or shared memory; and MIMD-based paradigms, comprising MIMD/SIMD hybrid, dataflow, reduction, and wavefront types.
Random behavior: mechanical and psychological
Authors: Foster Lindley
Venue: ACM SIGSIM Simulation Digest (1988)

To continue an earlier discussion of random number generators in SIMULETTER (Vol 8, No 1, pp. 10--37), it is frequently said of the sequences produced by random number algorithms that they are not genuinely random, but rather, pseudo-random. Two reasons are given; a) the sequence is predictable and repeatable, b) each number is dependent on the preceding number. Yet the first reservation would hold for any gambling device and the second may be true without affecting the randomness of its output.
The higher radix hypercube as an interconnection and virtual network
Authors: T.-C. Lin, P. Gupta
Venue: Proceedings of the 17th conference on ACM Annual Computer Science Conference (1989)

The HIGHER RADIX HYPERCUBE (HRH) is investigated in this paper as an interconnection network for multiprocessors as well as a virtual network. The HRH is based on a radix higher than two, the radix for the hypercube. We have compared several topological parameters' for the HRH with the hypercube. It can be seen that HRH provides smaller diameter for a small price. A mapping and a partitioning algorithms are proposed for mapping different topologies to the HRH. In our algorithm, we first map the problem topology to a virtual HRH, which is the most natural HRH for the problem. The virtual HRH is then transformed into the actual topology. This algorithm is applicable to HRH used either as an interconnection or a virtual network. The partitioning algorithm reduces a large application topology to the required size by the iterative reduction process. Three examples of mapping topologies onto the HRH are also presented.
IDLOG: extending the expressive power of deductive database languages
Authors: Yeh-Heng Shen
Venue: ACM SIGMOD Record (1990)

The expressive power of pure deductive database languages, such as DATALOG and stratified DATALOGS, is limited in a sense that some useful queries such as functions involving aggregation are not definable in these languages. Our concern in this paper is to provide a uniform logic framework for deductive databases with greater expressive power. It has been shown that with a linear ordering on the domain of the database, the expressive power of some database languages can be enhanced so that some functions involving aggregation can be defined. Yet, a direct implementation of the linear ordering in deductive database languages may seem unintuitive, and may not be very efficient to use in practice. We propose a logic for deductive databases which employs the notion of &ldquo;identifying each tuple in a relation&rdquo;. Through the use of these tuple-identifications, different linear orderings are defined as a result. This intuitively explains the reason why our logic has greater expressive power. The proposed logic language is non-deterministu in nature. However, non-determinism is not the real reason for the enhanced expressive power. A deterministic subset of the programs in this language is computational complete in the sense that it defines all the computable deterministic queries. Although the problem of deciding whether a program is in this subset is in general undecidable, we do provide a rather general sufficient test for identifying such programs. Also discussed in this paper is an extended notion of queries which allows both the input and the output of a query to contain interpreted constants of an infinite domain. We show that extended queries involving aggregation can also be defined in the language.
Error detecting decimal digits
Authors: Paul Putter, Neal R. Wagner
Venue: Communications of the ACM (1989)

Decimal-oriented error detection schemes are explored in the context of one particular company project.
Object specialization
Authors: Edward Sciore
Venue: ACM Transactions on Information Systems (TOIS) (1989)

Specialization hierarchies typically are treated as type-level constructs and are used to define various inheritance mechanisms. In this paper we consider specialization at the level of objects. We show that doing so creates a more flexible and powerful notion of inheritance by allowing objects to define their own inheritance path. Object specialization can also be used to model certain forms of versioning, implement data abstraction, and provide a &ldquo;classless&rdquo; prototype-based language interface to the user.
On the Sensitivity of the Hough Transform for Object Recognition
Authors: W. E. L. Grimson, D. P. Huttenlocher
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

Object recognition from sensory data involves, in part, determining the pose of a model with respect to a scene. A common method for finding an object's pose is the generalized Hough transform, which accumulates evidence for possible coordinate transformations in a parameter space whose axes are the quantized transformation parameters. Large clusters of similar transformations in that space are taken as evidence of a correct match. A theoretical analysis of the behavior of such methods is presented. The authors derive bounds on the set of transformations consistent with each pairing of data and model features, in the presence of noise and occlusion in the image. Bounds are provided on the likelihood of false peaks in the parameter space, as a function of noise, occlusion, and tessellation effects. It is argued that haphazardly applying such methods to complex recognition tasks is risky, as the probability of false positives can be very high.
Design and test of distributed applications
Authors: J. Fagerström
Venue: Proceedings of the 10th international conference on Software engineering (1988)

It is well known that programming and testing distributed systems can be extremely difficult. Reasons for this include non-deterministic behavior, non-reproducibility of events, complex timing of events, and complex states. This paper presents a paradigm and system that will support a programmer when designing, programming, and testing a distributed application. Our main point is that the structure introduced by the paradigm must be kept and exploited during design, programming, and testing. One is not helped by a programming method which introduces a structure just to break it down again. We have developed a structural model based on common structures in distributed systems. This structural model is used to describe the logical relationships between components in a system. It is also integrated into the programming environment.
Recording the reasons for design decisions
Authors: C. Potts, G. Bruns
Venue: Proceedings of the 10th international conference on Software engineering (1988)

We outline a generic model for representing design deliberation and the relation between deliberation and the generation of method-specific artifacts. A design history is regarded as a network consisting of artifacts and deliberation nodes. Artifacts represent specifications or design documents. Deliberation nodes represent issues, alternatives or justifications. Existing artifacts give rise to issues about the evolving design, an alternative is one of several positions that respond to the issue (perhaps calling for the creation or modification of an artifact), and a justification is a statement giving the reasons for and against the related alternative. The model is applied to the development of a text formatter. The example necessitates some tailoring of the generic model to the method adopted in the development, Liskov and Guttag's design method. We discuss the experiment and the method-specific extensions. The example development has been represented in hypertext and as a Prolog database, the two representations being shown to complement each other. We conclude with a discussion of the relation between this model and other work, and the implications for tool support and methods.
IR-NLI II: applying man-machine interaction and artificial intelligence conceptsto information retrieval
Authors: G. Brajnik, G. Guida, C. Tasso
Venue: Proceedings of the 11th annual international ACM SIGIR conference on Research and development in information retrieval (1988)

This paper addresses the problem of building expert interfaces to information retrieval systems. In particular, the problem of augmenting the capabilities of such interfaces with user modeling features is discussed and the main benefits of this approach are outlined. The paper presents a prototype system called IR-NLI II, devoted to model by means of artificial intelligence techniques the human intermediary to information retrieval systems. The overall organization of the IR-NLI II system is presented, together with a short description of the two main modules implemented so far, namely the Information Retrieval Expert Subsystem and the User Modeling Subsystem. An example of interaction with IR-NLI II is described. Perspectives and future research directions are finally outlined.
Garbarge collection for Prolog based on WAM
Authors: K. Appleby, M. Carllson, S. Haridi, D. Sawhlin
Venue: Communications of the ACM (1988)

The Warren abstract machine (WAM) has become a generally accepted standard Prolog implementation technique. Garbage collection is an important aspect in the implementation of any Prolog system. A synopsis of the WAM is presented and then marking and compaction algorithms are shown that take advantage of WAM's unique use of the data areas. Marking and compaction are performed on both the heap and the trail; both use pointer reversal techniques, which obviate the need for extra stack space. However, two bits for every pointer on the heap are reserved for the garbage collection algorithm. The algorithm can work on segments of the heap, which may lead to a significant reduction of the total garbage collection time. The time of the algorithms are linear in the size of the areas.
An implementation of portable standard LISP on the BBN butterfly
Authors: Mark Swanson, Robert Kessler, Gary Lindstrom
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

An implementation of the Portable Standard Lisp (PSL) on the BBN Butterfly is described. Butterfly PSL is identical, syntactically and semantically, to implementations of PSL currently available on the VAX, Gould, and many 68000-based machines, except for the differences discussed in this paper. The differences include the addition of the future and touch constructs for explicit parallelism and an extension of the fluid binding mechanism to support the multiple environments required by concurrent tasks. As with all other PSL implementations, full compilation to machine code of the basic system and application source code is the normal mode, in contrast to the previous byte-code interpreter efforts. Also discussed are other required changes to the PSL system not visible in the syntax or semantics, e.g., compiler support for the future construct. Finally, the underlying hardware is described, and timings for basic operations and speedup results for two examples are given.
Lifting canonical algorithms from a ring R to the ring R[x]
Authors: R. Shtokhamer
Venue: Journal of Symbolic Computation (1988)

Given ample sets in a ring R we define related ample sets in the polynomial ring R[x]. For Noetherian rings we state natural and sufficient conditions for canonical form algorithms to be lifted to canonical form algorithms in R[x]. It is possible then to construct syzygies as well as to perform general division with respect to any finite set in R[x]. The construction is based on the notion of a Szekeres basis.
A Case Study in Structure Specification: a Grid Description of Scribe
Authors: H. Ossher
Venue: IEEE Transactions on Software Engineering (1989)

The author describes a case study in which the grid mechanism was used to describe the structure of Scribe, a document-processing system in widespread use. The structure description is presented and explained in some detail, and the effectiveness of the grid for specifying the important structural features of Scribe is discussed. It is shown that the grid succeeds in its objective of presenting complex structures clearly. A grid specification forms a suitable basis for a narrative explanation of system structure. It is further noted that some detailed improvements would further enhance the expressiveness of the grid, and that environment support is essential for serious use of the grid.
Leave-One-Out Procedures for Nonparametric Error Estimates
Authors: K. Fukunaga, D. M. Hummels
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The use of nonparametric error estimates may lead to biased results if the kernel covariances are estimated from the same data as are used to form the error estimate. If additional design samples are available, one may eliminate this bias by estimating the class covariances using an independent set of data. If, however, additional samples are not available, one may resort to leave-one-out type estimates of the kernel (for Parzen estimates) or metric (for nearest-neighbor estimates) for every sample being tested. The authors present an efficient algorithm for computation of these leave-one-out type estimates that requires little additional computational burden over procedures currently in use. The presentation is applicable to both Parzen and k-nearest neighbor (k-NN) type estimates. Experimental results demonstrating the efficiency of the algorithm are provided.
Simulations of incipient singularities in the 3D Euler equations
Authors: A. Pumir, E. Siggia
Venue: Physica D (1989)

The production of the familiar local newspaper can become a complicated and challenging scheduling and distribution problem. Expanded circulation, zoned advertising and customized local news have forced newspapers to produce many variations of the traditional single product daily newspaper. Currently, a "main jacket" (a basic regional newspaper without specialized advertising) is only a building block for more complex products. Any time additional sections are "inserted" into the main, the paper becomes classified under a new product code. Operations are now dealing with simultaneous processing of dozens of products in a high-speed, demand-driven environment.Simulation and animation are being used to aid in the operational design and testing of new, flexible newspaper production and distribution facilities. This paper discusses the analysis of the scheduling problems of a specific newspaper while highlighting the benefits of using specialized modeling and display techniques during analysis. The paper contains the following sections: adding dual screen run-time output, creating reusable models by structuring for generic system qualities, and developing model specific user menu systems.