ppxscal/embedding_network huggingface dataset:
A Numerical Solution to the Generalized Mapmaker's Problem: Flattening Nonconvex Polyhedral Surfaces
Authors: E. L. Schwartz, A. Shaw, E. Wolfson
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

Methods are described to unfold and flatten the curved, convoluted surfaces of the brain in order to study the functional architectures and neural maps embedded in them. In order to do this, it is necessary to solve the general mapmaker's problem for representing curved surfaces by planar models. This algorithm has applications in areas other than computer-aided neuroanatomy, such as robotics motion planning and geophysics. The algorithm maximizes the goodness of fit distances in these surfaces to distances in a planar configuration of points. It is illustrated with a flattening of monkey visual cortex, which is an extremely complex folded surface. Distance errors in the range of several percent are found, with isolated regions of larger error, for the class of cortical surfaces studied so far.
The role of VHDL as a description language for off-the shelf integrated circuits
Authors: J. Morris
Venue: ACM SIGDA Newsletter (1988)

The US Department of Defense (DoD), through its military departments, procures thousands of electronic systems every year. These electronic systems are comprised of printed circuit boards, which, in turn, are comprised of hundreds of distinct integrated circuits (ICs). Some of these ICs are "custom-made" for each specific electronic system, but many are purchased "off-the-shelf" as individual components.
Comments on the performance of algebra systems in general relativity and a recent paper by Nielsen and Pedersen
Authors: M. A. MacCallum
Venue: ACM SIGSAM Bulletin (1989)

A recent paper by Nielsen and Pedersen [1] reported some calculations on a solution of the Einstein equations for a Euclidean four-dimensional space. A response was recently made by Schr uuml;fer [2]. This further comment sets some of the remarks in a more general context and reports some curious test results of further comparisons.
Computer science education in the People's Republic of China in the late 1980s
Authors: J. D. Wilson, E. S. Adams, H. P. Baouendi, W. A. Marion, G. J. Yaverbaum
Venue: Communications of the ACM (1988)

Last year a delegation of international computer professionals with interests in computer science education participated in an information exchange with colleagues in the People's Republic of China. The delegation's experiences suggest that the Chinese have made substantial progress in some aspects of computer science education since late 1982, but that difficult problems remain to be solved.
A smalltalk window system based on constraints
Authors: Danny Epstein, Wilf R. LaLonde
Venue: ACM SIGPLAN Notices (1988)

We describe the design of a constraint-based window system for Smalltalk. This window system uses constraints to specify attributes of windows and relationships between them. Three classes of constraints are supported, one of which is implicit and not available for general use. The system extends the current Smalltalk system, providing support for both fixed-size and fixed-scale windows. It also provides the capability to dynamically reorganize the layout of a window. A goal of the design is to produce a system with real-time response that is fast enough to be substituted for the existing system. A prototype with response times of approximately 1/4 second has been implemented to demonstrate the feasibility of the design as well as to point out several important optimizations.
A future APL: examples and problems
Authors: M. Gfeffer
Venue: ACM SIGAPL APL Quote Quad (1989)

AIDA is a modern APL featuring operator-less syntax, function attributes, function arrays, array parts and a hierarchical object library. The above areas are illustrated by examples on a model interpreter written in SHARP APL reg;. The relation of the AIDA extensions to APL application systems design is discussed and some problem areas requiring further thought are identified.
University computing services in 1995
Authors: M. D. Glick
Venue: ACM SIGUCCS Newsletter (1989)

For me to talk to you about what computing centers will be like in the future is rather like bringing coals to Newcastle. On the other hand, that doesn't preclude me from having opinions --- neither does lack of knowledge. You must understand from whence I come. I have spent my faculty life at Wayne State University, the University of Missouri at Columbia and Iowa State University, three large midwestern state universities that between them educate 85,000 students a year. They are the heartland universities. They are the major institutions, the kinds of institutions that are responsible for educating the leadership of our nation; they tend not to be cutting, or bleeding, edge, universities, but they have a major need for integrating technology.
An algorithm for determining the simplicity of a modular group representation
Authors: Gerhard O. Michler
Venue: Journal of Symbolic Computation (1988)

Let G be a finite group an F and arbitrary splitting field for G. Using the Amitsur-Levitzki theorem on the polynomial identities satisfied by a matrix ring over a commutative ring an algorithm is given for finding the minimal dimension t for which there is a simple t-dimensional FG-submodule U in a faithful FG-module M of dimension n
Synchronization Algorithms for Shared-Memory Multiprocessors
Authors: Gary Granunke, Shreekant Thakkar
Venue: Computer (1990)

A performance evaluation of the Symmetry multiprocessor system revealed that the synchronization mechanism did not perform well for highly contested locks, like those found in certain parallel applications. Several software synchronization mechanisms were developed and evaluated, using a hardware monitor, on the Symmetry multiprocessor system; the mechanisms were to reduce contention for the lock. The mechanisms remain valuable even when changes are made to the hardware synchronization mechanism to improve support for highly contested locks. The Symmetry architecture is described, and a number of lock algorithms and their use of hardware resources are examined. The performance of each lock is observed from the perspective of both the program itself and the total system performance.
An Efficient Implementation of Static String Pattern Matching Machines
Authors: Jun-ichi Aoe
Venue: IEEE Transactions on Software Engineering (1989)

A technique for implementing a static transition table of a string pattern matching machine which locates all occurrences of a finite number of keywords in a string is described. The approach is based on S.C. Johnson's (1975) storage and retrieval method of the transition table of a finite-state machine. By restricting the transition table of the finite-state machine to that of the string pattern-matching machine, triple arrays of Johnsons's data structure can be reduced to two arrays. The retrieval program of the reduced data structure can be speeded up by a finite straight program without loops.
Algorithmic Framework for Learned Robot Navigation in Unknown Terrains
Authors: N. S. Rao
Venue: Computer (1989)

A framework is presented that uses the same strategy to solve both the learned navigation and terrain model acquisition. It is shown that any abstract graph structure that satisfies a set of four properties suffices as the underlying structure. It is also shown that any graph exploration algorithm can serve as the searching strategy. The methods provide paths that keep the robot as far from the obstacles as possible. In some cases, these methods are preferable to visibility graph methods that require the robot to navigate arbitrarily close to the obstacles, which is hard to implement if the robot motions are not precise.
Spill code minimization techniques for optimizing compliers
Authors: D. Bernstein, M. Golumbic, y. Mansour, R. Pinter, D. Goldin, H. Krawczyk, I. Nahshon
Venue: Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation (1989)

Global register allocation and spilling is commonly performed by solving a graph coloring problem. In this paper we present a new coherent set of heuristic methods for reducing the amount of spill code generated. This results in more efficient (and shorter) compiled code. Our approach has been compared to both standard and priority-based coloring algorithms, universally outperforming them. In our approach, we extend the capability of the existing algorithms in several ways. First, we use multiple heuristic functions to increase the likelihood that less spill code will be inserted. We have found three complementary heuristic functions which together appear to span a large proportion of good spill decisions. Second, we use a specially tuned greedy heuristic for determining the order of deleting (and hence coloring) the unconstrained vertices. Third, we have developed a &ldquo;cleaning&rdquo; technique which avoids some of the insertion of spill code in non-busy regions.
A Curvature-Based Approach to Terrain Recognition
Authors: D. B. Goldof, T. S. Huang
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The authors describe an algorithm which uses a Gaussian and mean curvature profile for extracting special points on terrain and then use these points for recognition of particular regions of the terrain. The Gaussian and mean curvatures are chosen because they are invariant under rotation and translation. In the Gaussian and mean curvature image, the points of maximum and minimum curvature are extracted and used for matching. The stability of the position of those points in the presence of noise and with resampling is investigated. The input for this algorithm consists of 3-D digital terrain data. Curvature values are calculated from the data by fitting a quadratic surface over a square window and calculating directional derivatives of this surface. A method of surface fitting which is invariant to coordinate system transformation is suggested and implemented. The algorithm is tested with and without the presence of noise, and its performance is described.
Hardware support for large atomic units in dynamically scheduled machines
Authors: S. W. Melvin, M. C. Shebanow, Y. N. Patt
Venue: Proceedings of the 21st annual workshop on Microprogramming and microarchitecture (1988)

Microarchitectures that implement conventional instruction set architectures are usually limited in that they are only able to execute a small number of microoperations concurrently. This limitation is due in part to the fact that the units of work that the hardware treats as indivisible are small. While this limitation is not important for microarchitectures with a low level of functionality, it can be significant if the goal is to build hardware that can support a large number of microoperations executing concurrently. In this paper we address the tradeoffs associated with the sizes of the various units of work that a processor considers indivisible, or atomic. We argue that by allowing larger units of work to be atomic, restrictions on concurrent operation are reduced and performance is increased. We outline the implementation of a front end for a dynamically scheduled processor with hardware support for large atomic units. We discuss tradeoffs in the design and show that with a modest investment in hardware, the run-time advantages of large atomic units can be realized without the need to alter the instruction set architecture.
Efficient computation of the singular value decomposition on cube connected SIMD machine
Authors: H. Y. J. Chuang, L. Chen
Venue: Proceedings of the 1989 ACM/IEEE conference on Supercomputing (1989)

The singular value decomposition (SVD) has many real-time applications. Recently, there has been much interest in developing efficient methods to compute SVD in parallel machines. This paper presents an efficient method for computing SVD in a cube connected SIMD (single instruction stream - multiple data stream) parallel computer. The method is based on a one-sided orthogonalization algorithm due to Hestenes. In a cube connected SIMD with n/2 processors, the SVD of an m by n matrix requires a computation time of &Ogr;(mn) per sweep. Although the time complexity (excluding communication time) is the same as that of the best known SVD method on linearly connected SIMD, the communication time is much smaller because the amount of data moved among the nodes is only about one half. The SVD of large matrices on a fixed size system is also discussed.
Exploiting read-mostly workloads in the FileNet file system
Authors: D. Edwards, M. Mckendry
Venue: Proceedings of the twelfth ACM symposium on Operating systems principles (1989)

Most recent studies of file system workloads have focussed on loads imposed by general computing. This paper introduces a significantly different workload imposed by a distributed application system. The FileNet system is a distributed application system that supports document image processing. The FileNet file system was designed to support the workload imposed by this application. To characterize the read-mostly workload applied to the file system and how it differs from general computing environments, we present statistics gathered from live production installations. We contrast these statistics with previously published data for more general computing. We describe the key algorithms of the file system, focusing on the caching approach. A bimodal client caching approach is employed, to match the file modification patterns observed. Different cache consistency algorithms are used depending on usage patterns observed for each file. Under most conditions, files cached at workstations can be accessed without contacting servers. When a file is subject to frequent modification that causes excessive cache consistency traffic, caching is disabled for that file, and servers participate in all open and close activities. The data from production sites is examined to evaluate the success of the approach under its applied load. Contrasts with alternative approaches are made based on this data.
Discrete mathematics for computer science majors&mdash;where are we? How do we proceed?
Authors: William Marion
Venue: ACM SIGCSE Bulletin (1989)

It has been nine years since Anthony Ralston and Mary Shaw called for a rethinking of the importance of sound mathematical training for undergraduate computer science majors [14]. In their paper they stressed the need to develop a two-year sequence in discrete mathematics for beginning computer science majors. Since that time numerous articles about such a sequence have appeared in both mathematics and computer science journals [4], [9], [12] and [13] and a number of panel sessions at professional meetings of SIGSCE and of the Mathematical Association of America (MAA) have been held. After all this time questions about the place of discrete mathematics in the undergraduate curriculum are still being debated. One question that is no longer being asked is: should discrete mathematics be part of a computer science major's undergraduate program? The questions that are being asked now and for which there are no easy answers are: at what level should discrete mathematics be taught? should there be one course, two courses or even three courses? what should the prerequisites be for these courses? and what topics should be presented in these courses? Computer scientists and mathematicians who have read the literature, listened to the debates, examined the textbooks or taught a course in discrete mathematics or discrete structures know that there appears to be little agreement as to how and what works and when it works best. This paper attempts to analyze the current situation in more detail and to offer a few suggestions to keep the dialogue alive.
Should computer science examinations contain &ldquo;programming&rdquo; problems?
Authors: Donald J. Bagert,  Jr.
Venue: ACM SIGCSE Bulletin (1988)

The purpose of many computer science courses is to enhance the programming skills of the student, including the ability to design and implement appropriate algorithms. In such courses, examinations should therefore contain problems which test for algorithmic skills. In particular, there should be problems which require the student to write small sections of code, usually in the form of a subprogram. Students often perceive these questions as &ldquo;programming&rdquo; problems; however, it is more accurate to state that these are algorithmic problems, since such questions primarily measure algorithmic skills. In addition, since such exam problems address topics which are a part of the course content (e.g. stacks, queues, and tables in a data structures class), the student's knowledge of these topics is also tested and reinforced. This paper discusses how examination questions which test algorithmic skills have been implemented in a data structures course at Northeast Louisiana University. Arguments both for and against using such test questions are discussed, as well as the proper format and amount of this type of problem. The results of a survey of data structures students at Northeast concerning this topic is also presented. There has been relatively little discussion on the topic of computer science examinations in the literature. It is hoped that the publication and presentation of this paper will stimulate dialogue in this area among academicians.
Object subclass hierarchy in SQL: a simple approach
Authors: Chenho Kung
Venue: Communications of the ACM (1990)

The object subclass hierarchy is a useful way of modeling property and behavior inheritance. It can be implemented on a relational DBMS using views.
Track&mdash;a trace construction kit
Authors: Heinz-Dieter Böcker, J. Herczeg
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people (1990)

TRACK is a kit to interactively construct environments that trace the execution of methods and the flow of messages between SMALLTALK-80 objects. It enables the user to set up traces by means of direct manipulation. This is done by placing obstacles between icons representing specific classes and instances much in the way a jumping course is set up. TRACK may be used to generate multiple visualizations of programs which may be concurrently run. It is a browsing and debugging tool as well as an algorithm animation tool. TRACK is tightly integrated with the standard tools of the SMALL- TALK-80 programming environment.
The Design of Totally Self-Checking TMR Fault-Tolerant Systems
Authors: N. Gaitanis
Venue: IEEE Transactions on Computers (1988)

A totally self-checking triple modular redundancy (TSC-TMR) system consists of a conventional TMR system monitored by a TSC circuit with two outputs indicating information errors and internal faults. The internal fault indication is independent of the output information errors and indicates masked errors of modular units or faults in the monitoring circuit itself. The information error indication depends mainly on the output information errors and it can be used as a stop signal preventing the propagation of erroneous outputs. This scheme of fault-tolerant systems is very simple and reliable compared to the known TMR systems with self-checking capabilities and achieves a high degree of availability and maintainability. The TSC error checking circuit has been designed by applying a new algebraic technique with two basic operator blocks performing the AND and XOR operations on error indication variables.
Representation methods for software reuse
Authors: W. B. Frakes, P. B. Gandel
Venue: Proceedings of the conference on Tri-Ada '89: Ada technology in context: application, development, and deployment (1989)

Many methods for representing software components for reuse have been proposed. These include traditional library science methods, knowledge based methods, and hypertext. In this paper, we survey and categorize these methods, and discuss systems in which they have been used.
Symbolic Construction of a 2-D Scale-Space Image
Authors: E. Saund
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

A symbolic approach to constructing a multiscale primitive shape description to 2-D binary (silhouette) shape images is presented. In contrast to contour or region smoothing techniques, grouping operations are performed over collections of tokens residing on a scale-space blackboard. Two types of grouping operations are identified that, respectively, aggregate edge primitives at one scale into edge primitives at a coarser scale and group edge primitives into partial-region assertions, including curved contours, primitive corners, and bars. Procedures to perform these computations are presented.
Spare Capacity as a Means of Fault Detection and Diagnosis in Multiprocessor Systems
Authors: A. T. Dahbura, K. K. Sabnani, W. J. Hery
Venue: IEEE Transactions on Computers (1989)

A technique for detecting and diagnosing faults at the processor level in a multiprocessor system is described. A process is assigned whenever possible to two processors: the processor to which it would normally be assigned (primarily) and an additional processor that would otherwise be idle (secondary). Two strategies are described and analyzed: one that is preemptive and another that is nonpreemptive. It is shown that, for moderately loaded systems, a sufficient percentage of processes can be performed redundantly using the system's spare capacity to provide a basis for fault detection and diagnosis with virtually no degradation of response time. A multiprocessor that uses the approach for detecting faults at the processor loads is described.
Just-in-time simulation using artificial intelligence
Authors: S. Manivannan
Venue: Proceedings of the 21st conference on Winter simulation (1989)

The shortcomings of process oriented simulation languages for modeling various types of kanbans in a Just-in-time (JIT) system are outlined in this paper. To circumvent these modeling difficulties, a rule-based simulator (JITSAI) has been designed and implemented using LISP/VM language on an IBM 4381 computer. The simulator includes efficient user interfaces, static and dynamic databases, primitives for each of the JIT modeling and simulation issues, a domain-specific rulebase interfaced with an event planner, an explanation subsystem and an inference mechanism. Two simulation experiments conducted on a JIT system to illustrate the current features of the JITSAI simulator are discussed.
Linguistic support for atomic data types
Authors: William E. Weihl
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1990)

The problems of concurrency and failures in distributed systems can be addressed by implementing applications in terms of atomic data types: data types whose objects provide serializability and recoverability for transactions using them. The specifications of the types can be used to permit high levels of concurrency among transactions while still ensuring atomicity. However, highly concurrent implementations can be quite complicated. In this paper we analyze the expressive power of existing proposals for language features intended to support the implementation of atomic types. We illustrate several limitations of existing proposals and propose a new approach that avoids these problems.