ppxscal/embedding_network huggingface dataset:
Parallel execution of logic programs in the framework of OR-Forest
Authors: Y. Tzu, C. Sun
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

A new framework for parallel execution of logic programs is described in this paper. First, we present the OR-forest description for the execution of logic programs. Then, an algorithm for automatic partition of subgoals and an OR-forest-based process model are given and discussed. All the algorithms and schemes discussed in this paper have been implemented in PROLOG and their correctness and feasibility have been proved by testing a number of benchmark programs. Experiments show that the OR-forest-based execution system, incorporated with an automatic partition algorithm, can efficiently exploit parallelisms in both deterministic and nondeterministic programs, and nearly always achieve optimal AND-OR-parallelism.
Path of subterms ordering and recursive decomposition ordering revisited
Authors: Michael Rusinowitch
Venue: Journal of Symbolic Computation (1987)

The relationship between several simplification orderings is investigated: the path of subterms ordering, the recursive path ordering and the recursive decomposition ordering. The recursive decomposition ordering is improved in order to deal with more pairs of terms, and is made more efficient and easier to handle, by removing useless computations.
Prototype software complexity metrics tools
Authors: C. C. Cook, M. Nanja
Venue: ACM SIGSOFT Software Engineering Notes (1987)

Software Complexity Metrics Tool (SCMT) is a prototype, menu-driven program that assists in the collection, analysis, and display of software complexity and program error data. For example, using SCMT a user can investigate relationships between software complexity metrics and the number of errors in a program or can begin to develop predictive models for identifying error-prone modules.SCMT is written in C and runs under UNIX trade;. Although designed specifically for C software, its concepts and techniques apply to software in any programming language.
Rectilinear shortest paths through polygonal obstacles in O(n(logn)2) time
Authors: K. Clarkson, S. Kapoor, P. Vaidya
Venue: Proceedings of the third annual symposium on Computational geometry (1987)

The problem of finding a rectilinear shortest path amongst obstacles may be stated as follows: Given a set of obstacles in the plane find a shortest rectilinear (L1) path from a point s to a point t which avoids all obstacles. The path may touch an obstacle but may not cross an obstacle. We study the rectilinear shortest path problem for the case where the obstacles are non-intersecting simple polygons, and present an &Ogr;(n (logn)2) algorithm for finding such a path, where n is the number of vertices of the obstacles. We also study the case of rectilinear obstacles in three dimensions, and show that L1 shortest paths can be found in &Ogr;(n2(log n)3) time.
Reliability theory applied to software testing
Authors: D. Drake
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

Assessment of the reliability of a software product is a key element in the decision to release the product. As with hardware, a theoretical model and related metrics exist that can be practically applied to estimate the software reliability of a product prior to its release. The methods used to evaluate software reliability for Hewlett Packard terminals are presented in this paper.
Interfacing user processes an kernel in high level language
Authors: M Ancona, A Clematis, V Gianuzzi
Venue: ACM SIGOPS Operating Systems Review (1986)

We present a method to simplify the implementation of a kernel supporting a high level concurrent language on a bare multiprocessor system.User and system level languages (with as much common syntax as possible) are defined. The system language consists of those constructs which do not require concurrency support, plus other facilities which make it well suited to write the kernel supporting the user language. Such constructs must provide the equivalent of a supervisor call interface within a high level language.All machine dependencies for both the system and user languages have been encapsulated in the code generation phase of the compilation process. Our method reduces the retargeting problem of a kernel to the orientability problem of the code generator.Finally our experiences in using such methodology are discussed.
On conjunctive queries containing inequalities
Authors: Anthony Klug
Venue: Journal of the ACM (JACM) (1988)

Conjunctive queries are generalized so that inequality comparisons can be made between elements of the query. Algorithms for containment and equivalence of such &ldquo;inequality queries&rdquo; are given, under the assumption that the data domains are dense and totally ordered. In general, containment does not imply the existence of homomorphisms (containment mappings), but the homomorphism property does exist for subclasses of inequality queries. A minimization algorithm is defined using the equivalence algorithm. It is first shown that the constants appearing in a query can be divided into &ldquo;essential&rdquo; and &ldquo;nonessential&rdquo; subgroups. The minimum query can be nondeterministically guessed using only the essential constants of the original query.
Functional programming, the IEEE floating point standard and APL
Authors: Terence J. Reed
Venue: Proceedings of the international conference on APL: APL in transition (1987)

The IEEE standard for floating point numbers is by now reasonably well known, but less well known is the fact that this standard provides for a certain exceptional class of bit patterns, the use of which are left to the user. In this paper we explore uses for this class among which are provisions for a variety of infinities and a flag for undefined entities. It is proposed that the functional programming aspect of APL be strengthened by the provision of void returns as provided in a few other languages such as LISP. At the programming level we explore methods for providing within APL near functional programming capabilities.
The Fast Hartley Transform Algorithm
Authors: H. S. Hou
Venue: IEEE Transactions on Computers (1987)

The fast Hartley transform (FHT) is similar to the Cooley-Tukey fast Fourier transform (FFT) but performs much faster because it requires only real arithmetic computations compared to the complex arithmetic computations required by the FFT. Through use of the FHT, discrete cosine transforms (DCT) and discrete Fourier transforms (DFT) can be obtained. The recursive nature of the FHT algorithm derived in this paper enables us to generate the next higher order FHT from two identical lower order FHT's. In practice, this recursive relationship offers flexibility in programming different sizes of transforms, while the orderly structure of its signal flow-graphs indicates an ease of implementation in VLSI.
Summarizing natural language database responses
Authors: Jugal K. Kalita, Marlene L. Jones, Gordon I. McCalla
Venue: Computational Linguistics (1986)

In a human dialogue it is usually considered inappropriate if one conversant monopolizes the conversation. Similarly it can be inappropriate for a natural language database interface to respond with a lengthy list of data. A non-enumerative "summary" response is less verbose and often avoids misleading the user where an extensional response might.In this paper we investigate the problem of generating such discourse-oriented concise responses. We present details of the design and implementation of a system that produces summary responses to queries of a relational data base. The system employs a set of heuristics that work in conjunction with a knowledge base to discover underlying regularities that form the basis of summary responses. The system is largely domain-independent, and hence can be ported relatively easily from one data base to another. It can handle a wide variety of situations requiring a summary response and can be readily extended. It also has a number of shortcomings which are discussed thoroughly and which form the basis for a number of suggested research directions.
Clarify function]
Authors: N. Anand
Venue: ACM SIGPLAN Notices (1988)

The biggest obstacle in understanding large software systems is the sheer quantity of information that has to be explicitly remembered by a programmer. Our ability to understand a system directly determines the ease with which it can be modified, maintained or extended; programmers are hence in need of techniques which, when applied, result in systems that can be understood quickly and effectively. In this paper, some practical techniques for constructing such "highly understandable" systems are presented. The paper starts with an analysis of how we humans understand a system --- it is demonstrated that we do so by identifying the functions of various entities in it. On the basis of this important observation, the argument for naming entities by the function that they perform is developed. Some concrete rules for naming procedures, variables, pointers, etc. are subsequently suggested and the reasons why these rules should obviate the need to remember are explored. We further argue why inability to name according to the given criteria should be interpreted as an indication of poor quality of the system. Thus, we conclude that the way to construct systems that can be understood quickly and effectively is to name entities in the system by the function that they perform.
Embedding continuations in procedural objects
Authors: Christopher T. Haynes, Daniel P. Friedman
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1987)

Continuations, when available as first-class objects, provide a general control abstraction in programming languages. They liberate the programmer from specific control structures, increasing programming language extensibility. Such continuations may be extended by embedding them in procedural objects. This technique is first used to restore a fluid environment when a continuation object is invoked. We then consider techniques for constraining the power of continuations in the interest of security and efficiency. Domain mechanisms, which create dynamic barriers for enclosing control, are implemented using fluids. Domains are then used to implement an unwind-protect facility in the presence of first-class continuations. Finally, we present two mechanisms, wind-unwind and dynamic-wind, that generalize unwind-protect.
Personal distributed computing: the Alto and Ethernet hardware
Authors: Chuck Thacker
Venue: Proceedings of the ACM Conference on The history of personal workstations (1986)

Between 1972 and 1980, the first distributed personal computing system was built at the Xerox Palo Alto Research Center. The system was composed of a number of Alto workstations connected by an Ethernet local network. It also included servers that provided centralized facilities. This paper describes the development of the hardware that was the basis of the system.
Some tests of generalized bisection
Authors: R. Baker Kearfott
Venue: ACM Transactions on Mathematical Software (TOMS) (1987)

This paper addresses the task of reliably finding approximations to all solutions to a system of nonlinear equations within a region defined by bounds on each of the individual coordinates. Various forms of generalized bisection were proposed some time ago for this task. This paper systematically compares such generalized bisection algorithms to themselves, to continuation methods, and to hybrid steepest descent/quasi-Newton methods. A specific algorithm containing novel &ldquo;expansion&rdquo; and &ldquo;exclusion&rdquo; steps is fully described, and the effectiveness of these steps is evaluated. A test problem consisting of a small, high-degree polynomial system that is appropriate for generalized bisection, but very difficult for continuation methods, is presented. This problem forms part of a set of 17 test problems from published literature on the methods being compared; this test set is fully described here.
The simultaneous solution and sensitivity analysis of systems described by ordinary differential equations
Authors: Jorge R. Leis, Mark A. Kramer
Venue: ACM Transactions on Mathematical Software (TOMS) (1988)

The methodology for the simultaneous solution of ordinary differential equations and the associated first-order parametric sensitivity equations is presented, and a detailed description of its implementation as a modification of a widely disseminated implicit ODE solver is given. The error control strategy ensures that local error criteria are independently satisfied by both the model and sensitivity solutions. The internal logic effectuated by this implementation is detailed. Numerical testing of the algorithm is reported; results indicate that greater reliability and improved efficiency is offered over other sensitivity analysis methods.
Row/Column Replacement for the Control of Hard Defects in Semiconductor RAM's
Authors: T Fuja, C Heegard
Venue: IEEE Transactions on Computers (1986)

We describe and analyze row/column replacement, the technique currently used to control hard cell defects in semiconductor RAM's during manufacture. This strategy is shown to be asymptotically ineffective; it is demonstrated that this ineffectiveness may become a limiting issue for very large memory arrays.
Office-by-example: an integrated office system and database manager
Authors: Kyu-Young Whang, Art Ammann, Anthony Bolmarcich, Maria Hanrahan, Guy Hochgesang, Kuan-Tsae Huang, Al Khorasani, Ravi Krishnamurthy, Gary Sockut, Paula Sweeney, Vance Waddle, Moshé Zloof
Venue: ACM Transactions on Information Systems (TOIS) (1987)

Office-by-Example (OBE) is an integrated office information system that has been under development at IBM Research. OBE, an extension of Query-by-Example, supports various office features such as database tables, word processing, electronic mail, graphics, images, and so forth. These seemingly heterogeneous features are integrated through a language feature called example elements. Applications involving example elements are processed by the database manager, an integrated part of the OBE system. In this paper we describe the facilities and architecture of the OBE system and discuss the techniques for integrating heterogeneous objects.
When will we have true heterogeneous databases?
Authors: A. K. Elmagarmid
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

A heterogeneous distributed database is a system of interconnected DBMSs that use different strategies for data and transaction management. Though issues such as universal query languages, and global view and schema integration have been investigated, transaction management issues introduced by the integration of separate database management systems into one global database have not been widely addressed in the literature. Probably most disturbing to me is the general misunderstanding in the database community as to what a heterogeneous database really is. Many people seem to refer to distributed databases as heterogeneous databases. Of interest to me are questions relating to transaction support in the heterogeneous database environment. Two basic approaches are possible in order to integrate differing DBMS's. The first approach integrates transaction management policies into one global transaction manager that handles subtransactions accessing the heterogeneous database. The second is based on hierarchical composition of transaction management policies. In the latter approach, software is added on top of existing systems whenever needed (Gligor and Luckenbaugh, Interconnecting Heterogeneous Database Management Systems, IEEE Computer January 1984). The heterogeneous database research group at Penn State consists of three students along with myself. We are looking at concurrency control (Y. Leu), recovery (D. Mannai), and deadlock issues (I. Mahgoub). In this panel I would like to discuss the following set of related questions: Which of the problems are due to DBMS integration and not due to heterogeneity? How is the consistency of heterogeneous databases defined? How does serializability apply to heterogeneous databases? How strict must the definition of database autonomy be? How does it complicate transaction management issues? How important are atomic updates in this environment? How often are they expected? Are we likely to have generalized solutions to the problem of concurrency control and recovery? In the discussion we would like to consider all possible systems depicted in the figure below. Especially in the shaded areas.
Plane curves of minimal energy
Authors: Michael Kallay
Venue: ACM Transactions on Mathematical Software (TOMS) (1986)

The problem of finding the plane curve of minimal elastic energy with prescribed endpoints and end-directions was solved in 1983 by B. K. P. Horn. Here the solution is discussed, given a very short proof, and extended to include a constant on length.
The Calcualtion of Multiplicative Inverses Over GF(P) Efficiently Where P is a Mersenne Prime
Authors: J J Thomas, J M Keller, G N Larsen
Venue: IEEE Transactions on Computers (1986)

The extended Euclidean algorithm is typically used to calculate multiplicative inverses over finite fields and rings of integers. The algorithm presented here has approximately the same number of average iterations and maximum number of iterations. It is shown, when P is a Mersenne prime, implementation of this algorithm on a processor, designed especially for mod P arithmetic operations, produces a more efficient algorithm with respect to the amount of program statements and number of operations. It is then shown heuristically, when the division and multiplications are performed simultaneously, the Euclidean algorithm has fewer subiterations.
Reading text from computer screens
Authors: Carol Bergfeld Mills, Linda J. Weldon
Venue: ACM Computing Surveys (CSUR) (1987)

This paper reviews empirical studies concerning the readability of text from computer screens. The review focuses on the form and physical attributes of complex, realistic displays of text material. Most studies comparing paper and computer screen readability show that screens are less readable than paper. There are many factors that could affect the readability of computer screens. The factors explored in this review are the features of characters, the formatting of the screen, the contrast and color of the characters and background, and dynamic aspects of the screen. Numerous areas for future research are pinpointed.
A three-layer gridless channel router with compaction
Authors: D. B. Polkl
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper presents a channel router that is designed to handle channels having irregularly-spaced terminals on different layers. The development of this router has investigated combining several basic wiring functions in distinct stages to achieve the required performance. Both grid-based and river routing techniques are used to provide a preliminary wiring of the channel. Subsequent routing phases employ via reduction and vertical compaction to improve the channel wiring. Layer changes in wires that are introduced during the via reduction stage tend to enhance the results achieved during the compaction process. The router resulting from this approach acts as a gridless router capable of handling three layers of interconnect. Details of the approach and the results obtained are discussed. The adaptation of the router to variable-width wiring is also discussed and illustrated.
Viable inference systems
Authors: Joseph Deken
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

Because uncertain and provisional reasoning is an inherent part of intelligent systems, a diverse (and competing) array of formalisms for handling uncertain inference has been developed in theory and practice. Each of these formalisms tends to be argued and justified on its own ground, starting from assumptions which ensure its &ldquo;correctness&rdquo; or &ldquo;optimality.&rdquo; It is argued here, however, that the key concept for an intelligent system is viability - it is as unproductive to seek &ldquo;correctness&rdquo; in open inference systems as it would be to prove the &ldquo;optimality&rdquo; of a biological organism. Several inference formalisms are examined in the light of this criticism. The viability of systems based on these formalisms is seen to rest critically on their robustness to changes in their context. The assumptions which usually function to hold that context fixed must thus be critically examined.
Verification of Register Transfer Level Parallel Control Sequences
Authors: Vijay Pitchumani, Edward P. Stabler
Venue: IEEE Transactions on Computers (1985)

This correspondence presents a method for proof of correctness of register transfer level (RTL) parallel control sequences that describe hardware behavior. An RTL language endowed with parallel constructs is presented and its semantics is defined. The semantics includes temporal behavior. An assertion-based proof method is presented for verification of parallel control sequences described in this language. An example is given and comparisons are drawn between proofs of parallel register transfer level sequences and parallel programs. The temporal semantics associated with the language permits the construction and proof of parallel sequences that are not possible with parallel programs. Accessing shared resources outside critical regions is possible and is illustrated.
Mean Value Analysis for Blocking Queueing Networks
Authors: Ian F. Akyildiz
Venue: IEEE Transactions on Software Engineering (1988)

Mean value analysis is an exact solution technique for infinite capacity queueing networks and enjoyed widespread popularity during recent years.It considers the behavior of the system by stepwise increasing the number of jobs in the entire network, thus it is well suited for the analysis of queueing networks with blocking.In this work, an approximation is introduced for the mean value analysis queueing networks with transfer blocking.The blocking occurs when a job, after service at a station, wants to join a station which is full.The job resides in the server of the source station until a place becomes available in the destination station.The approximation is based on the modification of mean residence times due to the blocking events that occur in the network.Several examples are executed in order to validate the approximate results.
Maniplicons in ThinkerToy
Authors: Steven H. Gutfreund
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1987)

ThinkerToy is a graphical environment for modeling decision support problems. It provides a tableau on which such problems as landscape planning, service scheduling, and statistical analysis can be modeled and analyzed. Normally, complex mathematical and statistical modeling techniques are needed to perform meaningful analysis. ThinkerToy uses graphical icons with concrete physical properties to replace mathematical relationships and properties. The key construct in this methodology is the ManiplIcon: an icon which is not just a pictorial representation, but also a semantic tool for building models which homorphically represent semi-structured problems.