ppxscal/embedding_network huggingface dataset:
Automated design and analysis system for design of custom orthopedic implants
Authors: R. L. Dooley, G. Heimke, Aijt Dingankar, E. Berg, E. Kimbrough
Venue: Proceedings of the 1st international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1988)

A parametric model for implant design has been developed and incorporated into an expert system for prosthesis design and manufacturing. The expert system acquires data concerning the physical characteristics of a patient. The system conceptualizes a space-filling custom design based upon the available data and calculations. The system considers existing off-the-shelf designs and the custom design as parallel alternatives and applies geometric criteria to eliminate designs that are incompatible with the patient's data. The remaining designs are used to generate finite element models, and are evaluated for bone/prosthesis stress levels. The system &ldquo;reasons&rdquo; about the final designs in an iterative fashion. The expert system was used to evaluate possible prosthesis designs for a &ldquo;typical&rdquo; patient. Out of six off-the-shelf designs, three were rejected on the basis of incompatible geometries. The custom design was the closest fit as far as space-filling property is considered. All the designs were analyzed for excessive stress levels but none were found to have stresses above the critical stresses.
The Evolving Philosophers Problem: Dynamic Change Management
Authors: Jeff Kramer, Jeff Magee
Venue: IEEE Transactions on Software Engineering (1990)

A model for dynamic change management which separates structural concerns from component application concerns is presented. This separation of concerns permits the formulation of general structural rules for change at the configuration level without the need to consider application state, and the specification of application component actions without prior knowledge of the actual structural changes which may be introduced. In addition, the changes can be applied in such a way so as to leave the modified system in a consistent state, and cause no disturbance to the unaffected part of the operational system. The model is applied to an example problem, 'evolving philosophers'. The principles of this model have been implemented and tested in the Conic environment for distributed systems.
Circuit Simulation on Shared-Memory Multiprocessors
Authors: P. Sadayappan, V. Visvanathan
Venue: IEEE Transactions on Computers (1988)

Reports the parallelization on a shared-memory vector multiprocessor of the computationally intensive components of a circuit simulator-matrix assembly (including device model evaluation) and the unstructured sparse linear system solution. A theoretical model is used to predict the performance of the lock-synchronized parallel matrix assembly, and the results are compared to experimental measurements. Alternate approaches to efficient sparse matrix solution are contrasted, highlighting the impact of the matrix representation/access strategy on achievable performance, and medium-grained approach with superior performance is introduced. The techniques developed have been incorporated into a prototype parallel implementation of the production circuit simulator ADVICE on the Alliant FX/8 multiprocessor.
Organizing for users
Authors: G. McCartney
Venue: Proceedings of the 17th annual ACM SIGUCCS conference on User Services (1989)

Most Computing Centers organize their User Services staff around systems or hardware. Thus, there are for example, IBM mainframe support groups, VAX support groups and various flavors of personal computing support groups. This organization works well when each machine is a discrete entity and users are able to identify or be easily identified by consultants as using one or other machine. However, in more complex environments this discrete quality disappears. Now we may have a user running on a personal computer emulating a terminal connected to a front end minicomputer and submitting jobs over some kind of network link to a supercomputer. Briefly, if a user has a problem who should he contact? Their being able to contact the right person implies that they understand what is causing their particular problem - this may be far from clear even to experts. This paper proposes and describes a theoretical organization built around the user's requirements. A structure is discussed that offers the user a single entry point for problem resolution, a structure in which user questions can be easily tracked and one that allows for broadly based consulting maximizing the possibility of interesting work for the consultant.
Reconfigurable Multipipelines for Vector Supercomputers
Authors: Rajiv Gupta, Alessandro Zorat, I. V. Ramakrishan
Venue: IEEE Transactions on Computers (1989)

The problem of recovering multipipelines in the presence of faulty stages is addressed. The stages are assumed to be organized in rows and columns. The pipeline stages are alternated with reconfiguring circuitry which is used for bypassing the faulty stages. The pipelines are configured by programming the switches in a distributed manner using fault information available locally. The configuration algorithm is optimal in the sense that it recovers the maximum number of pipelines under any fault pattern. Probabilistic bounds on the delay (the number of bypassed faulty stages) and yield (the number of nonfaulty pipelines recovered) are derived. It is shown that the maximum signal delay in any of the pipelines is O(log m), where m is the initial number of pipelines. A constant fraction of these pipelines can be recovered with the scheme, as opposed to an exponentially decreasing number when no reconfiguration is used. The reconfiguration scheme can also be used to provide fault-tolerant buses on a wafer.
Distributed bisimulations
Authors: Ilaria Castellani, Matthew Hennessy
Venue: Journal of the ACM (JACM) (1989)

A new equivalence between concurrent processes is proposed. It generalizes the well-known bisimulation equivalence to take into account the distributed nature of processes. The result is a noninterleaving semantic theory; concurrent processes are differentiated from processes that are non-deterministic but sequential. The new equivalence, together with its observational version, is investigated for a subset of the language CCS, and various algebraic characterizations are obtained.
A tutorial on uniform variate generation
Authors: P. L'Ecuyer
Venue: Proceedings of the 21st conference on Winter simulation (1989)

In typical stochastic simulations, randomness is produced by generating a sequence of independent uniform variates (usually real-valued between 0 and 1, or integer-valued in some interval) and transforming them in the appropriate way. In this tutorial, we examine practical ways of generating such variates on a computer. We compare them in terms of ease of implementation, efficiency, flexibility, theoretical support, and statistical robustness. We look in particular at the following classes of generators: linear congruential (in scalar and matrix form), lagged-Fibonacci (including generalized feedback shift register) and combined. We also mention others and give a bibliographic survey of the most recent papers on the subject.
An empirical study of the performance of the APL370 compiler
Authors: W.-M. Ching, R. Nelson, N. Shi
Venue: ACM SIGAPL APL Quote Quad (1989)

The performance of a compiler is usually measured in terms of the execution efficiency of compiled code and the speed of compilation. For an APL compiler, we are also concerned about its relative performance with respect to the interpreter: C/I, the ratio of the speed of compiled code over interpretation. We give performance data on 4 groups of examples of moderate size: i) scalar style code where an interpreter does poorly and the C/I ratio is very high, ii) good APL style code where interpreter still does poorly due to inherent iterativeness or recursion, and the C/I ratio is high, and iii) good APL style code where the interpreter is very efficient on large data, and the C/I ratio is low, and iv) some particular primitives. These examples include neural net simulation, machine simulation, network routing, signal processing and mathematical computations. The APL370 compiler not only speeds up applications of iterative nature, but also gives good performance to codes utilizing APL's strength such as boolean selection and boolean data manipulation.
Computing the normal forms of matrices depending on parameters
Authors: G. Chen
Venue: Proceedings of the ACM-SIGSAM 1989 international symposium on Symbolic and algebraic computation (1989)

We consider in this paper an algorithm for the exact computation of the Frobenius, Jordan and Arnold's form of matrices depending holomorphically on parameters. The problem originates from the problem of formal resolution of a first order system of differential equations depending on parameter. We have implemented this algorithm in Macsyma.
Hashing practice: analysis of hashing and universal hashing
Authors: M. V. Ramakrishna
Venue: Proceedings of the 1988 ACM SIGMOD international conference on Management of data (1988)

Much of the literature on hashing deals with overflow handling (collision resolution) techniques and its analysis. What does all the analytical results mean in practice and how can they be achieved with practical files? This paper considers the problem of achieving analytical performance of hashing techniques in practice with reference to successful search lengths, unsuccessful search lengths and the expected worst case performance (expected length of the longest probe sequence). There has been no previous attempt to explicitly link the analytical results to performance of real life files. Also, the previously reported experimental results deal mostly with successful search lengths. We show why the well known division method performs &ldquo;well&rdquo; under a specific model of selecting the test file. We formulate and justify an hypothesis that by choosing functions from a particular class of hashing functions, the analytical performance can be obtained in practice on real life files. Experimental results presented strongly support our hypothesis. Several interesting problems arising are mentioned in conclusion.
Windows and pop-up menus in application design
Authors: A. Smith
Venue: ACM SIGAPL APL Quote Quad (1987)

An increasing number of APLs support the 'Mac-like' interface, with its pioneering ideas of Windows, Icons, Mice and Pull-down Menus. Technically exciting these may be; what is lacking is any useful experience of handling these techniques in APL application design. The author has tackled the problem from the application end: a collection of functions has been evolved (written in APL*PLUS/PC) to provide simple windows and menus using text characters only. The major benefits of the windowing/menu approach are found to be: 1) portability of ideas. What runs now on the PC and the Amiga will largely run on VS APL under GDDM (Vn 2) on the mainframe. 2) simplicity of design. With windows you can throw away many of those AP124-type panels and revert to 'quote-quad' input. 3) ease of validation. With a scroll-bar selection, the user has no choice but to input a valid reply. 4) ease of use, and 'PC' feel. Why not make Lotus-123 users feel at home? Typical applications include a shop-floor information system for chocolate manufacture, and a 'rule-inducing' expert system shell. Copies of the window functions are included at the end of this paper, or are available via the BAA Software Exchange.
Time-symbolic simulation for accurate timing verification of asynchronous behavior of logic circuits
Authors: N. Ishiura, M. Takahashi, S. Yajima
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

As a new approach for timing verification of logic circuits, we propose a new concept of time-symbolic simulation. While a conventional symbolic simulator treats signal values as logical expressions, a time-symbolic simulator treats time as algebraic expressions. In this paper, we describe algorithms for time-symbolic simulation, and its application to hazard detection and verification of asynchronous sequential circuits.
Intelligent support for interface systems
Authors: F. N. Teskey
Venue: Proceedings of the 11th annual international ACM SIGIR conference on Research and development in information retrieval (1988)

This paper describes how a language for building interfaces to information systems, that is being developed by the Office of Research at OCLC, can be linked to an artificial intelligence environment, Poplog. A demonstration system, showing how Poplog could provide some intelligent support for a D interface, has been developed. It is suggested that this could form the basis for intelligent support for interface systems.
Reasoning on a highlighted user model to respond to misconceptions
Authors: Kathleen F. McCoy
Venue: Computational Linguistics (1988)

Responses to misconceptions given by human conversational partners very often contain information refuting possible reasoning which may have led to the misconceptions. Surprisingly there is a great deal of regularity in these responses across different domains of discourse. For instance, one reason a user might have given an object a property it does not have is that the user confused the object with another similar object. In correcting such a misconception, a human conversational partner is likely to point out this possible confusion.This work describes a method for generating responses like the one just described by reasoning on a highlighted model of the user to identify possible sources of the error. Through a transcript study a number of response strategies were abstracted. Each strategy was associated with a structural configuration of the user model. For example, the above mentioned strategy of pointing out a similar confused object is associated with a configuration of the user model that indicates the user believes there is an important similar object that has the property involved in the misconception. Upon finding that configuration in the highlighted user model, the system can respond with the associated strategy.Notice that the reasoning must be done on a highlighted user model since the perception of both an object's importance and its similarity with another object change with the perspective being taken on the domain. This paper investigates how domain perspective can be modeled to provide the needed highlighting and introduces a similarity metric that is sensitive to the highlighting provided by the domain perspective. Finally, the paper shows how the highlighting affects misconception responses.
Atomic garbage collection: managing a stable heap
Authors: Elliot Kolodner, Barbara Liskov, William Weihl
Venue: Proceedings of the 1989 ACM SIGMOD international conference on Management of data (1989)

Modern database systems use transactions to achieve a high degree of fault-tolerance. Many modern programming languages and systems provide garbage collected heap storage, which frees the programmer from the job of explicitly deallocating storage. In this paper we describe integrated garbage collection and recovery algorithms for managing a stable heap in which accessible objects survive both system crashes and media failures. A garbage collector typically both moves and modifies objects which can lead to problems when the heap is stable because a system crash after the start of collection but before enough of the reorganized heap reaches the disk can leave the disk in an inconsistent state. Furthermore, collection has to be coordinated with the recovery system. We present a collection algorithm and recovery system that solves these problems.
An Efficient Distributed Knot Detection Algorithm
Authors: Israel Cidon
Venue: IEEE Transactions on Software Engineering (1989)

A distributed knot detection algorithm for general graphs is presented. The knot detection algorithm uses at most O(n log n+m) messages and O(m+n log n) bits of memory to detect all knots' nodes in the network (where n is the number of nodes and m is the number of links). This is compared to O(n/sup 2/) messages needed in the best algorithm previously published. The knot detection algorithm makes use of efficient cycle detection and clustering techniques. Various applications for the knot detection algorithms are presented. In particular, its importance to deadlock detection in store and forward communication networks and in transaction systems is demonstrated.
A Strategy for Comparing Alternative Software Development Life Cycle Models
Authors: A. M. Davis, H. Bersoff, E. R. Comer
Venue: IEEE Transactions on Software Engineering (1988)

It is difficult to compare and contrast models of software development because their proponents often use different terminology, and the models often have little in common except their beginnings (marked by a recognition that a problem exists) and ends (marked by the existence of a software solution). A framework is provided that can serve: as a basis for analyzing the similarities and differences among alternate life-cycle models; as a tool for software engineering researchers to help describe the probable impacts of a life-cycle mode; and as a means to help software practitioners decide on an appropriate life-cycle model to utilize on a particular project or in a particular application are.
Motion and Structure from Orthographic Projections
Authors: T. S. Huang, C. H. Lee
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

S. Ullman's classical (1979) results on motion/structure from orthographic views are revisited. Specifically, two results are presented: (1) two orthographic views allow an uncountably infinite number of solutions to motion/structure of a rigid body, and (2) a linear algorithm for solving motion/structure from four point correspondences over three views.
Efficient full LR(I) parser generation
Authors: D. Spector
Venue: ACM SIGPLAN Notices (1988)

This paper proposes that full LR(1) parser generators are easier to use than the LALR(1) parser generators commonly in use, and that minimal-state full LR(1) tables are not much larger than LALR(1) tables. A method is presented for the automatic construction of minimal-state full LR(1) parser tables. The method is fast and accurate because it starts with the LR(0) table and resolves lookahead ambiguities as necessary by tracing the LR(0) table and splitting the minimum number of states, and because there is no need for generalized set manipulation.
Algorithm 665: Machar: a subroutine to dynamically determined machine parameters
Authors: W. J. Cody
Venue: ACM Transactions on Mathematical Software (TOMS) (1988)

Numerical software written in high-level languages often relies on machine-dependent parameters to improve portability. MACHAR is an evolving FORTRAN subroutine for dynamically determining thirteen fundamental parameters associated with a floating-point arithmetic system. The version presented here operates correctly on a large number of different floating-point systems, including those implementing the new IEEE Floating-Point Standard.
An efficient implementation of SELF a dynamically-typed object-oriented language based on prototypes
Authors: C. Chambers, D. Ungar, E. Lee
Venue: ACM SIGPLAN Notices (1989)

We have developed and implemented techniques that double the performance of dynamically-typed object-oriented languages. Our SELF implementation runs twice as fast as the fastest Smalltalk implementation, despite SELF's lack of classes and explicit variables. To compensate for the absence of classes, our system uses implementation-level maps to transparently group objects cloned from the same prototype, providing data type information and eliminating the apparent space overhead for prototype-based systems. To compensate for dynamic typing, user-defined control structures, and the lack of explicit variables, our system dynamically compiles multiple versions of a source method, each customized according to its receiver's map. Within each version the type of the receiver is fixed, and thus the compiler can statically bind and inline all messages sent to self. Message splitting and type prediction extract and preserve even more static type information, allowing the compiler to inline many other messages. Inlining dramatically improves performance and eliminates the need to hard-wire low-level methods such as +,==, and ifTrue:. Despite inlining and other optimizations, our system still supports interactive programming environments. The system traverses internal dependency lists to invalidate all compiled methods affected by a programming change. The debugger reconstructs inlined stack frames from compiler-generated debugging information, making inlining invisible to the SELF programmer.
Conversational resources for situated action
Authors: D. M. Frohlich, P. Luff
Venue: ACM SIGCHI Bulletin (1989)

Suchman (1987) has recently drawn attention to the situated nature of human social action and its implications for the design of interactive computer systems. In particular, she has highlighted the shortcomings of globally managing human computer dialogues by matching user actions to some idealised plan for carrying out a task. In this paper we outline a scheme for the local management of dialogues based on the findings of conversation analysis. The scheme makes available a variety of communicative resources to both user and system, including the ability to give and take turns at talk, to initiate and carry out repair work, and to continue or change the topic of conversation. An implementation of the scheme in a welfare rights Advice System is described.
Learning the ways: the enculturation of SDSC users
Authors: Marsha Jovanovic
Venue: Proceedings of the 16th annual ACM SIGUCCS Conference on User Services (1988)

Some years ago when anthropologists were struggling to justify their existence, Laura Nader (Ralph's sister) encouraged her colleagues to study their own societies, leaving non-Western societies to non-Westerners.1 Today, using concepts from the social sciences, business consultants like Lawrence Miller are explaining American corporations in terms of life cycle and human culture (both deeply rooted anthropological terms).2 With that encouragement and precedent, this paper describes, from an anthropological point of view, how members of the computing society enter the supercomputing society and learn the ways of the San Diego Supercomputer Center (SDSC). From novitiate to sage, they pass through the following rites and stages: Seeking the vision: the supercomputer need Entering the select society: the allocation Initiation rites: promises and a password Learning the language: the workshops Reading the holy books: DOCUMENT and the handbooks Consorting with wizards: consultants by telephone and e-mail Voice of the society: the newsletter Making the mark: the annual reports
Voxel space automata: modeling with stochastic growth processes in voxel space
Authors: N. Greene
Venue: Proceedings of the 16th annual conference on Computer graphics and interactive techniques (1989)

A novel stochastic modeling technique is described which operates on a voxel data base in which objects are represented as collections of voxel records. Models are "grown" from predefined geometric elements according to rules based on simple relationships like intersection, proximity, and occlusion which can be evaluated more quickly and easily in voxel space than with analytic geometry. Growth is probabilistic: multiple trials are attempted in which an element's position and orientation are randomly perturbed, and the trial which best fits a set of rules is selected. The term voxel space automata is introduced to describe growth processes that sense and react to a voxel environment.Applications include simulation of plant growth, for which voxel representation facilitates sensing the environment. Illumination can be efficiently estimated at each plant "node" at each growth iteration by casting rays into the voxel environment, allowing accurate simulation of reaction to light including heliotropism.