ppxscal/embedding_network huggingface dataset:
Accurate triangulations of deformed, intersecting surfaces
Authors: Brian Von Herzen, Alan H. Barr
Venue: Proceedings of the 14th annual conference on Computer graphics and interactive techniques (1987)

A quadtree algorithm is developed to triangulate deformed, intersecting parametric surfaces. The biggest problem with adaptive sampling is to guarantee that the triangulation is accurate within a given tolerance. A new method guarantees the accuracy of the triangulation, given a "Lipschitz" condition on the surface definition. The method constructs a hierarchical set of bounding volumes for the surface, useful for ray tracing and solid modeling operations. The task of adaptively sampling a surface is broken into two parts: a subdivision mechanism for recursively subdividing a surface, and a set of subdivision criteria for controlling the subdivision process.An adaptive sampling technique is said to be robust if it accurately represents the surface being sampled. A new type of quadtree, called a restricted quadtree, is more robust than the traditional unrestricted quadtree at adaptive sampling of parametric surfaces. Each sub-region in the quadtree is half the width of the previous region. The restricted quadtree requires that adjacent regions be the same width within a factor of two, while the traditional quadtree makes no restriction on neighbor width. Restricted surface quadtrees are effective at recursively sampling a parametric surface. Quadtree samples are concentrated in regions of high curvature, and along intersection boundaries, using several subdivision criteria. Silhouette subdivision improves the accuracy of the silhouette boundary when a viewing transformation is available at sampling time. The adaptive sampling method is more robust than uniform sampling, and can be more efficient at rendering deformed, intersecting parametric surfaces.
Abstract routing of logic networks for custom module generation
Authors: S. T. Healey, W. J. Kubitz
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper describes a switchbox-type router for custom VLSI module generation as performed by a module planner. A module is decomposed into abstract cells consisting of global routes and Boolean functional specifications. Each abstract cell is given to a cell synthesizer which generates the circuit layout and through-the-cell routing. Abstract routing for a module planner is in some sense similar to switchbox routing to the degree that all of the routes are generated internally within a rectangular boundary (routes are coming from four sides). The principle difference with respect to standard switchbox routing is at the geometric level, where a cell synthesizer generates the routing conduction layers along with circuit devices for each abstract cell within this rectangular region. The aspects of this paper which are thought to be novel contributions are 1) a relative pin assignment algorithm for the abstract cells; 2) a global routing penalty function which not only considers previous routes, but also considers gate complexity within the cells; 3) an efficient optimization algorithm for minimizing the number of tracks running through the module.
Dynamic initial allocation and local reallocation procedures for multiple stacks
Authors: D. Yun Yeh, Toshinori Munakata
Venue: Communications of the ACM (1986)

Two new procedures for manipulating multiple stacks which share sequential memory locations are discussed. The first is the dynamic initial allocation procedure in which each stack is allocated as its first element arrives rather than having every stack preallocated at the very beginning of the entire process. The second is the local reallocation procedure; in this scheme, when a stack overflows, only its neighboring stacks, rather than the entire memory area, are reorganized provided that a certain condition is satisfied. The results of simulation appear to suggest that these new approaches improve the operational performance in many applications. With appropriate modifications, these concepts may also be applied to any other type of multiple linear lists (e.g., multiple queues) sharing sequential memory locations.
Fast heuristics for minimum length rectangular partitions of polygons
Authors: C Levcopoulos
Venue: Proceedings of the second annual symposium on Computational geometry (1986)

We consider the problem of partitioning isothetic polygons into rectangles by drawing edges of minimum total length. The problem has various applications [LPRS], eg. in VLSI design when dividing routing regions into channels ([Riv1], [Riv2]). If the polygons contain holes, the problem in NP-hard [LPRS]. In this paper it is shown how solutions within a constant factor of the optimum can be computed in time &Ogr;(n log n), thus improving the previous &Ogr;(n2) time bound. An unusual divide-and-conquer technique is employed, involving alternating search from two opposite directions, and further efficiency is gained by using a fast method to sort subsets of points. Generalized Voronoi diagrams are used in combination with plane-sweeping in order to detect all &ldquo;well bounded&rdquo; rectangles, which are essential for the heuristic.
Pseudoexhaustive Test Pattern Generator with Enhanced Fault Coverage
Authors: P. Golan, O. Novak, J. Hlavicka
Venue: IEEE Transactions on Computers (1988)

A method of pseudoexhaustive test pattern generation is proposed that is suitable above all for circuits using random access scan. Two linear feedback shift registers are used to generate scan addresses and test patterns to be scanned into these addresses. It is shown that the method gives better results than random testing.
The control of a toy robot ARM: a real time programming experience
Authors: Mario A. Figueroa
Venue: ACM SIGCSE Bulletin (1987)

The problem of controlling a non-intelligent toy robot arm at the device level renders itself as a perfect candidate for real-time programming applications because it involves the coordination of a set of concurrent activities which have to satisfy strict timing and space constraints. The problem can be tackled in a non-structured fashion by using ad-hoc programming techniques or in a more structured fashion which reveals the true nature of the problem and solves it in a general way extensible to similar problems. It is our belief that since the problem involves the coordination of concurrent activities the techniques used in the design and implementation of operating systems would better suit our requirements. It is shown that using the basic concepts of concurrency and their implementation can lead to the design of a general real-time scheduler which solves this and other related problems as well.
ALGLIB, a simple symbol-manipulation package
Authors: J. M. Shearer, M. A. Wolfe
Venue: Communications of the ACM (1985)

ALGLIB&mdash;a library of procedures that perform analytic differentiation and other simple symbolic manipulations&mdash;has certain advantages over existing and more comprehensive packages. It can be implemented in a high-level language of the user's choice using a pseudocode available from the authors, and it is easily interfaced with the user's programs.
A generator of direct manipulation office systems
Authors: Scott E. Hudson, Roger King
Venue: ACM Transactions on Information Systems (TOIS) (1986)

A system for generating direct manipulation office systems is described. In these systems, the user directly manipulates graphical representations of office entities instead of dealing with these entities abstractly through a command language or menu system. These systems employ a new semantic data model to describe office entities. New techniques based on attribute grammars and incremental attribute evaluation are used to implement this data model in an efficient manner. In addition, the system provides a means of generating sophisticated graphics-based user interfaces that are integrated with the underlying semantic model. Finally, the generated systems contain a general user reversal and recovery (or undo) mechanism that allows them to be much more tolerant of human errors.
Testable Design of Single-Output Sequential Machines Using Checking Experiments
Authors: K. K. Saluja, Ramaswami Dandapani
Venue: IEEE Transactions on Computers (1986)

The problem of testing sequential machines using checking experiments is investigated. A method of modifying sequential machines by adding a controllable input is presented. A procedure is given to construct checking experiments for the modified machine and it is shown that only one output observation is sufficient to determine whether the machine is fault free.
Three approaches to heuristic search in networks
Authors: A. Bagchi, A. Mahanti
Venue: Journal of the ACM (JACM) (1985)

Three different approaches to heuristic search in networks are analyzed. In the first approach, as formulated initially by Hart, Nilsson, and Raphael, and later modified by Martelli, the basic idea is to choose for expansion that node for which the evaluation function has a minimum value. A second approach has recently been suggested by Nilsson. In this method, in contrast to the earlier one, a node that is expanded once is not expanded again; instead, a &ldquo;propagation&rdquo; of values takes place. The third approach is an adaptation for networks of an AND/OR graph &ldquo;marking&rdquo; algorithm, originally due to Martelli and Montanari. Five algorithms are presented. Algorithms A and C illustrate the first approach; PropA and PropC, the second one; and MarkA, the third one. The performances of these algorithms are compared for both admissible and inadmissible heuristics using the following two criteria: (i) cost of the solution found; (ii) time of execution in the worst case, as measured by the number of node expansions (A, C), or node &ldquo;selections&rdquo; (PropA, PropC), or arc &ldquo;markings&rdquo; (MarkA). The relative merits and demerits of the algorithms are summarized and indications are given regarding which algorithm to use in different situations.
A pragmatic system for shared persistent objects
Authors: Thomas Merrow, Jame Laursen
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1987)

This paper describes a system for sharing information in the form of objects among users of the Smalltalk-80 programming environment. The system, called Coral3, is pragmatic in that it was developed to meet the needs of specific applications. This paper describes the expectations for the system, presents factors influencing the design, outlines the implementation of Coral3, and raises questions about object-oriented database systems in general.
IOTA3: the integration of Lotus spreadsheets and APL
Authors: John R. Searle
Venue: Proceedings of the international conference on APL (1986)

A software system named IOTA3 is described which represents an integration of the popular Lotus Corporation spreadsheets (1-2-3 and Symphony) and the language APL. IOTA3 allows the spreadsheet user to extend the worksheet environment to include many of the features of the APL environment. Conversely, it allows the APL user to think of the spreadsheet as an extension of the workspace. The paper describes the various levels at which integration may be achieved, the costs and benefits of doing so, and the problems that were encountered and/or solved along the way. The system is based on the IBM Personal Computer and has been written for a number of APL implementations.
APL2&mdash;A mathematician's delight
Authors: Norman Thomson
Venue: ACM SIGAPL APL Quote Quad (1986)

The early claims of APL to the attention of the computing world included its closeness to mathematical notation and hence its power both to improve and enhance the understanding of mathematical ideas, and also to smooth the process of realizing them on a computer. The new features of APL2, notably nested arrays and operator extensions have brought programming and mathematics even closer together. Mathematical users of APL cannot but delight in the new possibilities, of which just a few are outlined in this paper.
Multikey access methods based on superimposed coding techniques
Authors: R. Sacks-Davis, A. Kent, K. Ramamohanarao
Venue: ACM Transactions on Database Systems (TODS) (1987)

Both single-level and two-level indexed descriptor schemes for multikey retrieval are presented and compared. The descriptors are formed using superimposed coding techniques and stored using a bit-inversion technique. A fast-batch insertion algorithm for which the cost of forming the bit-inverted file is less than one disk access per record is presented. For large data files, it is shown that the two-level implementation is generally more efficient for queries with a small number of matching records. For queries that specify two or more values, there is a potential problem with the two-level implementation in that costs may accrue when blocks of records match the query but individual records within these blocks do not. One approach to overcoming this problem is to set bits in the descriptors based on pairs of indexed terms. This approach is presented and analyzed.
A Socratic approach to helping novice programmers debug programs
Authors: Judith D. Wilson
Venue: Proceedings of the eighteenth SIGCSE technical symposium on Computer science education (1987)

A technique is described which can be used to help novice programmers become more self-reliant in analyzing and debugging programs. The technique requires the instructor to interact one on one with students who seek help with their programs, and has been observed informally to have beneficial results for most of these students. Although the technique has not been tested experimentally, other experimental research involving novice programmers suggests that an approach of this kind should be effective.
Statistical and Scientific Database Issues
Authors: Arie Shoshani, Harry K. T. Wong
Venue: IEEE Transactions on Software Engineering (1985)

The purpose of this paper is to summarize the research issues of statistical and scientific databases (SSDB's). It organizes the issues into four major groups: physical organization and access methods, operators, logical organization and user interfaces, and miscellaneous issues. It emphasizes the differences between SSDB's and traditional database applications, and motivates the need for new and innovative techniques for the support of SSDB's. In addition to describing current work in this field, it discusses open research areas and proposes possible approaches to their solution.
A model for a portable Ada run-time library
Authors: Rudolf Landwehr, Peter Heensel, Rami Bayan, Antonio Kung
Venue: ACM SIGAda Ada Letters (1987)

A model for a portable and efficient Ada run-time library is presented that supports Ada tasking for real-time applications. After an overview of the module structure, the interface of a compiler-independent, real-time kernel is discussed in more detail. Finally, we evaluate the model based on an implementation on Motorola MC68000.
The early years of logic programming
Authors: Robert A. Kowalski
Venue: Communications of the ACM (1988)

This firsthand recollection of those early days of logic programming traces the shared influences and inspirations that connected Edinburgh, Scotland, and Marseilles, France.
Algebraic laws for nondeterminism and concurrency
Authors: Matthew Hennessy, Robin Milner
Venue: Journal of the ACM (JACM) (1985)

Since a nondeterministic and concurrent program may, in general, communicate repeatedly with its environment, its meaning cannot be presented naturally as an input/output function (as is often done in the denotational approach to semantics). In this paper, an alternative is put forth. First, a definition is given of what it is for two programs or program parts to be equivalent for all observers; then two program parts are said to be observation congruent if they are, in all program contexts, equivalent. The behavior of a program part, that is, its meaning, is defined to be its observation congruence class. The paper demonstrates, for a sequence of simple languages expressing finite (terminating) behaviors, that in each case observation congruence can be axiomatized algebraically. Moreover, with the addition of recursion and another simple extension, the algebraic language described here becomes a calculus for writing and specifying concurrent programs and for proving their properties.
An integrated system for neural network simulations
Authors: Simon Garth, Danny Pike
Venue: ACM SIGARCH Computer Architecture News (1988)

A specialist MIMD parallel processing computer has been constructed for high speed simulation of neural network systems. Custom-designed integrated circuits have been combined with conventional microprocessors to give a machine which is highly tuned for neural network computations but which runs a wide range of commercial software packages. In addition, an operating system is presented which assists in the partitioning of problems and allows code which has been developed remotely to be run in parallel on the machine without modification. The machine is intended for research purposes, particularly where large quantities of data need to be processed (e.g. in image processing applications).
Database system support for software engineering
Authors: P. A. Berstein
Venue: Proceedings of the 9th international conference on Software Engineering (1987)

The activity of Computer-Aided Software Engineering (CASE) generates much data. Although there are few, if any, database system products with features that attend to the requirements of CASE environments, there is a flurry of research work in the database field to develop technology to meet these requirements. The purpose of this paper is to raise the level of awareness in the software engineering community about this research on database systems for design applications. It describes technical problems and proposed solutions, and provides an extensive bibliography.
An empirical validation of software cost estimation models
Authors: Chris F Kemerer
Venue: Communications of the ACM (1987)

Practitioners have expressed concern over their inability to accurately estimate costs associated with software development. This concern has become even more pressing as costs associated with development continue to increase. As a result, considerable research attention is now directed at gaining a better understanding of the software-development process as well as constructing and evaluating software cost estimating tools. This paper evaluates four of the most popular algorithmic models used to estimate software costs (SLIM, COCOMO, Function Points, and ESTIMACS). Data on 15 large completed business data-processing projects were collected and used to test the accuracy of the models' ex post effort estimation. One important result was that Albrecht's Function Points effort estimation model was validated by the independent data provided in this study [3]. The models not developed in business data-processing environments showed significant need for calibration. As models of the software-development process, all of the models tested failed to sufficiently reflect the underlying factors affecting productivity. Further research will be required to develop understanding in this area.
Different perspectives on information systems: problems and solutions
Authors: Kalle Lyytinen
Venue: ACM Computing Surveys (CSUR) (1987)

The paper puts information systems (IS) research dealing with IS problems into perspective. IS problems are surveyed and classified. Using the IS research framework suggested by Ives, Hamilton, and Davis, research into IS problems is classified into several perspectives whose relevance in coping with the problems is discussed. Research perspectives focusing on IS operations environment, IS development process, IS development organization, IS development methods, and IS theories are distinguished. The paper concludes with suggestions for future research and how to deal with IS problems in practice.
Evolution of an organizational interface: the new business department at a largeinsurance firm
Authors: Andrew Clement, C. C. Gotlieb
Venue: ACM Transactions on Information Systems (TOIS) (1987)

This paper describes how the work organization and computer system of the New Business Department at a large life insurance firm have interacted and evolved over time. The dynamics of interaction are explained largely in terms of the economic incentive to reduce the length of transaction-processing chains and the more political goal of extending managerial control. It is argued that examining the interaction of organizations and computer systems can contribute to a better theoretical understanding of the development of large computer systems and offer guidance to designers of user-computer interfaces. A graphical technique for depicting organizational interfaces is presented.
Reimplementing the Cedar file system using logging and group commit
Authors: R. Hagmann
Venue: Proceedings of the eleventh ACM Symposium on Operating systems principles (1987)

The workstation file system for the Cedar programming environment was modified to improve its robustness and performance. Previously, the file system used hardware-provided labels on disk blocks to increase robustness against hardware and software errors. The new system does not require hardware disk labels, yet is more robust than the old system. Recovery is rapid after a crash. The performance of operations on file system metadata, e.g., file creation or open, is greatly improved. The new file system has two features that make it atypical. The system uses a log, as do most database systems, to recover metadata about the file system. To gain performance, it uses group commit, a concept derived from high performance database systems. The design of the system used a simple, yet detailed and accurate, analytical model to choose between several design alternatives in order to provide good disk performance.
Conformity analysis for communication protocols
Authors: N Liu
Venue: ACM SIGCOMM Computer Communication Review (1986)

In this paper we propose a methodology for conformity analysis of communication protocols. By conformity analysis it is meant to demonstrate that a protocol does indeed provide the service for which it is intended. We specify both a protocol and its service by a CSP (Communicating Sequential Processes) based language. To perform the conformity analysis we develop a transformation system to extract from a CSP process the communication sequences that may arise during its execution, and to express these sequences in terms of behavior expressions in CCS (Calculus of Communicating Systems). By performing algebraic manipulations and the equivalence proof on these expressions, we can show that the external behavior of a protocol conforms to its intended service. A version of the Alternating Bit Protocol is used to demonstrate the feasibility of the methodology.