ppxscal/embedding_network huggingface dataset:
Creating multisided rational B&eacute;zier surfaces using base points
Authors: Joe Warren
Venue: ACM Transactions on Graphics (TOG) (1992)

Rational Be&acute;zier surfaces provide an effective tool for geometric design. One aspect of the theory of rational surfaces that is not well understood is what happens when a rational parameterization takes on the value (0/0, 0/0, 0/0) for some parameter value. Such parameter values are called base points of the parameterization. Base points can be introduced into a rational parameterization in Be&acute;zier form by setting weights of appropriate control points to zero. By judiciously introducing base points, one can create parameterizations of four-, five- and six-sided surface patches using rational Be&acute;zier surfaces defined over triangular domains. Subdivision techniques allow rendering and smooth meshing of such surfaces. Properties of base points also lead to a new understanding of incompatible edge twist methods such as Gregory's patch.
Context dependent modeling of phones in continuous speech using decision trees
Authors: L. R. Bahl, P. V. de Soutza, P. S. Gopalakrishnan, D. Nahamoo, M. A. Picheny
Venue: Proceedings of the workshop on Speech and Natural Language (1991)

In a continuous speech recognition system it is important to model the context dependent variations in the pronunciations of words. In this paper we present an automatic method for modeling phonological variation using decision trees. For each phone we construct a decision tree that specifies the acoustic realization of the phone as a function of the context in which it appears. Several thousand sentences from a natural language corpus spoken by several talkers are used to construct these decision trees. Experimental results on a 5000-word vocabulary natural language speech recognition task are presented.
Debugging Larch Shared Language Specifications
Authors: S. J. Garland, J. V. Guttag, J. J. Horning
Venue: IEEE Transactions on Software Engineering (1990)

The checkability designed into the LSL (Larch shared language) is described, and two tools that help perform the checking are discussed. LP (the Larch power) is the principal debugging tool. Its design and development have been motivated primarily by work on LSL, but it also has other uses (e.g. reasoning about circuits and concurrent algorithms). Because of these other uses, and because they also tend to use LP to analyze Larch interface specifications, the authors have tried not to make LP too LSL-specific. Instead, they have chosen to build a second tool, LSLC (the LSL checker), to serve as a front-end to LP. LSLC checks the syntax and static semantics of LSL specifications and generates LP proof obligations from their claims. These proof obligations fall into three categories: consistency (that a specification does not contradict itself), theory containment (that a specification has intended consequences), and relative completeness (that a set of operators is adequately defined). An extended example illustrating how LP is used to debug LSL specifications is presented.
Clock routing for high-performance ICs
Authors: Michael A. B. Jackson, Arvind Srinivasan, E. S. Kuh
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

In this paper we focus on routing techniques for optimizing clock signals in small-cell (e.g., standard-cell, sea-of gate, etc.&hellip;) ASICs. In previously reported work, the routing of the clock net has been performed using ordinary global routing techniques based on a minimum spanning or minimal Steiner tree that have little understanding of clock routing problems. We present a novel approach to clock routing that all but eliminates clock skew and yields excellent phase delay results for a wide range of chip sizes, net sizes (pin count), minimum feature sizes, and pin distributions on both randomly created and standard industrial benchmarks. For certain classes of pin distributions we have proven theoretically and observed experimentally a decrease in skew with an increase in net size. In practice, we have observed a two to three order magnitude reduction in skew when compared to a minimum rectilinear spanning tree.
An Optimal Systolic Array for the Algebraic Path Problem
Authors: Paul S. Lewis, Sun-Yuan Kung
Venue: IEEE Transactions on Computers (1991)

A systolic array design for the algebraic path problem (APP) is presented that is both simpler and more efficient than previously proposed configurations. This array uses N/sup 2/ orthogonally connected processing elements and requires 2N I/O connections. Total computation time is 5N-2, which is the minimum time possible in a systolic implementation. The data pipelining rate is one, so no pipeline interleave is required. For multiple problem instances a block pipeline rate of N can be achieved, which is optimal for an array of N/sup 2/ processing elements.
Software engineering from a practical perspective
Authors: Motamarri Saradhi
Venue: ACM SIGSOFT Software Engineering Notes (1992)

The development of software is a marathon feat. Software Quality Assurance is a much more difficult and challenging task. Further, putting the software for live use, is a still more complex affair. These matters are not trivial for successful and appropriate exploitation of computers and Information Technology, rather they are the central issues one must answer first. Motivated by the ongoing discussions on a plenty of issues related to software, (software technology!) including standards and quality assurance, I am translating my experiences as the mentioned issues are duly represented in my systems development projects. Perhaps, this is an attempt to bring to light the prominent but less addressed points, especially that are lying at the interface of the several disciplines related to software creation. I present a generic structure of Systems Development Process (SDP) from a practical view point. The presentation will outline the framework of SDP, and the environment in which it takes place to illustrate the line of thinking that has influenced the creation of successful application systems developed in several domains.
The standards factor: two for the price of one
Authors: Pat Billingsley
Venue: ACM SIGCHI Bulletin (1991)

Regular readers of Standards Action, a bi-monthly publication that lists draft national and international standards available for comment, may have seen the following notice above the listing for some draft standards in the "Information Technology" section:NOTE: This draft standard is being submitted simultaneously as an International Standard and an American National Standard.
A System Architecture for Fault Tolerance in Concurrent Software
Authors: Massimo Ancona, Gabriella Dodero, Vittoria Gianuzzi, Andrea Clematis, Eduardo B. Fernandez
Venue: Computer (1990)

A system architecture called the recovery metaprogram (RMP) is proposed. It separates the application from the recovery software, giving programmers a single environment that lets them use the most appropriate fault-tolerance scheme. To simplify the presentation of the RMP approach, it is assumed that the fault model is limited to faults originating in the application software, and that the hardware and kernel layers can mask their own faults from the RMP. Also, relationships between backward and forward error recovery are not considered. Some RMP examples are given, and a particular RMP implementation is described.
Usability metrics and methodologies
Authors: Jakob Nielsen
Venue: ACM SIGCHI Bulletin (1991)

The British Computer Society's human-computer interaction specialist group sponsored a one-day seminar on usability metrics and methodologies in connection with its 1990 annual meeting in London. The seminar was organized by Nigel Bevan from the National Physical Laboratory and attracted an audience of about 80 people. The lively discussions during the seminar and the tea breaks indicated substantial interest in the issues of usability engineering.
3,000,000 Queens in less than one minute
Authors: Rok Sosic, Jun Gu
Venue: ACM SIGART Bulletin (1991)

The n - queens problem is a classical combinatorial search problem. In this paper we give a linear time algorithm for this problem. The algorithm is an extension of one of our previous local search algorithms [3, 4, 6]. On an IBM RS 6000 computer, this algorithm is capable of solving problems with 3,000,000 queens in approximately 55 seconds.
Specifying gestures by example
Authors: Dean Rubine
Venue: ACM SIGGRAPH Computer Graphics (1991)

Gesture-Based interfaces offer an alternative to traditional keyboard, menu, and direct manipulation interfaces. The ability to specify objects, an operation, and additional parameters with a single intuitive gesture appeals to both novice and experienced users. Unfortunately, gesture-based interfaces have not been extensively researched, partly because they are difficult to create. This paper describes GRANDMA, a toolkit for rapidly adding gestures to direct manipulation interfaces. The trainable single-stroke gesture recognizer used by GRANDMA is also described.
Computer Architecture in the 1990s
Authors: Harold S. Stone, John Cocke
Venue: Computer (1991)

Some of the technology that will drive the advances of the 1990s are explored. A brief tutorial is given to explain the fundamental speed limits of metal interconnections. The advantages and disadvantages of optical interconnections and where they may be used are discussed in some detail. Trends in speeding up performance by increasing data-path width and by increasing the number of operations performed are reviewed, and questions of efficiency are examined. The advent of super reliable machines produced at very low cost by replicating entire processors is examined.
Querying of Executable Software Specifications
Authors: Giancarlo Nota, Giuliano Pacini
Venue: IEEE Transactions on Software Engineering (1992)

The availability of executable specification languages allows testing to be carried out soon after or concurrently with the requirements specification phase. In addition, it becomes possible to use these languages for rapid prototyping, making it possible to gather information on properties of the specified target system including its behavior in response to external events. The inspection of software behavior is viewed as the querying of executable specifications. A language RSQ is defined for the purpose of constructing queries against executable specifications expressed in RSF, a language for the description of systems with time constraints. A query is able to single out a subclass of possible behaviors based on properties supplied by the query. The integration of RSQ with RSF enhances the analytical abilities of the software designer and developer.
Analogy by generalization&mdash;and the quest of the grail
Authors: Antonio L. Furtado
Venue: ACM SIGPLAN Notices (1992)

It is argued that a powerful kind of reasoning by analogy is provided by combining unification with most specific generalization. A revised version of an existing algorithm to compute the most specific generalization of terms is presented, which decides correctly whether or not new variables should be introduced in each case. Both unification and most specific generalization are extended to frames. It is indicated, as a research goal, the extension of these processes to more complex forms of knowledge representation, a particularly challenging example being the comparison of the structures of literary narratives.
The relation-based knowledge representation of King Kong
Authors: Samuel Bayer, Marc Vilain
Venue: ACM SIGART Bulletin (1991)

This paper presents an overview of the knowledge representation facilities of King Kong a transportable natural language system. The thrust of the paper is towards demonstrating how the particulars of Kong's representation language support the processing of key phenomena of natural language. To this extent, we cover Kong's terminological hierarchies; the logical language in which Kong encodes utterance meanings; and the query evaluator that interfaces Kong to expert system back ends. We focus particularly on King Kong's innovative treatment of relations, as this treatment provides the system with much of its language analysis strengths.
Efficient algorithms for dynamic allocation of distributed memory
Authors: Tom Leighton, Eric J. Schwabe
Venue: Proceedings of the 32nd annual symposium on Foundations of computer science (1991)

The problem of dynamically allocating and deallocating local memory resources among multiple users in a parallel or distributed system is considered. The goal is to devise an online allocation algorithm that minimizes both the fraction of unused space due to fragmentation of the memory and the slowdown needed by the system to service user requests. The problem is solved in near-optimal fashion by devising an algorithm that allows the memory to be used to 100% of capacity despite the fragmentation and guarantees that service delays will always be within a constant factor of optimal. The algorithm is completely online (no foreknowledge of user activity is assumed) and can accommodate any sequence of insertions and deletions by the users which does not violate global memory bounds. The results have applications in the domain of parallel disk allocation.
Efficient implementation of bit-vector operation in Common Lisp
Authors: Henry G. Baker
Venue: ACM SIGPLAN Lisp Pointers (1990)

In this paper we show various techniques for the efficient implementation of the various functions of Common Lisp involving bit-vectors and bit-arrays. Bit-vectors are extremely useful for computing everything from the Sieve of Eratosthenes for finding prime numbers, to the representation of sets and relations, to the implementation of natural language parsers, to the performance of flow analysis in an optimizing compiler, to the manipulation of complex communication codes like those used in facsimile machines. However, the efficient manipulation of bit-vectors on modern computers represents a curious point on the spectrum of data processing tasks. On the one hand, the possibility of packing many bits within a single computer word and operating on all of them in parallel offers a potential for speedup not usually available for other types of tasks. On the other hand, the lack of the ability to efficiently manipulate single bits because of addressing schemes tuned for larger objects can actually reduce the speed of operating on bits. As a result of these observations, it should be obvious that no simple, automatic techniques such as "in-lining" (procedure integration) or "loop unrolling" of the obvious serial algorithms will produce the kinds of efficiency we are seeking. For these reasons, the efficient implementation of bit-vector operations requires special-case code, and is an interesting challenge in ingenuity and engineering.
Fault tolerance using group communication
Authors: M. Frans Kaashoek, Andrew S. Tanenbaum
Venue: ACM SIGOPS Operating Systems Review (1991)

We propose group communication as an efficient mechanism to support fault tolerance. Our approach is based on an efficient reliable broadcast protocol that requires on average only two messages per broadcast. To illustrate our approach we will describe how the task bag model can be made fault-tolerant using group communication.
A template matcher for robust NL interpretation
Authors: Eric Jackson, Douglas Appelt, John Bear, Robert Moore, Ann Podlozny
Venue: Proceedings of the workshop on Speech and Natural Language (1991)

In this paper, we describe the Template Matcher, a system built at SRI to provide robust natural-language interpretation in the Air Travel Information System (ATIS) domain. The system appears to be robust to both speech recognition errors and unanticipated or difficult locutions used by speakers. We explain the motivation for the Template Matcher, describe in general terms how it works in comparison with similar systems, and examine its performance. We discuss some limitations of this approach, and sketch a plan for integrating the Template Matcher with an analytic parser, which we believe will combine the advantages of both.
'Overturned-Stairs' Adder Trees and Multiplier Design
Authors: Zhi-Jian (Alex) Mou, Francis Jutand
Venue: IEEE Transactions on Computers (1992)

Wallace trees are the theoretically fastest multioperand adders. However, their complex interconnections do not permit practical implementations. A family of Overturned-Stairs trees which achieve the same speed performance as equivalent Wallace trees in many cases, but require a simple and regular interconnection scheme is introduced. These trees can be designed in a systematic way and laid out regularly in a VLSI circuit. A comparison is made between various trees to provide useful indexes for a practical design. The design of a 16*16 2's complement parallel multiplier using Overturned-Stairs trees is studied as an illustration.
On playing &ldquo;Twenty Questions&rdquo; with a liar
Authors: Aditi Dhagat, Peter Gács, Peter Winkler
Venue: Proceedings of the third annual ACM-SIAM symposium on Discrete algorithms (1992)

Motivated by the problem of searching in the presence of adversarial errors, we consider a version of the game &ldquo;Twenty Questions&rdquo; played on the set {0,&hellip;,N-1} where the player giving answers may lie in her answers. The questioner is allowed Q questions and the responder may lie in upto [rQ] of the answers, for some fixed and previously known fraction r. Under three different models of this game and for two different question classes, we give precise conditions (i.e. tight bounds on r and, in most cases, optimal bounds on Q under which the questioner has a winning strategy in the game.
GCODE: a revised standard for a graph representation for functional programs
Authors: Mike Joy, Tom Axford
Venue: ACM SIGPLAN Notices (1991)

The data structures used in the authors' functional language graph reduction implementations are described, together with a standard notation for representing the graphs in a textual format. The data structures employed are tailored to the intermediate functional language FLIC. The textual format is designed to be transmittable easily across networks. This document details the changes in the notation that have evolved since the previous specification [1] was published.
The Many Faces of Consensus in Distributed Systems
Authors: John Turek, Dennis Shasha
Venue: Computer (1992)

Known results regarding consensus among processors are surveyed and related to practice. The ideas embodied in the various proofs are explained. The goal is to give practitioners some sense of the system hardware and software guarantees that are required to achieve a given level of reliability and performance. The survey focuses on two categories of failures: fail-stop failures, which occur when processors fail by stopping; and Byzantine failures, which occur when processors fail by acting maliciously.
Neural-Network-Based Fuzzy Logic Control and Decision System
Authors: Chin-Teng Lin, C. S. George Lee
Venue: IEEE Transactions on Computers (1991)

A general neural-network (connectionist) model for fuzzy logic control and decision systems is proposed. This connectionist model, in the form of feedforward multilayer net, combines the idea of fuzzy logic controller and neural-network structure and learning abilities into an integrated neural-network-based fuzzy logic control and decision system. A fuzzy logic control decision network is constructed automatically by learning the training examples itself. By combining both unsupervised (self-organized) and supervised learning schemes, the learning speed converges much faster than the original backpropagation learning algorithm. The connectionist structure avoids the rule-matching time of the inference engine in the traditional fuzzy logic system. Two examples are presented to illustrate the performance and applicability of the proposed model.
Design data management in a CAD framework environment
Authors: Lung-Chun Liu
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

The design data management system is a crucial component in an IC CAD framework environment as the design involves large volume of data in diversified formats. This article identifies requirements for such a system and presents the approaches that a design framework utilizes to support these requirements. Several aspects, including a library model, version control, configuration management, access control, and history tracking, are explored and feasible solutions are proposed. The system is currently under development and will be released in the next generation of the Cadence design framework.
Pascal with internet primitives for pedagogy
Authors: Paul M. Mullins
Venue: ACM SIGCSE Bulletin (1991)

An extension to standard Pascal which includes the kind of Internet primitives necessary to support meaningful programming projects for a networks course is described. The new language, Pascal with Internet Primitives (PIP), is a simple modification of the standard Pascal language providing interprocess communication library routines. The PIP use requests and uses networked services which are presented as Pascal-style files. Primitives calls are handled transparently by a compiler preprocessor and an extended run-time environment. This simple file-based extension allows the student to immediately write pedagogically useful programs using pre-planned Internet facilities. More complex assignments, such as the development of network servers, protocols, et cetera, are possible with increased awareness of primitive function calls. Increased awareness can come about gradually as a part of the course and occurs within the syntactically familiar setting of Pascal. This approach allows presentation of programming essentials as meaningful excursions, rather than as a separate topic. Design, implementation, and use of the system are described.
Symbolic Boolean manipulation with ordered binary-decision diagrams
Authors: Randal E. Bryant
Venue: ACM Computing Surveys (CSUR) (1992)

Ordered Binary-Decision Diagrams (OBDDs) represent Boolean functions as directed acyclic graphs. They form a canonical representation, making testing of functional properties such as satisfiability and equivalence straightforward. A number of operations on Boolean functions can be implemented as graph algorithms on OBDD data structures. Using OBDDs, a wide variety of problems can be solved through symbolic analysis. First, the possible variations in system parameters and operating conditions are encoded with Boolean variables. Then the system is evaluated for all variations by a sequence of OBDD operations. Researchers have thus solved a number of problems in digital-system design, finite-state system analysis, artificial intelligence, and mathematical logic. This paper describes the OBDD data structure and surveys a number of applications that have been solved by OBDD-based symbolic analysis.
Task allocation in data flow multiprocessors: an annotated bibliography
Authors: Camille C. Price
Venue: ACM SIGARCH Computer Architecture News (1991)

The performance of data flow multiprocessors depends to a large extent on the methods used to partition a data flow program and assign the resulting computational tasks among the processors. We cite significant contributions to the field of data flow computing, and categorize these efforts according to the granularity of the partitions and by whether task allocation is static (performed at compile time) or dynamic (performed during execution of the program). Each reference is accompanied by a brief description of the task allocation techniques used in the system.