ppxscal/embedding_network huggingface dataset:
Modifying freshman perception of the CIS graduate's workstyle
Authors: Charles H. Mawhinney, David R. Callaghan, Edward G. Cale,  Jr.
Venue: ACM SIGCSE Bulletin (1989)

Student interest in computer-related careers has declined dramatically in recent years. One possible explanation for this decline is incorrect perceptions of the workstyle associated with the positions held by CIS graduates. A study of freshman business majors was conducted which: (1) examined whether an introductory computing course changed those perceptions, and (2) compared those perceptions to their own expected starting positions. The study showed that: (1) the introductory computing course had a negligible effect on changing student perceptions of the nature of the CIS graduate's initial job, and (2) compared to their perceptions of CIS jobs, they expected their own jobs to involve substantially more human interaction and less direct involvement in the implementation of computer technology. The results suggest a need for: (1) a more proactive strategy to market the MIS career both inside and outside the classroom, and (2) some creative approaches for the placement and content of programming activities in both the major and the career.
Visibility problems for polyhedral terrains
Authors: Richard Cole, Micha Sharir
Venue: Journal of Symbolic Computation (1989)

In this paper we study several problems concerning the visibility of a polyhedral terrain @s from a point (or several points) lying above it. Our results are: (1) For a fixed point a, one can preproeess a in time O(n@a(n) log n), to produce a data structure of size O(n@a(n) log n), which supports fast ray shooting queries, where each such query asks for the point on @s that is visible from a in a specified direction. Here n is the number of faces of @s and @a(n) is the extremely slowly growing functional inverse of Ackermann's function. (2) If the viewing point a can vary along a fixed vertical line L, then the entire visibility structure of @s from L is of combinatorial complexity O(n@l"4(n)), where @l"4(n) is the maximal length of an (n, 4) Davenport-Sehinzel sequence, and is nearly linear in n, and where the visibility structure in question is the decomposition of L x S^2 into maximal connected regions, such that for each such region R, all points (a, u)@? R are such that the ray from a @? L in direction u @? S^2 first intersects @s at a point on the same face of @s. Furthermore, we present an O(n@l"4(n)log n)-time algorithm that preprocesses L and @s into a data-structure of size O(n@l"4(n)) which supports O(log^2n) time ray shooting queries. (3) Concerning the results in (2) we show that (i) if L is not vertical, then the resulting visibility structure can be of size @W(n^3); (ii) there exist a vertical line L and a polyhedral terrain a with n faces, for which the resulting visibility structure is of size @W(n^2@a(n)). (4) Finally, we consider the problem of placing on the surface @s one or several viewing points which collectively cover the entire surface (i.e. each point on @s is visible from at least one of these viewing ''stations''). We show (i) in the case of a single viewing station, one can determine in time O(n log n) whether such a station exists, and if so, produce such a point; (ii) the problem of finding the smallest number of points on @s that can collectively see the entire surface @s is NP-hard.
Compiling Fortran 8x array features for the connection machine computer system
Authors: Eugene Albert, Kathleen Knobe, Joan D. Lukas, Guy L. Steele,  Jr.
Venue: ACM SIGPLAN Notices (1988)

The Connection Machine&reg; computer system supports a data parallel programming style, making it a natural target architecture for Fortran 8x array constructs. The Connection Machine Fortran compiler generates VAX code that performs scalar operations and directs the Connection Machine to perform array operations. The Connection Machine virtual processor mechanism supports elemental operations on very large arrays. Most array operators and intrinsic functions map into single instructions or short instruction sequences. Noncontiguous array sections, array-valued subscripts, and parallel constructs such as WHERE and FORALL are also readily accommodated on the Connection Machine. In addition to such customary optimizations as common subexpression elimination, the CM Fortran compiler minimizes data motion for aligning array operations, minimizes transfers between the Connection Machine and the VAX and minimizes context switching for masked computations.
Use of the hypercube for symbolic quantum chromodynamics
Authors: A. Kolawa, G. C. Fox
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

A new numerical approach by Furmanski and Kolawa to quantum chromodynamics is based on diagonalizing the underlying Hamiltonian. This method involves the generation of states by repeated action of a potential operator. This symbolic calculation is dominated by the time it takes to search the database of existing states to verify if a generated state is identical to one previously found. We implement this algorithm on the Caltech/JPL Mark II hypercube and analyze its performance of both a simple database search and one optimized for this application. We show that the hypercube performance can be modelled in a fashion similar to conventional numerical (loosely synchronous) applications.
The electrical resistance of a graph captures its commute and cover times
Authors: A. K. Chandra, P. Raghavan, W. L. Ruzzo, R. Smolensky
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

View an n-vertex, m-edge undirected graph as an electrical network with unit resistors as edges. We extend known relations between random walks and electrical networks by showing that resistance in this network is intimately connected with the lengths of random walks on the graph. For example, the commute time between two vertices s and t (the expected length of a random walk from s to t and back) is precisely characterized by the effective resistance Rst between s and t: commute time = 2mRst. Additionally, the cover time (the expected length of a random walk visiting all vertices) is characterized by the maximum resistance R in the graph to within a factor of log n: mR &le; cover time &le; O (mR log n). For many graphs, the bounds on cover time obtained in this manner are better than those obtained from previous techniques such as the eigenvalues of the adjacency matrix. In particular, using this approach, we improve known bounds on cover times for various classes of graphs, including high-degree graphs, expanders, and multi-dimensional meshes. Moreover, resistance seems to provide an intuitively appealing and tractable approach to these problems.
Towards an expert/novice learning system with application to infectious disease
Authors: D. Kopec, L. Latour, M. Brody
Venue: Issue 108 (April 1989) (1989)

The threat of AIDS is widely recognized as an important educational problem, particularly in the college age population. To date, intelligent software has not been developed and employed to effectively disseminate the critical knowledge relevant to this epidemic. Since sexually transmitted diseases (STDs) as a group are a personal problem which few people feel comfortable discussing, the computer can provide an opportunity for learning about these diseases while insuring anonymity.
Local Concurrent Error Detection and Correction in Data Structures Using Virtual Backpointers
Authors: Chung-Chi J. Li, Paul P. Chen, W. K. Fuchs
Venue: IEEE Transactions on Computers (1989)

Two linked data structures utilizing virtual backpointers, the virtual double-linked list (VDLL) and the B-tree with virtual backpointers (VBT), are described. Four experiments that provide example measurements of the capabilities (behavior under multiple error conditions) and performance (time overhead) of both local concurrent error detection and correction using sample VDLL and VBT instances are described. For these structures, double errors within a fixed-size checking window can be detected in constant time, and single errors detected during forward moves can be corrected in constant time.
Solution of closed, product form, queueing networks via the RECAL and tree-RECAL methods on a shared memory multiprocessor
Authors: A. G. Greenberg, J. McKenna
Venue: ACM SIGMETRICS Performance Evaluation Review (1989)

RECAL is a new recurrence relation for calculating the partition function and various queue length moments for closed, product form networks. In this paper we discuss a number of the issues involved in the software implementation of RECAL on both sequential computers and parallel, shared memory computers. After a brief description of RECAL, we describe software implementing RECAL on a sequential computer. In particular, we discuss the problems involved in indexing and data storage. Next we describe code implementing RECAL on a parallel, shared memory computer. Special attention is given to designing a special buffer for temporary data storage and several other important features of the parallel code. Finally, we touch on software for serial and parallel implementations of a tree algorithm for RECAL.
Algorithmic Techniques for Computer Vision on a Fine-Grained Parallel Machine
Authors: J. J. Little, G. E. Blelloch, T. A. Cass
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The authors describe several fundamentally useful primitive operations and routines and illustrate their usefulness in a wide range of familiar version processes. These operations are described in terms of a vector machine model of parallel computation. They use a parallel vector model because vector models can be mapped onto a wide range of architectures. They also describe implementing these primitives on a particular fine-grained machine, the connection machine. It is found that these primitives are applicable in a variety of vision tasks. Grid permutations are useful in many early vision algorithms, such as Gaussian convolution, edge detection, motion, and stereo computation. Scan primitives facilitate simple, efficient solutions of many problems in middle- and high-level vision. Pointer jumping, using permutation operations, permits construction of extended image structures in logarithmic time. Methods such as outer products, which rely on a variety of primitives, play an important role of many high-level algorithms.
Constraint satisfaction problems in logic programming
Authors: Francesca Rossi
Venue: Issue 106 (October 1988) (1988)

Due to its relational form, its definite clause syntax and the possibility of writing metaprograms in the same language, it turns out that logic programming is a convenient programming language to represent, relax and solve constraint satisfaction problems (CSPs). Not only we can represent CSPs writing elegant logic programs in a declarative style, but we can also solve them in an efficient way by writing simple metaprograms adding new control strategies to the usual backtrack search strategy of logic programs. This paper defines the classes of CSPs we consider, shows the mapping between these CSPs and logic programs having the same semantics, and describes how to represent relaxation algorithms as logic metaprograms.
A connectionless congestion control algorithm
Authors: G. G. Finn
Venue: ACM SIGCOMM Computer Communication Review (1989)

This paper describes a congestion control algorithm that operates within a connectionless network environment. The algorithm controls a source's transmission rate, with that rate determined by feedback from the point of congestion. The algorithm is well suited to operate from within the IP layer of the TCP/IP protocol suite. An analytic model is developed to examine isolated aspects of the algorithm's behavior. A simulator was written to further test its behavior under a variety of topologies, loads, and path bandwidths. The results achieved are presented.
Algorithm 678: BTPEC: sampling from the binomial distribution
Authors: Voratas Kachitvichyanukul, Bruce W. Schmeiser
Venue: ACM Transactions on Mathematical Software (TOMS) (1989)

The FORTRAN implementation of an exact, uniformly fast algorithm for generating the binomial, random variables is presented. The algorithm is numerically stable and is faster than other published algorithms. The code uses only standard FORTRAN statements and is portable to most computers; it has been tested on the IBM 370, 3033, 4381, DEC VAX 11/780, SUN 3/50, CDC 6500-6600, ENCORE Multimax, and Apple Mcintosh Plus. A driver program is also included.
Adaptive storage control for page frame supply in large scale computer systems
Authors: Y. Yoshizawa, T. Arai
Venue: Proceedings of the 1988 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1988)

A real storage management algorithm called Adaptive Control of Page-frame Supply (ACPS) is described. ACPS employees three strategies: prediction of the demand for real page frames, page replacement based on the prediction, and working set control. Together, these strategies constitute the real page frame allocation method, and contribute to short and stable response times in conversational processing environments. ACPS is experimentally applied to the VOS3 operating system. Evaluation of ACPS on a real machine shows that TSS response times are not affected too strongly by king-size jobs and ACPS is successful in avoiding paging delay and thrashing. ACPS prevents extreme shortages of real storage in almost all cases.
Concurrency and availability as dual properties of replicated atomic data
Authors: M. Herlihy
Venue: Journal of the ACM (JACM) (1990)

A replicated data object is a typed object that is stored redundantly at multiple locations in a distributed system. Each of the object's operations has a set of quorums, which are sets of sites whose cooperation is needed to execute that operation. A quorum assignment associates each operation with its set of quorums. An operation's quorums determine its availability, and the constraints governing an object's quorum assignments determine the range of availability properties realizable by replication. In this paper, the restrictions on quorum assignment imposed by three kinds of atomicity mechanisms found in the literature are analyzed: (1) serial schemes, in which replication and atomicity are implemented independently at different levels in the system, (2) static schemes, in which the transaction serialization order is predetermined, and (3) hybrid schemes in which the serialization order emerges dynamically. The following results are derived: (1) Although serial schemes place the strongest restrictions on concurrency, they place the weakest restrictions on availability. (2) Although hybrid and static mechanisms place incomparable restrictions on concurrency, hybrid mechanisms place weaker restrictions on availability. (3) Bounding the maximum depth of transaction nesting strengthens restrictions on concurrency for all classes, but weakens restrictions on availability for hybrid schemes only. Concurrency and availability are best considered as dual properties: A complete analysis of an atomicity mechanism should take both into account.
Towards an efficient evaluation of general queries: quantifier and disjunction processing revisited
Authors: Francois Bry
Venue: ACM SIGMOD Record (1989)

Database applications often require to evaluate queries containing quantifiers or disjunctions, e.g., for handling general integrity constraints. Existing efficient methods for processing quantifiers depart from the relational model as they rely on non-algebraic procedures. Looking at quantified query evaluation from a new angle, we propose an approach to process quantifiers that makes use of relational algebra operators only. Our approach performs in two phases. The first phase normalizes the queries producing a canonical form. This form permits to improve the translation into relational algebra performed during the second phase. The improved translation relies on a new operator - the complement-join - that generalizes the set difference, on algebraic expressions of universal quantifiers that avoid the expensive division operator in many cases, and on a special processing of disjunctions by means of constrained outer-joins. Our method achieves an efficiency at least comparable with that of previous proposals, better in most cases. Furthermore, it is considerably simpler to implement as it completely relies on relational data structures and operators.
Real-time hierarchically distributed processing network interaction simulation
Authors: Wayne F. Zimmerman, Chung-I Wu
Venue: Proceedings of the 21st annual symposium on Simulation (1988)

The Telerobot Testbed is a hierarchically distributed processing system which is linked together through a standard, commercial Ethernet. Standard Ethernet systems are primarily designed to manage non-real-time information transfer. Therefore, collisions on the net (i.e., two or more sources attempting to send data at the same time) are managed by randomly rescheduling one of the sources to retransmit at a later time interval. Although acceptable for transmitting noncritical data such as mail, this particular feature is unacceptable for real-time hierarchical command and control systems such as the Telerobot. Data transfer and scheduling simulations, such as token ring, offer solutions to collision management, but do not appropriately characterize real-time data transfer/interactions for robotic systems. Therefore, models like these do not provide a viable simulation environment for understanding real-time network loading. A real-time network loading model is being developed which allows processor-to-processor interactions to be simulated, collisions (and respective probabilities) to be logged, collision-prone areas to be identified, and network control variable adjustments to be reentered as a means of examining and reducing collision-prone regimes that occur in the process of simulating a complete task sequence. The phase-one and phase-two development results are presented in this paper. Results include 1) the theoretical foundation for the network flow model, 2) an overview of the simulation design and constraints, 3) the software design, and 4) a summary and analysis of actual results. Ultimately, the simulation will be used to examine potential loading problems as out-year demo performance improvements cause increased data traffic. The simulation will also provide a systematic means of managing resulting loading problems.
How to read floating point numbers accurately
Authors: William D. Clinger
Venue: Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation (1990)

Consider the problem of converting decimal scientific notation for a number into the best binary floating point approximation to that number, for some fixed precision. This problem cannot be solved using arithmetic of any fixed precision. Hence the IEEE Standard for Binary Floating-Point Arithmetic does not require the result of such a conversion to be the best approximation. This paper presents an efficient algorithm that always finds the best approximation. The algorithm uses a few extra bits of precision to compute an IEEE-conforming approximation while testing an intermediate result to determine whether the approximation could be other than the best. If the approximation might not be the best, then the best approximation is determined by a few simple operations on multiple-precision integers, where the precision is determined by the input. When using 64 bits of precision to compute IEEE double precision results, the algorithm avoids higher-precision arithmetic over 99% of the time. The input problem considered by this paper is the inverse of an output problem considered by Steele and White: Given a binary floating point number, print a correctly rounded decimal representation of it using the smallest number of digits that will allow the number to be read without loss of accuracy. The Steele and White algorithm assumes that the input problem is solved; an imperfect solution to the input problem, as allowed by the IEEE standard and ubiquitous in current practice, defeats the purpose of their algorithm.
Integrating an object-oriented programming system with a database system
Authors: Won Kim, Nat Ballou, Jay Banerjee, Hong-Tai Chou, Jorge G. Garza, Darrell Woelk
Venue: ACM SIGPLAN Notices (1988)

There are two major issues to address to achieve integration of an object-oriented programming system with a database system. One is the language issue: an object-oriented programming language must be augmented with semantic data modeling concepts to provide a robust set of data modeling concepts to allow modeling of entities for important real-world applications. Another is the computational-model issue: application programmers should be able to access and manipulate objects as though the objects are in an infinite virtual memory; in other words, they should not have to be aware of the existence of a database system in their computations with the data structures the programming language allows. This paper discusses these issues and presents the solutions which we have incorporated into the ORION object-oriented database system at MCC.
Application of the Karhunen-Loeve Procedure for the Characterization of Human Faces
Authors: M. Kirby, L. Sirovich
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

The use of natural symmetries (mirror images) in a well-defined family of patterns (human faces) is discussed within the framework of the Karhunen-Loeve expansion. This results in an extension of the data and imposes even and odd symmetry on the eigenfunctions of the covariance matrix, without increasing the complexity of the calculation. The resulting approximation of faces projected from outside of the data set onto this optimal basis is improved on average.
A safe vertex
Authors: E. W. Felten, S. W. Otto
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications: Architecture, software, computer systems, and general issues - Volume 1 (1988)

The VERTEX message passing system provided with NCUBE hypercubes is unsafe. The system can fail under high message loads. We have implemented a message passing system with the same &ldquo;look and feel&rdquo; as VERTEX but which is instead based upon the crystal_router running at clock interrupt time. The system is written mostly in C with a few bits of assembly code to run the DMA devices. This implies that safety checks (are the buffers full?) and complex error handling mechanisms can be easily implemented at the C level. A first version works, is safe, and is faster than VERTEX in the high volume limit, slower in the low volume case. At the very least, this system will be interesting for high message traffic applications, such as disk backup.
Cone-spheres
Authors: Nelson Max
Venue: ACM SIGGRAPH Computer Graphics (1990)

A cone-sphere consists of two spheres, together with the part of the cylinder or cone tangent to the two spheres and lying between them. Cone-spheres can be rapidly rendered with shading, highlights, texture, or bump maps, and composited to create twisted or branched tubular structures.