ppxscal/embedding_network huggingface dataset:
Dimensionality-Reduction Using Connectionist Networks
Authors: E. Saund
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

A method is presented for using connectionist networks of simple computing elements to discover a particular type of constraint in multidimensional data. Suppose that some data source provides samples consisting of n-dimensional feature-vectors, but that this data all happens to lie on an m-dimensional surface embedded in the n-dimensional feature space. Then occurrences of data can be more concisely described by specifying an m-dimensional location of the embedded surface than by reciting all n components of the feature vector. The recording of data in such a way is known as dimensionality-reduction. A method is presented for performing dimensionality-reduction in a wide class of situations for which an assumption of linearity need not be made about the underlying constraint surface. The method takes advantage of self-organizing properties of connectionist networks of simple computing elements. The authors present a scheme for representing the values of continuous (scalar) variables in subsets of units.
Vectorized dissection on the hypercube
Authors: T-H. Olesen, J. Petersen
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

Dissection ordering is used with Gaussian elimination on a Hypercube parallel processor with vector hardware to solve matrices arising from finite-difference and finite-element discretizations of 2-D elliptic partial differential equations. These problems can be put into a matrix-vector form, Ax = f, where the matrix A takes the place of the differential operator, x is the solution vector, and f is the source vector. The domain is divided among the nodes with neighboring subdomains sharing a strip called a separator. Each processor is given its own part of the source vector and computes its own part of the stiffness matrix, A. The elimination starts out in parallel; communication is only needed after most of the elimination is finished when the edges need to be eliminated. Back substitution is initially done on the domain edges, and then totally in parallel without communication on each node. The Hypercube code involved was optimized to work with vector hardware. Example problems and timings are given with comparisons to nonvector runs.
A lazy buddy system bounded by two coalescing delays
Authors: R. Barkley, T. Lee
Venue: Proceedings of the twelfth ACM symposium on Operating systems principles (1989)

The watermark-based lazy buddy system for dynamic memory management uses lazy coalescing rules controlled by watermark parameters to achieve low operational costs. The correctness of the watermark-based lazy buddy system is shown by defining a space of legal states called the lazy space and proving that the watermark-based lazy coalescing rules always keep the memory state within that space. In this paper we describe a different lazy coalescing policy, called the DELAY-2 algorithm, that focuses directly on keeping the memory state within the lazy space. The resulting implementation is simpler, and experimental data shows it to be up to 12% faster than the watermark-based buddy system and about 33% faster than the standard buddy system. Inexpensive operations make the DELAY-2 algorithm attractive as a memory manager for an operating system. The watermark-based lazy buddy policy offers fine control over the coalescing policy of the buddy system. However, applications such as the UNIX System kernel memory manager do not need such fine control. For these applications, the DELAY-2 buddy system provides an efficient memory manager with low operational costs and low request blocking probability. In the DELAY-2 buddy system, the worst-case time for a free operation is bounded by two coalescing delays per class, and when all blocks are returned to the system, the system memory is coalesced back to its original state. This ensures that the memory space can be completely shared.
Constructing Two-Writer Atomic Registers
Authors: B. Bloom
Venue: IEEE Transactions on Computers (1988)

A two-writer, n-reader atomic memory register is constructed from two one-writer, (n+1)-reader atomic memory registers. There are no restrictions on the size of the constructed register. The simulation requires only a single extra bit per real register and can survive the failure of any set of readers and writers. A complete proof of correctness is given. Several obvious ways are suggested to try to extend this algorithm to more than two writers, none of which work. As an example, it is shown how a natural extension of the two-writer protocol fails.
Corporate contributions: Is the tail wagging the dog?
Authors: M. Draper, R. W. Lutz, J. Nicholson
Venue: ACM SIGUCCS Newsletter (1989)

Nicholson: Before I go directly to my argument that the tail is not wagging the dog, let me share with you a little information about Howard University and how computing fits into the overall organization.
Compile-time techniques for efficient utilization of parallel memories
Authors: Rajiv Gupta, Mary Lou Soffa
Venue: Proceedings of the ACM/SIGPLAN conference on Parallel programming: experience with applications, languages and systems (1988)

The partitioning of shared memory into a number of memory modules is an approach to achieve high memory bandwidth for parallel processors. Memory access conflicts can occur when several processors simultaneously request data from the same memory module. Although work has been done to improve access performance for vectors, no work has been reported to improve the access performance of scalars. For systems in which the processors operate in a lock-step mode, a large percentage of memory access conflicts can be predicted at compile-time. These conflicts can be avoided by appropriate distribution of data among the memory modules at compile-time. A long instruction word machine is an example of a system in which the functional units operate in a lock-step mode performing operations on data fetched in parallel from multiple memory modules. In this paper, compile-time techniques for distribution of scalars to avoid memory access conflicts are presented. Furthermore, algorithms to schedule data transfers among memory modules to avoid conflicts that cannot be avoided by the distribution of values alone are developed. The techniques have been implemented as part of a compiler for a reconfigurable long instruction word architecture. Results of experiments are presented demonstrating that a very high percentage of memory access conflicts can be avoided by scheduling a very low number of data transfers.
A Theory of Attributed Equivalence in Databases with Application to Schema Integration
Authors: J. A. Larson, S. B. Navathe, R. Elmasri
Venue: IEEE Transactions on Software Engineering (1989)

The authors present a common foundation for integrating pairs of entity sets, pairs of relationship sets, and an entity set with a relationship set. This common foundation is based on the basic principle of integrating attributes. Any pair of objects whose identifying attributes can be integrated can themselves be integrated. Several definitions of attribute equivalence are presented. These definitions can be used to specify the exact nature of the relationship between a pair of attributes. Based on these definitions, several strategies for attribute integration are presented and evaluated.
Direct WYSIWYG painting and texturing on 3D shapes: An error occurred during the printing of this article that reversed the print order of pages 118 and 119. While we have corrected the sort order of the 2 pages in the DL, the PDF did not allow us to repaginate the 2 pages.
Authors: Pat Hanrahan, Paul Haeberli
Venue: ACM SIGGRAPH Computer Graphics (1990)

This paper describes a 3D object-space paint program. This program allows the user to directly manipulate the parameters used to shade the surface of the 3D shape by applying pigment to its surface. The pigment has all the properties normally associated with material shading models. This includes, but is not limited to, the diffuse color, the specular color, and the surface roughness. The pigment also can have thickness, which is modeled by simultaneously creating a bump map attached to the shape. The output of the paint program is a 3D model with associated texture maps. This information can be used with any rendering program with texture mapping capabilities. Almost all traditional techniques of 2D computer image painting have analogues in 3D object painting, but there are also many new techniques unique to 3D. One example is the use of solid textures to pattern the surface.
Applications of qualitative modeling to knowledge-based risk assessment studies
Authors: Gautam Biswas, Kenneth A. Debelak, Kazuhiko Kawamura
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

Risk assessment of technological processes (chemical and power plants, electro-mechanical systems) is a complex process that requires enumeration of all possible failure modes, their probability of occurrence, and their consequences. Traditionally such studies have been performed by a committee of expert engineers with diverse backgrounds. This paper discusses the use of qualitative modeling techniques based on deriving behavior from structural descriptions and causal reasoning to aid automating and enhancing the risk analysis process. Hierarchical schemes are used for describing component structure, and system functionality is derived from a set of primitive functions and parameters defined for the domain. The system uses these models to automatically generate fault and event networks for hypothesized fault situations specified by users.
A Note on Detecting Sneak Paths in Transistor Networks
Authors: S. Chakravarty, H. B. Hunt
Venue: IEEE Transactions on Computers (1989)

The problem of detecting sneak paths in transistor networks arises in the minimization of transistor networks. It is shown that the problem of detecting consistent sneak paths in very simple transistor networks is co-NP-complete.
Provably fast integer factoring with quasi-uniform small quadratic residues
Authors: B. Vallée
Venue: Proceedings of the twenty-first annual ACM symposium on Theory of computing (1989)

Finding small quadratic residues modulo n, when n is a large composite number of unknown factorisation is almost certainly a computationally hard problem. This problem arises in a natural way when factoring n by the use of congruences of squares. We construct here a polynomial-time algorithm based on the use of lattices, which finds in a near uniform way quadratic residues mod n that are smaller than O(n2/3). In this way, we derive a class of integer factorisation algorithms, the fastest of which provides the best rigorously established probabilistic complexity bound for integer factorisation algorithms.
Hierarchically organised formalisations
Authors: T. Routen
Venue: Proceedings of the 2nd international conference on Artificial intelligence and law (1989)

Formalisations to date have tended to ignore a salient feature of statutes: they exhibit a multi-layered logical structure. This, rather than the unsuitability of logic for representing statute law, is at the root of at least some of the knowledge representation problems researchers have uncovered. In addition, the failure of any formalisation to mirror this kind of structure means that it inevitably will be an impoverished translation of the original article.
Verification of hardware descriptions by retargetable code generation
Authors: L. Nowak, P. Marwedel
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

This paper proposes a new method for hardware verification. The basic idea is the application of a retargetable compiler as verification tool. A retargetable compiler is able to compile programs into the machine code of a specified hardware (target). If the program is the complete behavioural specification of the target, the compiler can be used to verify that a properly programmed structure implements the behaviour. Methods, algorithms and applications of an existing retargetable compiler are described.
Automatic reasoning about numerical stability of rational expressions
Authors: B. W. Char
Venue: Proceedings of the ACM-SIGSAM 1989 international symposium on Symbolic and algebraic computation (1989)

While numerical (e.g. Fortran) code generation from computer algebra is nowadays relatively easy to do, the expressions as they are produced via computer algebra typically benefit from non-trivial reformulation for efficiency and numerical stability. To assist in automatic &ldquo;expert reformulation&rdquo;, we desire good automated tools to assess the stability of a particular form of an expression. In this paper, we discuss an approach to proofs of numerical stability (with respect to roundoff error) of rational expressions. The proof technique is based upon the ability to propagate properties such as sign, exact representability, or a certain kind of numerical stability, to floating point results from properties of their antecedents. The qualitative approach to numerical stability (inspired by [12]) lends itself to implementation as a backwards-chaining theorem prover. While it is not a replacement for alternative forms of stability analysis, it can sometimes discover stability and explain it straightforwardly.
An experimental investigation of the close procedure as a measure of program understanding
Authors: J. R. Ullrich, C. Cook
Venue: ACM SIGCSE Bulletin (1989)

The cloze procedure consists of systematically replacing tokens from a computer program with blanks. The cloze score, the number of blanks filled in correctly, has been used as a measure of program understanding in many experiments because it is easy to construct and score. However, little is known about the process by which the subjects fill in the blanks. This paper describes a program that collects information about the process. The program allows the subject to take a cloze test on the computer; it records the keystrokes and time as the subject fills in the blanks. Use of the program in a program comprehension experiment provided insight about differences between the subjects, order of insertion of tokens, and possible chunking strategies used by the subjects.
Compiling techniques for first-order liner recurrences on a Vector computer
Authors: Y. Tanaka, K. Iwasawa, S. Gotoo, Y. Umetani
Venue: Proceedings of the 1988 ACM/IEEE conference on Supercomputing (1988)

Linear recurrences are the most important class of non-vectorizable problems in typical scientific/engineering calculations. This work discusses high performance methods for solving first-order linear recurrences on a vector computer, investigates automatic transformations, and develops the compiling techniques for first-order linear recurrence problems. These results show that the improved vector code generated by the vectorizing compiler run at the rate of 150 MFLOPS (million floating operations per second), in the case of the moderate loop lengths (>1000), and at the rate of over 200 MFLOPS, in the case of the long loop lengths (>10000), on the HITAC S-820 supercomputer. Also, overall performance improvements of 69% in the 14 Lawrence Livermore Loops and 25% in the 24 Lawrence Livermore Loops, as measured by the harmonic mean, are attained.
Critical issues in mapping neural networks on message-passing multicomputers
Authors: J. Ghosh, K. Hwang
Venue: ACM SIGARCH Computer Architecture News (1988)

Connectionist models such as artificial neural systems, offer an intrinsically concurrent computational paradigm. We investigate the architectural requirements for efficiently simulating large neural networks on a multicomputer system with thousands of fine-grained processors and distributed memory. First, models for characterizing the structure of a neural network and the function of individual cells are developed. These models provide guidelines for efficiently mapping the network onto multicomputer topologies such as the hypercube, hypernet and torus. They are further used to estimate the amount of interprocessor communication bandwidth required, and the number of processors needed to meet a particular cost/performance goal. Design issues such as memory organization and the effect of VLSI technology are also considered.
Models of software development environments
Authors: D. E. Perry, G. E. Kaiser
Venue: Proceedings of the 10th international conference on Software engineering (1988)

We present a general model of software development environments that consists of three components: policies, mechanisms and structures. The advantage of this formalization is that it distinguishes precisely those aspects of an environment that are useful in comparing and contrasting software development environments. We introduce four classes of models by means of a sociological metaphor that emphasizes scale: the individual, the family, the city and the state models. The utility of this taxonomy is that it delineates the important classes of interaction among software developers and exposes the ways in which current software development environments inadequately support the development of large systems. Environments reflecting the individual and family models are the current state of the art. Unfortunately, these two models are ill-suited for the development of large systems that require more than, say, 20 programmers. We argue that there is a qualitative difference between the interactions among a small, &ldquo;family&rdquo; project and a large, &ldquo;city&rdquo; project and that this qualitative difference requires a fundamentally different model of software development environments. We illustrate the city model with Inscape/Infuse and ISTAR, the only two environments we know of that instantiate this model, and show that there is a pressing need for further research on this kind of environment. Finally, we postulate a state model, which is in need of further clarification, understanding and, ultimately, implementation.
Support for data-intensive applications: conceptual design and software development
Authors: Alexander Borgida, John Mylopoulos, Joachim W. Schmidt, Ingrid Wetzel
Venue: Proceedings of the second international workshop on Database programming languages (1989)

In the process of developing an Information System, one passes through stages that include requirements gathering, design specification, and software implementation. The purpose of the TDL language is to express the conceptual design of an information system; it is the intermediate language in a triad that includes the language Telos, which captures an evolutionary view of the application domain and requirements, and DBPL, a procedural programming language that has persistent values and transactions supporting the development of databases. We consider TDL's features for specifying the data and eventual procedural components of the system, and discuss how these are related to its companions. We also survey several tools for manipulating TDL descriptions which are currently under development, and give a detailed example of the iterative refinement of TDL designs into DBPL programs.
Misconceived misconceptions?
Authors: M. E. J. Masson, W. C. Hill, J. Conner, R. Guidon
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (1988)

Detailed user activity scripts from two previous studies of novice users working at a command language or a direct representation interface were submitted to independent expert judges for the justified ascription of misconceptions. Our initial hypothesis was that behavioral evidence for such misconceptions comes about as a result of well-articulated hypothetical reasoning. Although the evidence we obtained supports this view, it also suggests that for the direct representation case some activity normally attributed to misconceptions is non-reasoned in nature and governed by inherent powers of the representation.
Application of symbolic algebra to the instability of a nonconservative system
Authors: Isaac Elishakoff, Brian Couch
Venue: Journal of Symbolic Computation (1987)

This paper deals with flutter buckling of a tapered column resting on a uniform elastic foundation and subjected to a follower force, The Galerkin method is applied, with attendant computations performed by a computer algebra.
Expressing mathematical subroutines constructively
Authors: Gerald Roylance
Venue: Proceedings of the 1988 ACM conference on LISP and functional programming (1988)

The typical subroutines that compute sin(x) and exp(x) bear little resemblance to our mathematical knowledge of these functions: they are composed of concrete arithmetic expressions that include many mysterious numerical constants. Instead of programming these subroutines conventionally, we can express their construction using symbolic ideas such as periodicity, Taylor series, and economization. Such an approach has many advantages: the code is closer to the mathematical basis of the function, is less vulnerable to errors, and is trivially adaptable to various precisions.
Towards a compiler for a constraint language
Authors: Hans Werner Guesgen
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

For many engineering tasks, constraints are a useful knowledge representation formalism to specify functional relationships. In this paper, we describe a programming language based on constraints which, unlike former approaches, enables us to handle sets of possible values (rather than single values) and to filter them until consistent subsets are obtained that satisfy the constraints.As, e.g., in technical systems, the constraint relations are of different complexity, structure, and applicability, several ways to describe a relation are provided. Different control strategies are available, computing local consistency as well as globally consistent solutions. It is sketched how to realize a compiler for the language, which optimizes constraint descriptions during definition time. As a result, combinatorial explosion can be reduced, depending on the number of variables used in a constraint description.CONSAT is used in several applications, for example, in a system for process diagnosis [Voss 1988], where constraints are applied to maintain functional relationships in physical units. For this purpose, CONSAT was incorporated into the hybrid knowledge representation system BABYLON in order to use constraints together with rules, frames, and Prolog [Guesgen et al. 1987].
Equational problems anddisunification
Authors: Hubert Comon, Pierre Lescanne
Venue: Journal of Symbolic Computation (1989)

Roughly speaking, an equational problem is a first order formula whose only predicatesymbol is =. We propose some rules for the transformation of equational problems and study their correctness in various models. Then, we give completeness results with respect to some ''simple'' problems called solved forms. Such completeness results still hold when adding some control which moreover ensures termination. The termination proofs are given for a ''weak'' control and thus hold for the (large) class of algorithms obtained by restricting the scope of the rules. Finally, it must be noted that a by-product of our method is a decision procedure for the validity in the Herbrand Universe of any first order formula with the only predicate symbol=.