ppxscal/embedding_network huggingface dataset:
Joint triangulations and triangulation maps
Authors: A. Saalfeld
Venue: Proceedings of the third annual symposium on Computational geometry (1987)

In rubber-sheeting applications in cartography, it is useful to seek piecewise-linear homeomorphisms (PLH maps) between rectangular regions which map an arbitrary sequence of n points {p1, p2, &hellip;,pn} from the interior of one rectangle to a corresponding sequence {q1, q2, &hellip;, qn} of n points in the interior of the second region. This paper proves that it is always possible to find such PLH maps and describes then in terms of a joint triangulation of the domain and the range rectangular regions. One naive approach to finding a PLH map is to triangulate (in any fashion) the domain rectangle on its n points and four corners and to define a piecewise affine map on each triangle &utrif;p11p12p13 to be the unique affine map that sends the three vertices p11, p12, p13 of the triangle to the three corresponding vertices q11, q12, q13 of the image triangle &utrif;q11q12q13. Such piecewise affine maps send triangles to triangles, agree on shared edges, and thus extend globally, and will be called triangulation maps. The shortcoming of building transformations in this fashion is that the resulting triangulation map need not be one-to-one, although there is a simple test to determine if such a map is one-to-one (see Theorem 2 below). If the map is one-to-one, then the image triangles will form a triangulation of the range space; and we will have a joint triangulation. If the map is not one-to-one, then there will be folding over of triangles. It may be possible to alleviate this folding by choosing a different triangulation of the n domain points, or it may be the case that no triangulation of the n domain points will work. (See figures 5 and 6 below). We show that it will be possible, in all cases, to rectify the folding by adding appropriate additional triangulation vertex pairs {pn+1, pn+2, &hellip;, pn+m} and {qn+1, qn+2, &hellip;, qn+m} and retriangulating (see Theorem 1 below). This paper examines conditions for triangulation maps to be homeomorphisms and explores different ways of modifying triangulations and triangulation maps to make them joint triangulations and homeomorphisms. The paper concludes with a section on alternative constructive approaches to the open problem of finding joint triangulations on the original sequences of vertex pairs without augmenting those sequences of pairs. The existence proofs in this paper do not solve computational geometry problems per se; instead they permit us to formulate new computational geometry problems. The problems we pose are of interest to us because of a particular application in automated cartography.
A Space-Efficient Optimization of Call-by-Need
Authors: F. Warren Burton, Dieter Maurer, Hans-Georg Oberhauser, Reinhard Wilhelm
Venue: IEEE Transactions on Software Engineering (1987)

Call-by-need is widely regarded as an optimal (to within a constant factor) parameter passing mechanism for functional programming languages. Except for certain special cases involving higher order functions, call-by-need is optimal with respect to time. However, call-by-need is far from optimal with respect to space. We examine some of the space problems which can arise with call-by-need and other parameter passing mechanisms. A simple optimizing technique, based on work by Mycroft [1], is proposed. If it can be determined both that an expression must be evaluated eventually and that the evaluation of the expression is likely to reduce the space required by the program, then the evaluation is performed as soon as possible. This optimization does not result in optimal space performance in all cases. However, in most of the common cases where call-by-need causes a problem the proposed optimization avoids the problem. Since our technique is not always optimal, it is likely to be of greatest advantage in situations where efficiency is important but not critical. For example, functional languages with call-by-name semantics are increasingly being used as specification languages. Since such a specification is runnable, it may be used as a prototype. This makes it possible to experiment with a program and refine the specification before the implementation in the target language is started.
A Line Extraction Method for Automated SEM Inspection of VLSI Resist
Authors: B. Shu, C. C. Li, J. F. Mancuso, Y. N. Sun
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1988)

A precision digital edge-line-detection method is presented that was developed for extracting edge contours of resist lines of submicrometer width as imaged by scanning electron microscopy, as a means of inspection in integrated circuit fabrication. The method is based on a modification of the Hough transform.
A model for distributed systems based on graph rewriting
Authors: Pierpaolo Degano, Ugo Montanari
Venue: Journal of the ACM (JACM) (1987)

In our model, a graph describes a net of processes communicating through ports and, at the same time, its computation history consisting of a partial ordering of events. Stand-alone evolution of processes is specified by context-free productions. From productions and a basic synchronization mechanism, a set of context-sensitive rewriting rules that models the evolution of processes connected to the same ports can be derived. A computation is a sequence of graphs obtained by successive rewritings. The result of a finite computation is its last graph, whereas the result of an infinite computation is the limit, infinite graph defined through a completion technique based on metric spaces. A result characterizes a concurrent computation, since it abstracts from any particular interleaving of concurrent events, while in the meantime providing information about termination, partial or complete deadlocks, and fairness. Not every result is acceptable, however, but only the computations that produce a result no longer rewritable are successful. Infinite successful computations are shown to coincide with weakly fair computations, and a scheduler yielding all and only such computations is defined.
A comparison of two token-passing bus protocols
Authors: V Rego
Venue: Proceedings of the ACM SIGCOMM conference on Communications architectures protocols (1986)

A well known disadvantage of standard token-passing in ring and bus networks is the waste of channel bandwidth often seen in lightly loaded or asymmetric systems. It is possible to make use of the broadcast mechanism in token bus systems to distribute nearly up-to-date information about the state of individual stations to the entire system. One such scheme involves the determination of a randomly varying set of more active stations. These stations are given a chance to form a second logical ring above the standard logical ring that characterizes the token bus. The transmission cycles of the system can thus be made to alternate between standard token-passing and transmission cycles, and the cycles of token-passing and transmission within the logical ring of more active stations. We assume that each station makes at most one transmission when given the chance to transmit. For Poisson arrivals and otherwise general input distributions, the cycle-time distribution of the token is derived for each kind of cycle. An important random variable is the random token turnaround time seen by individual stations. For lightly loaded stations this time tends to be larger than for heavily loaded stations. The distribution of this random time, simple performance measures, and a comparative measure of stability, showing the adaptive scheme to be more stable than the standard, are obtained.
Efficient Computing of Relational Algebraic Primitives in a Database Machine Architecture
Authors: Yang-Chang Hong
Venue: IEEE Transactions on Computers (1985)

Algorithms are described and analyzed for the efficient evaluation of the primitive operators of a relational algebra on a database machine architecture. The architecture contains a RAM divided up into partitions, each partition having a separate server. Tuples from the first operand relation are stored in linked lists in the partitioned RAM via bit and pointer arrays based on hashed column values. Each tuple in the second operand relation is either deposited in the corresponding partition server queue based on the hashed value, or it is ignored. Cross-referencing involved in the operations is removed without performing a sorting operation, which significantly reduces the time complexity. A procedure is also presented for computing the optimal number of partition servers for different applications.
Large lexicons for natural language processing: utilising the grammar coding system of LDOCE
Authors: Bran Boguraev, Ted Briscoe
Venue: Computational Linguistics (1987)

This article focusses on the derivation of large lexicons for natural language processing. We describe the development of a dictionary support environment linking a restructured version of the Longman Dictionary of Contemporary English to natural language processing systems. The process of restructuring the information in the machine readable version of the dictionary is discussed. The Longman grammar code system is used to construct 'theory neutral' lexical entries. We demonstrate how such lexical entries can be put to practical use by linking up the system described here with the experimental PATR-II grammar development environment. Finally, we offer an evaluation of the utility of the grammar coding system for use by automatic natural language parsing systems.
The effect of a priori views on the social implications of computing: the case of office automation
Authors: R. A. Hirschheim
Venue: ACM Computing Surveys (CSUR) (1986)

Office automation impact has received considerable attention in the literature recently. Unfortunately, that which has appeared is diverse and contradictory. The relevant literature is reviewed, summarized, and placed in a framework containing three positions on office automation impact: optimism, pessimism, and relativism. The basic assumptions and empirical support for each position are noted and analyzed. It is proposed that these positions are based on a number of a priori views which guide the reporting and beliefs about technological impact.
Parallelism, persistence and meta-cleanliness in the symmetric Lisp interpreter
Authors: D. Gelernter, S. Jagannathan, T. London
Venue: Papers of the Symposium on Interpreters and interpretive techniques (1987)

Symmetric Lisp is a programming language designed around first-class environments, where an environment is a dictionary that associates names with definitions or values. In this paper we describe the logical structure of the Symmetric Lisp interpreter. In other interpreted languages, the interpreter is a virtual machine that evaluates user input on the basis of its own internal state. The Symmetric Lisp interpreter, on the other hand, is a simple finite-state machine with no internal state. Its role is to attach user input to whatever environment the user has specified; such environments are transparent objects created by, maintained by and fully accessible to the user. The interpreter's semantics are secondary to the semantics of environments in Symmetric Lisp: it is the environment-object to which an expression is attached, not the interpreter, that controls the evaluation of expressions.This arrangement has several consequences. Because environments in Symmetric Lisp are governed by a parallel evaluation rule, the Symmetric Lisp interpreter is a parallel interpreter. A Symmetric Lisp environment evaluates to another environment; a session with the interpreter therefore yields a well-defined environment object as its result. Users are free to write routines that manage these interpreter-created objects - routines that list the elements of a namespace, coalesce environments, maintain multiple name definitions and so on precisely because environment objects may be freely inspected and manipulated. Because a named environment may contain other named environments as elements, interpreter-created objects may be regarded as hierarchical file systems. Because of the parallel evaluation semantics of environments, the interpreter is well-suited as an interface to a concurrent, language-based computer system that uses Symmetric Lisp as its base language. We argue that - in short - a basic semantic simplification in Symmetric Lisp promises a correspondingly basic increase in power at the user-interpreter interface.
Imbalance between growth and funding in academic computing science: two trends c
Authors: D Gries, R Miller, R Ritchie, P Young
Venue: Communications of the ACM (1986)

This report is endorsed by the Computer Science Board and prepared by the board's Committee on Research Funding in Computer Science.
Resolving ambiguities in the parsing of translation grammars
Authors: M. Share
Venue: ACM SIGPLAN Notices (1988)

During the course of the Chameleon Research Project, situations arose in which ambiguities during LR parsing could not be solved by conventional deterministic means. The source of this problem and the implemented solution are presented.
The 1984 Olympic Message System: a test of behavioral principles of system design
Authors: John D. Gould, Stephen J. Boies, Stephen Levy, John T. Richards, Jim Schoonard
Venue: Communications of the ACM (1987)

There was more than athletic talent being pressed to peak performance at the 1984 Olympic Games in Los Angeles. Behind the scenes, a multilingual Olympic Message System ran round-the-clock keeping more than 10,000 athletes and officials in contact with families and friends, both far and near.
A single model for files an processes
Authors: P Singleton, K H Bennett, O P Brereton
Venue: ACM SIGOPS Operating Systems Review (1986)

In conventional operating systems, the concepts of files and processes are typically quite distinct, both in the job control language and at the internal "system call" interface. In this paper, the elimination of this dichotomy is explored, and a concept termed the "extrafile" is described which provides a single model for both processes and files (in their most common usage). The generalisation of extrafiles to include data abstraction facilities is discussed, and it is argued that an extrafile containing dependency prescriptions can provide a useful tool. An implementation of extrafiles in UNIX is described.
Transfer between word processing systems
Authors: J. Karat, L. Boyes, S. Weisgerber, C. Schafer
Venue: ACM SIGCHI Bulletin (1986)

A study was conducted to examine knowledge transfer between word processing systems. The study examined the performance of naive subjects learning to use a word processing system, as well as performance of individuals with word processing experience as they learned to use a new system. Subjects initially familiar with one system carried out a series of tasks on this system and then were asked to carry out a similar series of tasks on a second system with which they were initially unfamiliar. The second systems varied in similarity to the first system along several dimensions. Subject performance was significantly slower on the second set of tasks for all groups compared to a control group using a single system. The reduced performance is attributed primarily to 'syntactic' differences in the user interfaces of the systems.
A documentation system, philosophy and implementation at the UAB University Computer Center
Authors: Landy Manderson
Venue: Proceedings of the 15th annual ACM SIGUCCS conference on User Services (1987)

The University Computer Center at the University of Alabama at Birmingham (UAB/TUCC) supports the primary administrative functions of the University, as well as some research and academic programs. A relatively small, specialized User Services staff must provide assistance to several hundred Users with widely varying needs. The traditional methods of maintaining documentation, which require dedicated people and resources to update and enter the information, are impossible to implement here given the size and makeup of the staff and the diversity of the User base. The solution to this problem has been the development of an on-line system, called USDR (User Services Documentation Retrieval), which permits information in many forms (e.g., SCRIPT output, tapes from vendors, word processing files) to be retrieved and printed, without the need to rekey or reformat documentation into a common form or location in the system. This paper will discuss the underlying concepts of USDR and an overview of the system which is actually run at UAB/TUCC.
Impact of system response time on state anxiety
Authors: Jan L. Guynes
Venue: Communications of the ACM (1988)

Recent research has shown that user satisfaction and productivity are affected by system response time. Our purpose is to provide the results of empirical research on system response time and its effect on state anxiety. Test subjects were classified as Type A or Type B personality in order to determine if personality type had any affect on the relationship between system response time and state anxiety. The results show that both Type A and Type B personalities exhibit a statistically significant increase in state anxiety during poor or variable system response times.
Provably monotone approximations, II
Authors: Charles B. Dunham
Venue: ACM SIGNUM Newsletter (1987)

In the preceding note (Dunham, 1987) were given forms of approximation that were provably monotone for suitable arithmetic, but left open the forms(1) c + x * r (x),where r could be a rational (the Kuki form on middle p. 9) or the next to last stage in Horner's method (top p. 10). If r is positive and non-decreasing on a positive interval I, (1) is obviously monotone on I for monotone arithmetic. This leaves two cases, (a)r positive and (slowly) decreasing on I, and (b) r negative on I. We consider them separately.
JAM&mdash;just another microsequencer
Authors: W. J. Tracz, B. Boesch
Venue: Proceedings of the 18th annual workshop on Microprogramming (1985)

JAM (Just Another Microsequencer) is a flexible - dual role microcode sequencer. It supports high performance N-Way microsequencing operations (traditional 360/370 type branch address generation techniques), along with more traditional (a la AMD 2910) sequencing control over &ldquo;structured&rdquo; microcode. A unique feature of the chip is that the degree of parallel branching can be changed dynamically. That is, the chip can be reconfigured to support 2-way, 4-way, &hellip; up to 256-way branching on a 14 bit Control Store address. There are 16 microsequencing operations supported including: Next Sequential Control Store Address N-Way Branch, N-Way Call and N-Way Return (Including several submodes) Conditional Branch, Conditional Call and Conditional Return Loop Control An on-chip stack provides micro-routine nesting up to 8 levels deep. The stack is also used for looping and a special conditional branching mechanism. The chip has been designed and fabricated using 4 micron NMOS technology and has a cycle time of under 100 nanoseconds.
Faster architectural simulation through parallelism
Authors: J. W. Smith
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

Architectural simulation of complex systems is usually constrained by available computational resources. Recently, several commercial parallel processing systems have appeared with price-performance levels that make very intense simulations affordable. In this paper, we briefly review architectural simulation technology, then describe the approach used to develop a parallel architectural simulator. Performance of the parallel simulator is then experimentally characterized and analyzed. This study is one of the earliest to report measured performance of a widely-used commercial simulator, running non-trivial designs on a popular parallel computing system.
A workload characterization pipeline for models of parallel systems
Authors: William Alexander, Tom W. Keller, Ellen E. Boughter
Venue: Proceedings of the 1987 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1987)

The same application implemented on different systems will necessarily present different workloads to the systems. Characterizations of workloads intended to represent the same application, but input to models of different systems, must also differ in analogous ways. We present a hierarchical method for characterizing a workload at increasing levels of detail such that every characterization at a lower level still accurately represents the workload at higher levels. We discuss our experience in using the method to feed the same application through a workload characterization &ldquo;pipeline&rdquo; to two different models of two different systems, a conventional relational database system and a logic-based distributed database system. We have developed programs that partially automate the characterization changes that are required when the system to be modeled changes.
Monitoring Software Development Through Dynamic Variables
Authors: Carl W. Doerflinger, Victor R. Basili
Venue: IEEE Transactions on Software Engineering (1985)

This paper describes research conducted by the Software Engineering Laboratory (SEL) on the use of dynamic variables as a tool to monitor software development. The intent of the project is to identify project independent measures which may be used in a management tool for monitoring software development. This study examines several Fortran projects with similar profiles. The staff was experienced in developing these types of projects. The projects developed serve similar functions. Because these projects are similar we believe some underlying relationships exist that are invariant between the projects. These relationships, once well defined, may be used to compare the development of different projects to determine whether they are evolving the same way previous projects in this environment evolved.
The symbolic computation laboratory at UIUC
Authors: John W. Gray
Venue: ACM SIGSAM Bulletin (1987)

As I was leaving Erwin Engeler's office at the ETH during the summer of 1985, he casually asked me if I had seen their mathematics laboratory. Up to that point I had heard nothing about it, but as soon as I understood how it was organized and how it functioned, I realized that it was almost exactly what I had been looking for. Over the years, there have been numerous computer projects in the mathematics department at the UIUC, the most notable being George Francis' Apple Lab and the recently established Plato and Excel (IBM) labs. However, none of these seemed to conform with the kind of computer experience I imagined for students. I did not feel that it was the proper function of a mathematics department to teach students to program in traditional languages such as Basic or Pascal or Forth. But I did feel that algorithms were an important component of modern mathematics which deserved the same kind of emphasis that is normally accorded to proofs. What better way to understand the role of algorithms could there be than to try to implement them in computer programs? How could this be done unless it were done say in Pascal? Why not use Macsyma? I thought and still think that one could base a valid course just on this, but when I saw that the Laboratory at the ETH used projects in many different computer algebra languages, I realized that that was the methodology for which I was searching.