ppxscal/embedding_network huggingface dataset:
Deformable curve and surface finite-elements for free-form shape design
Authors: George Celniker, Dave Gossard
Venue: Proceedings of the 18th annual conference on Computer graphics and interactive techniques (1991)

The finite element method is applied to generate primitives that build continuous deformable shapes designed to support a new free-form modeling paradigm. The primitives autonomously deform to minimize an energy functional subject to user controlled geometric constraints and loads. The approach requires less user input than conventional free-form modeling approaches because the shape can be parameterized independently of the number of degrees of freedom needed to describe the shape.Both a curve and a surface finite element are developed. The properties of these geometric primitives have been engineered to support an interactive three phase approach for defining very fair free-form shapes as found in automobiles, ship hulls and car bodies. The shape's character lines or folds and edges are defined with deformable curve segments. These character lines are then "skinned" with a deformable surface. The final shape is sculpted interactively by applying loads to the surface to control the surface shape between character lines. Shapes created with this technique enjoy the advantage that they are already meshed for further finite element analysis.
Hypertext'91 trip report
Authors: Lynda Hardman
Venue: ACM SIGCHI Bulletin (1992)

This was the third US-based hypertext conference (following on from the '87 and '89 conferences) with 575 participants, 450 from the USA and 125 from the rest of the world.
Standard bases and some computations in rings of power series
Authors: Thomas Becker
Venue: Journal of Symbolic Computation (1990)

We prove the existence of standard bases and unique remainder for ideals in power series rings with respect to arbitrary admissible term order. Several characterizations of standard bases are shown to be equivalent. We give an algorithm that computes the unique remainder of a power series modulo a principal ideal with respect to the lexicographical term order. The algorithm applies to the Weierstrass preparation theorem.
Learning HCI design: mentoring project groups in a course on human-computer interaction
Authors: B. Hartfield, Terry Winograd, John Bennett
Venue: ACM SIGCSE Bulletin (1992)

We describe the role of mentors in an experimental course on human-computer interaction (HCI) taught in the Computer Science Department at Stanford University for the past two years. Students practice design within the course by collaborating in small groups on 12-week projects, in which they analyze a work environment, design and implement a prototype user interface, and evaluate the prototype with project clients. As part of our experiment in providing contact with the world of practical design, we invited people from local industry to serve as mentors for the student groups. These unpaid volunteers have been important adjuncts in guiding students as they developed their HCI projects. We discuss: the background for the projects; the role of mentors in the learning process; what is required of mentors and what benefits they get; how to support the mentoring process; and what we have learned from the experience so far. We consider mentors to be a critical part of the design project within the course, and we welcome a sharing of experience with other people who may have developed similar courses where mentors played an important role.
A simple output-sensitive algorithm for hidden surface removal
Authors: Micha Sharir, Mark H. Overmars
Venue: ACM Transactions on Graphics (TOG) (1992)

We derive a simple output-sensitive algorithm for hidden surface removal in a collection of n triangles in space for which a (partial) depth order is known. If k is the combinatorial complexity of the output visibility map, the method runs in time Onklog n . The method is extended to work for other classes of objects as well, sometimes with even improved time bounds. For example, we obtain an algorithm that performs hidden surface removal for n (nonintersecting) balls in time On3/2logn+k .
A Study of Odd Graphs as Fault-Tolerant Interconnection Networks
Authors: Arif Ghafoor, Theodore R. Bashkow
Venue: IEEE Transactions on Computers (1991)

Odd graphs are analyzed to determine their suitable in designing interconnection networks. These networks are shown to possess many features that make them competitive with other architectures, such as ring, star, mesh, the binary n-cube and its generalized form, the chordal ring, and flip-trees. Among the features are small internode distances, a lighter density, simplicity in implementing various self-routing algorithms (both for faulty and nonfaulty networks), capability of maximal fault tolerance, strong resilience, and good persistence. The routing algorithms (both for the faulty and fault-free networks) do not require any table lookup mechanism, and intermediate nodes do not need to modify the message. These graphs are shown to have a partitioning property that is based on Hadamard matrices and can be effectively used for a system's expansion and self-diagnostics.
Prolog-Based Meta-rules for Relational Database Representation and Manipulation
Authors: Timo Niemi, Kalervo Järvelin
Venue: IEEE Transactions on Software Engineering (1991)

A Prolog-based experimental system for relational databases that is not defined from the viewpoint of any specific relational topic is proposed. The idea is that the experimental system can be used in many different contexts such as query optimization, data restructuring and database design. The definition is based entirely on the theoretical foundations of the relational model. The experimental system offers a well-defined environment for studying how other systems can be integrated with relational databases. The use of the experimental system in the context of different approaches to deductive databases is considered.
CL/TB an allegro common Lisp programming interface for TransBase
Authors: J. Kempe, T. Lenz, B. Freitag, H. Shütz, G. Specht
Venue: ACM SIGPLAN Notices (1991)

This paper presents the "CL/TB" programming interface for Allegro CL (an implementation of Common Lisp.) and the relational database management system TransBase. The interface and its components are presently running on SUN UNIX workstations but can easily be installed on all major UNIX workstations. CL/TB supports data manipulation, data definition, and data control. The database system is called by sending SQL-statements as strings from Allegro CL. Basically, CL/TB offers the prominent services of the underlying TransBase programming interface (TBX). The services are successfully integrated into the functional environment of Lisp and enhanced by many additional features to improve ease of use, programming security, and error support. Thus operating on a database system via CL/TB is easy even for unexperienced users. Furthermore CL/TB is compatible with the relational algebra R-Lisp.Structure, design, implementation, and performance data axe presented and its application is illustrated by examples.
A Parallel Time/Hardware Tradeoff T.H=O(2/sup n/2/) for the Knapsack Problem
Authors: Afonso G. Ferreira
Venue: IEEE Transactions on Computers (1991)

A parallel algorithm for solving the knapsack problem on a single-instruction, multiple-data machine with shared memory is presented. The shared memory allows concurrent reading while concurrent writing is forbidden. The knapsack problem is of size n, which the algorithm solves in time T=O(n*(2/sup n/2/)/sup epsilon /) when P=O((2/sup n/2/)/sup (1- epsilon )/), 0>or= epsilon >or=1, processors are available. It is shown that the algorithm needs S=O(2/sup n/2/) memory space in a shared memory. If H (for hardware) is the number of processors plus the number of memory cells used by a parallel algorithm, the parallel algorithm takes a linear time proportional to (n/2) to find a solution when P=O(2/sup n/2/), leading a tradeoff T*H=O(2/sup n/2/).
A faster algorithm for constructing minimal perfect hash functions
Authors: Edward A. Fox, Qi Fan Chen, Lenwood S. Heath
Venue: Proceedings of the 15th annual international ACM SIGIR conference on Research and development in information retrieval (1992)

Our previous research on one-probe access to large collections of data indexed by alphanumeric keys has produced the first practical minimal perfect hash functions for this problem. Here, a new algorithm is described for quickly finding minimal perfect hash functions whose specification space is very close to the theoretical lower bound, i.e., around 2 bits per key. The various stages of processing are detailed, along with analytical and empirical results, including timing for a set of over 3.8 million keys that was processed on a NeXTstation in about 6 hours.
Covert Flow Trees: A Visual Approach to Analyzing Covert Storage Channels
Authors: Richard A. Kemmerer, Phillip A. Porras
Venue: IEEE Transactions on Software Engineering (1991)

The authors introduce a technique for detecting covert storage channels using a tree structure called a covert flow tree (CFT). CFTs are used to perform systematic searches for operation sequences that allow information to be relayed through attributes and eventually detected by a listening process. When traversed, the paths of a CFT yield a comprehensive list of operation sequences which support communication via a particular resource attribute. These operation sequences are then analyzed and either discharged as benign or determined to be covert communication channels. Algorithms for automating the construction of CFTs and potential covert channel operation sequences are presented. To illustrate this technique, two example systems are analyzed and their results compared to two currently accepted analysis techniques performed on identical systems. This comparison shows that the CFT approach not only identified all covert storage channels found by the other analysis techniques, but discovered a channel not detected by the other techniques.
A reservation based cyclic server queue with limited service
Authors: Duan-Shin Lee, Bhaskar Sengupta
Venue: Proceedings of the 1992 ACM SIGMETRICS joint international conference on Measurement and modeling of computer systems (1992)

In this paper, we examine a problem which is an extension of the limited service in a queueing system with a cyclic server. In this service mechanism, each queue, after receiving service in cycle j, makes a reservation for its service requirement in cycle j + 1. In this paper, we consider symmetric case only, i.e., the arrival rates to all the queues are the same. The main contribution to queueing theory is that we propose an approximation for the queue length and sojourn-time distributions for this discipline. Most approximate studies on cyclic queues, which have been considered before, examine the means only. Our method is an iterative one, which we prove to be convergent by using stochastic dominance arguments. We examine the performance of our algorithm by comparing it to simulations and show that the results are very good.
The future evolution of Fortran
Authors: Lawrie Schonfelder
Venue: ACM SIGPLAN Fortran Forum (1991)

This is a working paper of ISO/IEC JTC1/SC22/WG5 that was presented to the WG5 meeting at Lund (Sweden) in June 1991.
Eye Monitor: Microcomputer-Based Instrument uses an Internal Mode to Track the Eye
Authors: Glenn A. Myers, Keith R. Sherman, Lawrence Stark
Venue: Computer (1991)

An eye monitor whose design is inspired by the human visual system is presented. The monitor incorporates an internal representation or model of what the eye looks like to a video camera. The system can measure the position of the eyes and the size of the pupil in the presence of interfering noise and in patients wearing eyeglasses or contact lenses, and it tolerates defocusing due to small movements in depth by the patient. The system makes real-time correction for head and eye movements while measuring pupillary responses to controlled light stimuli. The design and software and hardware components are described, and some applications are noted. Its use for early clinical detection of visual diseases by objectively measuring pupillary responses to carefully controlled light stimuli is examined as an example. Some general observations about using computers in medical measurements are made.
Thinning Methodologies-A Comprehensive Survey
Authors: Louisa Lam, Seong-Whan Lee, Ching Y. Suen
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1992)

A comprehensive survey of thinning methodologies is presented. A wide range of thinning algorithms, including iterative deletion of pixels and nonpixel-based methods, is covered. Skeletonization algorithms based on medial axis and other distance transforms are not considered. An overview of the iterative thinning process and the pixel-deletion criteria needed to preserve the connectivity of the image pattern is given first. Thinning algorithms are then considered in terms of these criteria and their modes of operation. Nonpixel-based methods that usually produce a center line of the pattern directly in one pass without examining all the individual pixels are discussed. The algorithms are considered in great detail and scope, and the relationships among them are explored.
Hiding memory latency using dynamic scheduling in shared-memory multiprocessors
Authors: Kourosh Gharachorloo, Anoop Gupta, John Hennessy
Venue: ACM SIGARCH Computer Architecture News (1992)

The large latency of memory accesses is a major impediment to achieving high performance in large scale shared-memory multi-processsors. Relaxing the memory consistency model is an attractive technique for hiding this latency by allowing the overlap of memory accesses with other computation and memory accesses. Previous studies on relaxed models have shown that the latency of write accesses can be hidden by buffering writes and allowing reads to bypass pending writes. Hiding the latency of reads by exploiting the overlap allowed by relaxed models is inherently more difficult, however, simply because the processor depends on the return value for its future computation. This paper explores the use of dynamically scheduled processors to exploit the overlap allowed by relaxed models for hiding the latency of reads. Our results are based on detailed simulation studies of several parallel applications. The results show that a substantial fraction of the read latency can be hidden using this technique. However, the major improvements in performance are achieved only at large instruction window sizes.
Architectural Support for Designing Fault-Tolerant Open Distributed Systems
Authors: Salim Hariri, Alok Choudhary, Behcet Sarikaya
Venue: Computer (1992)

An overview of the main techniques for designing fault-tolerant software and hardware systems is provided. The important features of the building blocks (computers, memories, buses, etc.) that can support an efficient implementation of fault-tolerant open distributed systems (FTODSs) are identified. Taking into account the features of these building blocks, an organization for FTODS is proposed. A distributed voting algorithm and a two-level hierarchy for permanent memory are key elements in this scheme. The algorithms needed for transferring files and synchronizing the concurrent activities of the computing modules and for recovery-are ISO standard protocols. Low-level voting and recovery algorithms that can run as a layer of software above the operating system make the open distributed system an attractive environment for applying fault-tolerant techniques.
Approximate Reasoning About the Semantic Effects of Program Changes
Authors: M. Moriconi, T. C. Winkler
Venue: IEEE Transactions on Software Engineering (1990)

It is pointed out that the incremental cost of a change to a program is often disproportionately high because of inadequate means of determining the semantic effects of the change. A practical logical technique for finding the semantic effects of changes through a direct analysis of the program is presented. The programming language features considered include parametrized modules, procedures, and global variables. The logic described is approximate in that weak (conservative) results sometimes are inferred. Isolating the exact effects of a change is undecidable in general. The basis for an approximation is a structural interpretation of the information-flow relationships among program objects. The approximate inference system is concise, abstract, extensible, and decidable, giving it significant advantages over the main alternative formalizations. The authors' implementation of the logic records the justification for each dependency to facilitate the interpretation of results.
An implementation of a divide and conquer algorithm for the unitary eigen problem
Authors: G. S. Ammar, L. Reichel, D. C. Sorensen
Venue: ACM Transactions on Mathematical Software (TOMS) (1992)

We present a FORTRAN implementation of a divide-and-conquer method for computing the spectral resolution of a unitary upper Hessenberg matrix H. Any such matrix H of order n, normalized so that its subdiagonal elements are nonnegative, can be written as a product of n&minus;1 Givens matrices and a diagonal matrix. This representation, which we refer to as the Schur parametric form of H, arises naturally in applications such as in signal processing and in the computation of Gauss-Szego quadrature rules. Our programs utilize the Schur parametrization to compute the spectral decomposition of H without explicitly forming the elements of H. If only the eigenvalues and first components of the eigenvectors are desired, as in the applications mentioned above, the algorithm requires only O(n2) arithmetic operations. Experimental results presented indicate that the algorithm is reliable and competitive with the general QR algorithm applied to this problem. Moreover, the algorithm can be easily adapted for parallel implementation. &mdash;Authors' Abstract
Self-testing polynomial functions efficiently and over rational domains
Authors: Ronitt Rubinfeld, Madhu Sudan
Venue: Proceedings of the third annual ACM-SIAM symposium on Discrete algorithms (1992)

In this paper we give the first self-testers and checkers for polynomials over rational and integer domains. We also show significantly stronger bounds on the efficiency of a simple modification of the algorithm for self-testing polynomials over finite fields given in [8].
Scale-Based Detection of Corners of Planar Curves
Authors: Anothai Rattarangsi, Roland T. Chin
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1992)

A technique for detecting and localizing corners of planar curves is proposed. The technique is based on Gaussian scale space, which consists of the maxima of absolute curvature of the boundary function presented at all scales. The scale space of isolated simple and double corners is first analyzed to investigate the behavior of scale space due to smoothing and interactions between two adjacent corners. The analysis shows that the resulting scale space contains line patterns that either persist, terminate, or merge with a neighboring line. Next, the scale space is transformed into a tree that provides simple but concise representation of corners at multiple scales. Finally, a multiple-scale corner detection scheme is developed using a coarse-to-fine tree parsing technique. The parsing scheme is based on a stability criterion that states that the presence of a corner must concur with a curvature maximum observable at a majority of scales. Experiments were performed to show that the scale space corner detector is reliable for objects with multiple-size features and noisy boundaries and compares favorably with other corner detectors tested.
Reconstructive expert system explanation
Authors: Michael R. Wick, William B. Thompson
Venue: Artificial Intelligence (1992)

Existing explanation facilities are typically far more appropriate for knowledge engineers engaged in system maintenance than for end-users of the system. This is because the explanation is little more than a trace of the detailed problem-solving steps. An alternative approach recognizes that an effective explanation often needs to substantially reorganize the actual line of reasoning and bring to bear additional information to support the result. Explanation itself becomes a complex problem-solving process that depends not only on the actual line of reasoning, but also on additional knowledge of the domain. This paper presents a new computational model of explanation and argues that it results in significant improvements over traditional approaches. &mdash;Authors' Abstract
Analysis of file I/O traces in commercial computing environments
Authors: K. K. Ramakrishnan, Prabuddha Biswas, Ramakrishna Karedla
Venue: ACM SIGMETRICS Performance Evaluation Review (1992)

Improving the performance of the file system is becoming increasingly important to alleviate the effect of I/O bottlenecks in computer systems. To design changes to an existing file system or to architect a new file system it is important to understand current usage patterns. In this paper we analyze file I/O traces of several existing production computer sytems to understand file access behavior. Our analysis suggests that a relatively small percentage of the files are active. The amount of total data active is also quite small for interactive environments. An average file encounters a relatively small number of file opens while receiving an order of magnitude larger number of reads to it. An average process opens quite a large number of files over a typical prime time period. What is more significant is that the effect of outliers on many of the characteristics we studied is dominant. A relatively small number of processes dominate the activity, and a very small number of files receive most of these operations. In addition, we provide a comprehensive analysis of the dynamic sharing of files in each of these enviroments, addressing both the simultaneous and sequential sharing aspects, and the activity to these shared files. We observe that although only a third of the active files are sequentially shared, they receive a very large proportion of the total operations. We analyze the traces from a given environment across different lengths of time, such as one hour, three hour and whole work-day intervals and do this for 3 different environments. This gives us an idea of the shortest length of the trace needed to have confidence in the estimation of the parameters.
Benchmark semantics
Authors: Carl G. Ponder
Venue: ACM SIGMETRICS Performance Evaluation Review (1991)

Be careful when interpreting benchmark measurements that compare two languages or two implementations of the same language. A program expressed in two different languages rarely computes the exact same function in both cases. The same goes for a program run on two different implementations of the same language. The implementation details ultimately affect the language semantics as well as the benchmark performance. Here are some simple examples of this effect.