ppxscal/embedding_network huggingface dataset:
Set operations on polyhedra using binary space partitioning trees
Authors: William C. Thibault, Bruce F. Naylor
Venue: ACM SIGGRAPH Computer Graphics (1987)

We introduce a new representation for polyhedra by showing how Binary Space Partitioning Trees (BSP trees) can be used to represent regular sets. We then show how they may be used in evaluating set operations on polyhedra. The BSP tree is a binary tree representing a recursive partitioning of d-space by (sub-)hyperplanes, for any dimension d. Their previous application to computer graphics has been to organize an arbitrary set of polygons so that a fast solution to the visible surface problem could be obtained. We retain this property (in 3D) and show how BSP trees can also provide an exact representation of arbitrary polyhedra of any dimension. Conversion from a boundary representation (B-reps) of polyhedra to a BSP tree representation is described. This technique leads to a new method for evaluating arbitrary set theoretic (boolean) expressions on B-reps, represented as a CSG tree, producing a BSP tree as the result. Results from our language-driven implmentation of this CSG evaluator are discussed. Finally, we show how to modify a BSP tree to represent the result of a set operation between the BSP tree and a B-rep. We describe the embodiment of this approach in an interactive 3D object design program that allows incremental modification of an object with a tool. Placement of the tool, selection of views, and performance of the set operation are all performed at interactive speeds for modestly complex objects.
Recommendations for software engineering education
Authors: Doris L. Carver
Venue: ACM SIGCSE Bulletin (1987)

The increasing emphasis on software engineering in the computer science curricula directly correlates with the expansion of the area of software engineering. The increased occurrence of software engineering courses has produced significant discrepancies in the content of the courses at the undergraduate level. These discrepancies have percipitated the need for recommendations for the inclusion of software engineering in the curriculum. The recommendations presented in this paper include both the integration of software engineering principles throughout the undergraduate curriculum and the content of a separate software engineering course. The recommendations for course content are based on a survey of the contents of recently published software engineering textbooks.
An improved systematic method for constructing systolic arrays from algorithms
Authors: N. Faroughi, M. A. Shanblatt
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

An improved systematic method is introduced which reduces the number of ad hoc steps and provides all possible systolic solutions for a given algorithm. Algorithms are modeled using index space (geometric) representations where the index transformation matrices are determined systematically. Systolic arrays are produced by geometric projections.
Verification of microprogrammed computer architectures in the S*-system: a case study
Authors: W. Damm, G. Dohmen
Venue: Proceedings of the 18th annual workshop on Microprogramming (1985)

We apply the verification methodology underlying the S*-System[12], [13] to the verification of a hierarchically structured design [16] of an emulation of the instruction-set of a commercially available computer on a commercially available micro-architecture. Based on this case-study, we discuss some aspects of the relation between verification and generation of microcode.
A Model of Visibility Control
Authors: Alexander L. Wolf Lori A. Clarke, Jack C. Wileden
Venue: IEEE Transactions on Software Engineering (1988)

A number of mechanisms have been created for controlling entity visibility. As with most language concepts in computer science, visibility control mechanisms have been developed in an essentially ad hoc fashion, with no clear indication given by their designers as to how one proposed mechanism relates to another. This paper introduces a formal model for describing and evaluating visibility control mechanisms. The model reflects a general view of visibility in which the concepts of requisition of access and provision of access are distinguished.This model provides a means for characterizing and reasoning about the various properties of visibility control mechanisms. Specifically, a notion of preciseness is defined in this paper. The utility of the model is illustrated by using it to evaluate and compare the relative strengths and weaknesses, with respect to preciseness, of the visibility control mechanisms found in Algol60, Ada, Gypsy, and an approach we have developed, called PIG, that specifically addresses the concerns of visibility control in large software systems.
Hashed and hierarchical timing wheels: data structures for the efficient implementation of a timer facility
Authors: G. Varghese, T. Lauck
Venue: ACM SIGOPS Operating Systems Review (1987)

Conventional algorithms to implement an Operating System timer module take &Ogr;(n) time to start or maintain a timer, where n is the number of outstanding timers: this is expensive for large n. This paper begins by exploring the relationship between timer algorithms, time flow mechanisms used in discrete event simulations, and sorting techniques. Next a timer algorithm for small timer intervals is presented that is similar to the timing wheel technique used in logic simulators. By using a circular buffer or timing wheel, it takes &Ogr;(1) time to start, stop, and maintain timers within the range of the wheel.Two extensions for larger values of the interval are described. In the first, the timer interval is hashed into a slot on the timing wheel. In the second, a hierarchy of timing wheels with different granularities is used to span a greater range of intervals. The performance of these two schemes and various implementation trade-offs are discussed.
External hashing with limited internal storage
Authors: Gaston H. Gonnet, Per-Åke Larson
Venue: Journal of the ACM (JACM) (1988)

The following problem is studied: How, and to what extent, can the retrieval speed of external hashing be improved by storing a small amount of extra information in internal storage? Several algorithms that guarantee retrieval in one access are developed and analyzed. In the first part of the paper, a restricted class of algorithms is studied, and a lower bound on the amount of extra storage is derived. An algorithm that achieves this bound, up to a constant difference, is also given. In the second part of the paper a number of restrictions are relaxed and several more practical algorithms are developed and analyzed. The last one, in particular, is very simple and efficient, allowing retrieval in one access using only a fixed number of bits of extra internal storage per bucket. The amount of extra internal storage depends on several factors, but it is typically very small: only a fraction of a bit per record stored. The cost of inserting a record is also analyzed and found to be low. Taking all factors into account, this algorithm is highly competitive for applications requiring very fast retrieval.
An object-oriented programming language for developing distributed software
Authors: Shang Lujun, Sun Zhongxiu
Venue: ACM SIGPLAN Notices (1987)

CLUSTER 86 is an object-oriented programming language. Everything in CLUSTER 86 falls into the category of object concepts. Objects are defined in two abstraction levels -- the cluster level and the type level. A type defines a set of objects whereas a cluster specifies a collection of types, and clusters are described in a tree structure.The language finds its justification in developing distributed operating systems. The language itself does not introduce any facilities for distributed programming, but it has the ability of specifing all kinds of distributed activity models. Thus the language users may build their integrated distributed environments out of scratch from the specifications of various hardware resources, to the specifications of miscellaneous high level models that pertain to their research fields and cater to their programming customs.
On the Diagnosis of System Faults with Propagation
Authors: K Huang, T Chen
Venue: IEEE Transactions on Computers (1986)

This correspondence proposes a new fault model for system diagnosis, wherein the interaction among faulty subsystems and fault propagation is considered. Criteria for one-step diagnosability are given. Optimal design of diagnosable systems is also developed. As to sequential diagnosis, single-loop systems are studied in depth.
There is a planar graph almost as good as the complete graph
Authors: P Chew
Venue: Proceedings of the second annual symposium on Computational geometry (1986)

Given a set S of points in the plane, there is a triangulation of S such that a path found within this triangulation has length bounded by a constant times the straight-line distance between the endpoints of the path. Specifically, for any two points a and b of S there is a path along edges of the triangulation with length less than &radic;10 times |ab|, where |ab| is the straight-line Euclidean distance between a and b. Thus, a shortest path in this planar graph is less than about 3 times longer than the corresponding straight-line distance. The triangulation that has this property is the L1 metric Delaunay triangulation for the set 5. This result can be applied to motion planning in the plane. Given a source, a destination, and a set of polygonal obstacles of size n, an &Ogr;(n) size data structure can be used to find a reasonable approximation to the shortest path between the source and the destination in &Ogr;(n log n) time.
Fourier series representation of industrial load profiles
Authors: Morton W. Reed
Venue: Proceedings of the 20th annual symposium on Simulation (1987)

Many industrial processes consist of motor-driven equipment and robotics operated in discrete power consuming steps or loads. The optimal sequencing of these loads makes it possible to reduce the superposition or additive load that occurs when various loads have the potential of being on at the same time. Savings in power demand costs may be realized as well as an optimization of plant production and operation. The Fourier series representation of load profiles provides a compact, flexible means of storing this information.
The zonal method for calculating light intensities in the presence of a participating medium
Authors: Holly E. Rushmeier, Kenneth E. Torrance
Venue: ACM SIGGRAPH Computer Graphics (1987)

The zonal method for calculating radiative transfer in the presence of a participating medium is applied to the generation of realistic synthetic images. The method generalizes the radiosity method and allows for emission, scattering, and absorption by a participating medium. The zonal method accounts for volume/surface interactions which have not been previously included, as well as volume/volume and surface/surface interactions. In addition, new algorithms, based on the hemi-cube formulation, are introduced for calculating the geometric factors required by the zonal method.
Heuristic Minimization of MVL Functions: A Direct Cover Approach
Authors: P W Besslich
Venue: IEEE Transactions on Computers (1986)

A heuristic method to obtain near-minimal covers of p-valued switching functions is introduced. First, we describe transform tools useful in the processing of MVL functions. They are: p-adic shifting, weighting, and implicant detecting transformations. Based on these tools, a direct cover algorithm is presented that uses local information for heuristic decision making. The heuristics are taken from weight coefficients calculated for canonical terms and implicants. The method allows to assign cost factors to implicants. Further, the algorithms can be modified easily, so as to correspond to various connectives (e.g., MAX, PLUS).
Automatic phrase indexing for document retrieval
Authors: J. Fagan
Venue: Proceedings of the 10th annual international ACM SIGIR conference on Research and development in information retrieval (1987)

An automatic phrase indexing method based on the term discrimination model is described, and the results of retrieval experiments on five document collections are presented. Problems related to this non-syntactic phrase construction method are discussed, and some possible solutions are proposed that make use of information about the syntactic structure of document and query texts.
Compared anatomy of the programming languages Pascal and C
Authors: V Hayward
Venue: ACM SIGPLAN Notices (1986)

The programming languages PASCAL and C belong to the class of algorithmic compiled languages, and feature comparable facilities. The syntax of C is more regular and enjoys less restrictions than that of PASCAL. Consequently, the syntax of C is significantly simpler than that of the PASCAL language. The design differences are particularly apparent as far as data types, operators, and system interface are concerned. PASCAL implements abstract data types (booleans, sets), whereas C defines data types that reflect the architecture of currently available computers. For PASCAL, the system interface is implemented via functions built in the language and is therefore not extensible by the user. Most of the practical implementations of the language require non standard extensions. In C, system calls and libraries of subroutines and macro instructions are provided to handle the system interface. The portability of applications then depends on the libraries and not on the compiler. A greater flexibility is thus achieved. The use of pointers and the rich set of operators of the C language make it more general than PASCAL, while retaining the principles of structured programming. Separate compilation is a standard feature of C, not of PASCAL. PASCAL compilers are often complex, while C compilers are simple and compact. C compilers include a macro processor, and the program verifier is a separate tool. The application programmers have more responsibility programming in C than in PASCAL, conversely, applications depend less on compilers in C than in PASCAL.
Systolic Super Summation
Authors: Peter R. Cappello, Willard L. Miranker
Venue: IEEE Transactions on Computers (1988)

A principal limitation in accuracy for scientific computation performed with floating-point arithmetic is due to the computation of repeated sums, such as those that arise in inner products. A systolic super summer of cellular design is proposed for the high-throughput performance of repeated sums of floating-point numbers. The apparatus receives pipelined inputs of streams of summands from one or many sources. The floating-point summands are converted into a fixed-point form by a sieve-like pipelined cellular packet-switching device with signal combining. The emerging fixed-point numbers are then summed in a corresponding network of extremely long accumulators (i.e., super accumulators). At the cell level, the design uses a synchronous model of VLSI. The amount of time the apparatus needs to compute an entire sum depends on the values of summands; at this architectural level, the design is asynchronous. The throughput per unit area of hardware approaches that of a tree network, but without the long wire and signal propagation delay that are intrinsic to tree networks.
The ML approach to the readable all-purpose language
Authors: C. R. Spooner
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1986)

The ideal computer language is seen as one that would be as readable as natural language, and so adaptable that it could serve as the only language a user need ever know. An approach to language design has emerged that shows promise of allowing one to come much closer to that ideal than might reasonably have been expected. Using this approach, a language referred to as ML has been developed, and has been implemented as a language-creation system in which user-defined procedures invoked at translation time translate the source to some object code. In this way the user can define both the syntax and the semantics of the source language. Both language and implementation are capable of further development. This paper describes the approach, the language, and the implementation and recommends areas for further work.
SSIM: a software levelized compiled-code simulator
Authors: L.-T. Wang, N. E. Hoover, E. H. Porter, J. J. Zasio
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper presents a new logic simulation technique that uses software levelized compiled-code (LCC) for synchronous designs. Three approaches are proposed: C source code, target machine code and interpreted code. The evaluation speed for the software LCC simulator (SSIM) is about 140,000 (gate) evaluations per second using C source code or target machine code, or 50,000 evaluations per second using interpreted code. It is about 40 to 100 times slower than the AIDA hardware LCC simulator, but is about one order of magnitude faster than a traditional software event simulator. For a 32-bit multiplier with gate activity more than 100%, experiments indicate that SSIM runs about 250 to 1,000 times faster than the AIDA event simulator that evaluates about 4,500 gates per second.
The AIS-5000 Parallel Processor
Authors: Lorenz A. Schmitt, Stephen S. Wilson
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

The AIS-5000 is a commercially available massively parallel processor which was designed to operate in an industrial environment. It has fine-grained parallelism with up to 1024 processing elements arranged in a single-instruction multiple-data (SIMD) architecture. The processing elements are arranged in a one-dimensional chain that, for computer vision applications, can be as wide as the image itself. The overall architecture of the system is described. Various components of the system are discussed, including details of the processing elements, data I/O (input/output) pathways and parallel memory organization. A virtual two-dimensional model for programming image-based algorithms for the system is also presented. Performance benchmarks are given for certain simple and complex functions.
FISHNET: A Distributed Architecture for High-Performance Local Computer Networks
Authors: Y. J. Kang, J. H. Herzog, J. Spragins
Venue: IEEE Transactions on Computers (1988)

FISHNET (facilities integrated in a shared habitat network) addresses the problem of effectively integrating a wide variety of computers, terminals, memory devices and computer peripherals in a local environment. High performance is achieved by effectively separating the high volume node-to-node data communications and the low-volume network control information. Data messages travel through point-to-point data links. Control messages, which set up data paths and coordinate network activities, use an independent multidrop control link which connects all devices. The fully distributed control mechanism allows a high degree of concurrent data transmission.
The ALGIC silicon compiler system: implementation, design experience and results
Authors: J. Schuck, N. Wehn, M Glesner, G. Kamp
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

In this paper we present the ALGIC silicon compiler system. Starting from a structural and functional description of digital VLSI circuits, the system generates automatically the corresponding layout in a full custom design style. Main components of the ALGIC system are a system monitor module, a parameterisable macrocell generator, an appropriate floorplanner with 100% routing solution including planar VDD/GND trees and a block-oriented timing verifier. One essential feature of the system is the high degree of integration between all program modules using the concept of abstract data types. The flexibility and performance of the whole system is demonstrated by real design examples in the field of DSP applications.
On the representation and querying of sets of possible worlds
Authors: Serge Abiteboul, Paris Kanellakis, Gosta Grahne
Venue: ACM SIGMOD Record (1987)

We represent a set of possible worlds using an incomplete information database. The representation techniques that we study form a hierarchy, which generalizes relations of constants. This hierarchy ranges from the very simple Codd-table, (i e , a relation of constants and distinct variables called nulls, which stand for values present but unknown), to much more complex mechanisms involving views on conditioned-tables, (i e , queries on Codd-tables together with conditions). The views we consider are the queries that have polynomial data-complexity on complete information databases. Our conditions are conjunctions of equalities and inequalities. (1) We provide matching upper and lower bounds on the data-complexity of testing containement, membership, and uniqueness for sets of possible worlds and we fully classify these problems with respect to our representation hierarchy. The most surprising result in this classification is that it is complete in &Pgr;2p, whether a set of possible worlds represented by a Codd-table is a subset of a set of possible worlds represented by a Codd-table with one conjuction of inequalities. (2) We investigate the data-complexity of querying incomplete information databases. We examine both asking for certain facts and for possible facts. Our approach is algebraic but our bounds also apply to logical databases. We show that asking for a certain fact is coNP-complete, even for a fixed first order query on a Codd-table. We thus strengthen a lower bound of [16], who showed that this holds for a Codd-table with a conjunction of inequalities. For each fixed positive existential query we present a polynomial algorithm solving the bounded possible fact problem of this query on conditioned-tables. We show that our approach is, in a sense, the best possible, by deriving two NP-completeness lower bounds for the bounded possible fact problem when the fixed query contains either negation or recursion.
Complex Integer to Complex Residue Encoding
Authors: Mike Sousa, Fred Taylor
Venue: IEEE Transactions on Computers (1986)

Recently, a new algebra for manipulating complex residue numbers was reported. Its advantage over traditional methods is a reduced complex multiplication budget. In this work a complex integer to complex residue encoder is developed for use with this new numbering system.
A system for parallel programming
Authors: K. Schwan, R. Ramnath, S. Vasudevan, D. Ogle
Venue: Proceedings of the 9th international conference on Software Engineering (1987)

The programming of efficient parallel software typically requires extensive experimentation with program prototypes. A programming system that supports rapid prototyping of parallel programs should provide high-level primitives with which programs can be explicitly, statically or dynamically tuned with respect to performance and reliability. When using such primitives, programmers should not need to interact explicitly or even be aware of the software tools involved in program construction and tuning, such as compilers, linkers, and loaders. In addition, programmers should be provided with the information about the executing program and the parallel hardware required for tuning. Such information may include monitoring data about the current or previous program or even hints regarding appropriate tuning decisions.A programming system that includes primitives and tools for program tuning is presented in this paper. The system has been implemented, and has been tested with a variety of parallel applications on a network of Unix workstations.
A perfect square root routine
Authors: E. E. McDonnell
Venue: ACM SIGAPL APL Quote Quad (1986)

To characterize a much larger effort, the design and implementation of a square root routine for IPSA APL is described. The routine is perfect in the sense that, if the result can be represented exactly, the exact result is given. If the result cannot be represented exactly, it is rounded to the nearest representable floating point number. The use of APL in designing and testing this routine is emphasized.