ppxscal/embedding_network huggingface dataset:
Multisystem Coupling by a Combination of Data Sharing and Data Partitioning
Authors: J. L. Wolf, D. M. Dias, B. R. Iyer, P. S. Yu
Venue: IEEE Transactions on Software Engineering (1989)

A hybrid architecture is proposed that combines the approaches of a multisystem partitioned database system and a data-sharing multisystem approach offering the advantages of each. With this architecture some databases are shared between systems, while others are retained private by specific systems. The authors examine how to determine which databases to share, which to retain private, and how to route transactions and partition the private databases among systems so as to minimize response time or overheads while balancing the load among systems. A simulated annealing heuristic is used to solve this optimizing problem. Trace data from large mainframe systems running IBM's Information Management System database management system are used to illustrate the methodology and to demonstrate the advantages of the hybrid approach.
Rewrite, rewrite, rewrite, rewrite, rewrite...
Authors: Nachum Dershowitz, S. Kaplan
Venue: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1989)

The theory of term rewriting systems has important applications in abstract data type specifications and functional programming languages. We begin here a study of properties of systems that are not necessarily terminating, but allow for infinite derivations that have a limit. In particular, we give conditions for the existence of a limit and for its uniqueness.
Software Evolution Through Rapid Prototyping
Authors: Luqi
Venue: Computer (1989)

Rapid prototyping is defined, and its role in software evolution is examined. Software evolution refers to all activities that change a software system. It differs from maintenance in that the latter is done after the initial development, whereas evolution activities are interleaved with the initial development and continue after the delivery of the initial version of the system. In the author's approach to rapid prototyping, software systems are delivered incrementally and requirements analysis continues throughout the process, interleaved with implementation and evolution. The focus is on reducing requirements errors through prototyping before undertaking the incremental implementation effort for each deliverable version of the system. The evolution of a hyperthermia system is considered as an example.
Fault Diagnosis of RAMs from Random Testing Experiments
Authors: René David, Antoine Fuentes
Venue: IEEE Transactions on Computers (1990)

It is shown how random testing experiments can be used for fault diagnosis. Starting from a prescribed set of faults, the result of the first experiment allows the authors (1) to determine a subset of faults which are compatible with this result and (2) to choose the second experiment, and so on. An algorithm (each step of which is an experiment) is given, and simulation results are presented.
Polynomials over finite fields with large images
Authors: J. von zur Gathen
Venue: Proceedings of the international symposium on Symbolic and algebraic computation (1990)

A polynomial &fnof; &egr; Fq[&khgr;], over a finite field Fq with q elements, is p-large if its image in Fq contains at least q - p elements. This Extended Abstract presents an efficient probabilistic test for this property, using expected time polynomial in deg &fnof;s, log q, and p.
Real-Time Specification Using Lucid
Authors: D. B. Skillicorn, J. I. Glasgow
Venue: IEEE Transactions on Software Engineering (1989)

A methodology is presented for transforming a functional specification written in Lucid to an equivalent specification that captures its real-time properties. The enhanced specification consists of a set of equations that can be solved for several properties, including execution time and external requirements, or may simply be checked for the existence of a solution. Lucid has a set of meaning-preserving transformations, and a proof system corresponding to a behavioral semantics has been constructed. Both of these tools can be used to reason about properties of the specification. The specification is executable and can be used as a prototype for the system being specified. It is possible to express architectural constraints within the same formal framework. Thus this type of specification can be used to guide the development of new real-time systems.
Increasing the efficiency of Prolog Lexical databases with N-gram Boolean cubes
Authors: Richard Rankin
Venue: Proceedings of the 1988 ACM SIGSMALL/PC symposium on ACTES (1988)

PROLOG has been shown to be an effective tool for expressing the logic of many problems dealing with parsing, natural language processing, and spelling verification [1,7,8,9,12]. As a class, these problems deal with the manipulation of lexical databases as Horn clauses. Since PROLOG does not generally differentiate between program clauses and data clauses, the internal representation and manipulation of data may not be optimal for a particular application. This paper discusses an alternative method of representing and manipulating lexical databases through the use of N-gram analysis, prefiltering, and integration with another high level language.
Version management in Gypsy
Authors: Ellis S. Cohen, Dilip A. Soni, Raimund Gluecker, William M. Hasling, Robert W. Schwanke, Michael E. Wagner
Venue: Proceedings of the third ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments (1989)

This paper describes the Version Manager of the Gypsy programming support environment, and its integration with the object-oriented extension of Unix1 on which it is built.
Applications of random sampling in computational geometry, II
Authors: K. L. Clarkson
Venue: Proceedings of the fourth annual symposium on Computational geometry (1988)

Random sampling is used for several new geometric algorithms. The algorithms are &ldquo;Las Vegas,&rdquo; and their expected bounds are with respect to the random behavior of the algorithms. One algorithm reports all the intersecting pairs of a set of line segments in the plane, and requires &Ogr;(A + n log n) expected time, where A is the size of the answer, the number of intersecting pairs reported. The algorithm requires &Ogr;(n) space in the worst case. Another algorithm computes the convex hull of a point set in E3 in &Ogr;(n log A) expected time, where n is the number of points and A is the number of points on the surface of the hull. A simple Las Vegas algorithm triangulates simple polygons in &Ogr;(n log log n) expected time. Algorithms for half-space range reporting are also given. In addition, this paper gives asymptotically tight bounds for a combinatorial quantity of interest in discrete and computational geometry, related to halfspace partitions of point sets.
Software Complexity and its Impact on Software Reliability
Authors: K. S. Lew, T. S. Dillon, K. E. Forward
Venue: IEEE Transactions on Software Engineering (1988)

To produce reliable software, its complexity must be controlled by suitably decomposing the software system into smaller subsystems. A software complexity metric is developed that includes both the internal and external complexity of a module. This allows analysis of a software system during its development and provides a guide to system decomposition. The basis of this complexity metric is in the development of an external complexity measure that characterizes module interaction.
Range Image Segmentation Based on Differential Geometry: A Hybrid Approach
Authors: Naokazu Yokoya Martin D. Levine
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

The authors describe a hybrid approach to the problem of image segmentation in range data analysis, where hybrid refers to a combination of both region- and edge-based considerations. The range image of 3-D objects is divided into surface primitives which are homogeneous in their intrinsic differential geometric properties and do not contain discontinuities in either depth of surface orientation. The method is based on the computation of partial derivatives, obtained by a selective local biquadratic surface fit. Then, by computing the Gaussian and mean curvatures, an initial region-gased segmentation is obtained in the form of a curvature sign map. Two additional initial edge-based segmentations are also computed from the partial derivatives and depth values, namely, jump and roof-edge maps. The three image maps are then combined to produce the final segmentation. Experimental results obtained for both synthetic and real range data of polyhedral and curved objects are given.
Acquisition of macro-operators from worked examples in problem solving
Authors: S. Yamada, S. Tsuji
Venue: Issue 108 (April 1989) (1989)

In general, as building a problem solver, the expert in the problem-solving, not the knowledge-base, can easily give the system the basic-operators that transform the problem state formally. However, the condition-parts of these basic-operators that transform the problem state formally. However, the condition-parts of these basic-operators are usually too general. For example, considering a basic-operator: LHS = RHS --> LHS + A = RHS + B in the solving of equations, this operator is applicable to any equation and A, B are arbitrary formulas. Therefore, without any strategy knowledge that can control the applications of basic-operators, the search space explosively gets large and the problem solver can not solve the problem by itself. The strategy knowledge typically contains problem states in which each basic-operator should be applied. Unfortunately, this strategy knowledge is difficult for the expert to give to the problem solver. In general, an expert can solve the problem given to the problem solver, thus another input that an expert can easily give to a problem solver is a worked example which is the history of the expert's problem solving. Thus, if a learning system which can acquire the strategy knowledge from worked examples and basic-operators is added to the problem solver, the expert will be able to easily build the knowledge base for the problem solver. This method of knowledge acquisition that the learning system obtains, the expertise from expert's behavior is called Learning Apprentice [1] and some applications were reported [1,2].
Algorithms 683: a portable FORTRAN subroutine for exponential integrals of a complex argument
Authors: Donald E. Amos
Venue: ACM Transactions on Mathematical Software (TOMS) (1990)

The algorithm computes exponential integrals En(z) for integer orders n &ge; 1 and complex z in -&pgr; < arg z &le; &pgr;. Both single and double precision subroutines are provided. Exponential scaling and stable sequence generation are auxiliary options.
High-Performance Fault-Tolerant VLSI Systems Using Micro Rollback
Authors: Y. Tamir, M. Tremblay
Venue: IEEE Transactions on Computers (1990)

A technique called micro rollback, which allows most of the performance penalty for concurrent error detection to be eliminated, is presented. Detection is performed in parallel with the transmission of information between modules, thus removing the delay for detection from the critical path. Erroneous information may thus reach its destination module several clock cycles before an error indication. Operations performed on this erroneous information are undone using a hardware mechanism for fast rollback of a few cycles. The implementation of a VLSI processor capable of micro rollback is discussed, as well as several critical issues related to its use in a complete system.
ERNEST: A Semantic Network System for Pattern Understanding
Authors: H. Niemann, G. F. Sagerer, S. Schröder, F. Kummert
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1990)

The authors give a detailed account of a system environment for treating general problems of image and speech understanding. A framework for representing declarative and procedural knowledge based on a suitable definition of a semantic network is provided. The syntax and semantics of the network are clearly defined. The pragmatics of the network in its use for pattern understanding are defined by several rules which are problem-independent. This allows one to formulate problem-independent control algorithms. Complete software environments are available to handle the described structures. The general applicability of the network system is demonstrated by short descriptions of three applications from different task domains.
Tolerance of Double-Loop Computer Networks to Multinode Failures
Authors: H. Masuyama, T. Ichimori
Venue: IEEE Transactions on Computers (1989)

The reliability of double-loop networks is examined along with their fault tolerance in cases when more than two nodes break down. It is demonstrated that double-loop structured networks are very desirable with respect to the measure of fault tolerance introduced.
Experiences creating a portable cedar
Authors: R. Atkinson, A. Demers, C. Hauser, C. Jacobi, P. Kessler, M. Weiser
Venue: Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation (1989)

Cedar is the name for both a language and an environment in use in the Computer Science Laboratory at Xerox PARC since 1980. The Cedar language is a superset of Mesa, the major additions being garbage collection and runtime types. Neither the language nor the environment was originally intended to be portable, and for many years ran only on D-machines at PARC and a few other locations in Xerox. We recently re-implemented the language to make it portable across many different architectures. Our strategy was, first, to use machine-dependent C code as an intermediate language, second, to create a language-independent layer known as the Portable Common Runtime, and third, to write a relatively large amount of Cedar-specific runtime code in a subset of Cedar itself. By treating C as an intermediate code we are able to achieve reasonably fast compilation, very good eventual machine code, and all with relatively small programmer effort. Because Cedar is a much richer language than C, there were numerous issues to resolve in performing an efficient translation and in providing reasonable debugging. These strategies will be of use to many other porters of high-level languages who may wish to use C as an assembler language without giving up either ease of debugging or high performance. We present a brief description of the Cedar language, our portability strategy for the compiler and runtime, our manner of making connections to other languages and the Unix* operating system, and some measures of the performance of our &ldquo;Portable Cedar&rdquo;.
Comparison of assembly language and Ada for a real-time embedded ECM system
Authors: N. Salant
Venue: Proceedings of the conference on Tri-Ada '89: Ada technology in context: application, development, and deployment (1989)

ITT Avionics has conducted a performance comparison between an existing ECM system for tactical fighter aircraft and a theoretical Ada implementation of this system targeted to a MIL-STD-1750A processor. The ECM system component selected for the study is based on an ATAC-16M 16 bit microprocessor and is hand coded in assembly language. The intent of the performance study was to determine the feasibility of meeting the real time requirements of such an ECM system based on current Ada and 1750A technology. The Ada code selected for the comparison contained no tasking, generics or user defined exception handlers, and was compiled with all checks suppressed. The results showed that the Ada software generated 2.06 as many machine instructions as the assembly language version. After compensation for differences in processor speeds, the Ada system showed an execution time ratio of 2.4 to 1 with the Assembly language system to process functionally equivalent code on equivalent processors. Despite this performance penalty, the fastest 1750A processors that were evaluated in the study show a theoretical Ada/l750 system execution time improvement of 43% over the current assembly language ECM system.
Polynomial-time implication problems for unary inclusion dependencies
Authors: Stavros S. Cosmadakis, Paris C. Kanellakis, Moshe Y. Vardi
Venue: Journal of the ACM (JACM) (1990)

Unary inclusion dependencies are database constraints expressing subset relationships. The decidability of implication for these dependencies together with embedded implicational dependencies, such as functional dependencies, are investigated. As shown by Casanova et al., the unrestricted and finite implication problems are different for the class of functional and unary inclusion dependencies; also, for this class and for any fixed k, finite implication has no k-ary complete axiomatization. For both of these problems, complete axiomatizations and polynomial-time decision procedures are provided: linear time for unrestricted implication and cubic time for finite implication. It follows that functional and unary inclusion dependencies form a semantically natural class of first-order sentences with equality, which although not finitely controllable, is efficiently solvable and docile. Generalizing from these results, it is shown that the interaction between functional and inclusion dependencies characterizes: (1) unrestricted implication of unary inclusion and all embedded implicational dependencies; (2) finite implication of unary inclusion and all full implicational dependencies; (3) finite implication of unary inclusion and all embedded tuple-generating dependencies. As a direct consequence of this analysis, most of the applications of dependency implication are extended, within polynomial-time, to database design problems involving unary inclusion dependencies. Such examples are tests for lossless joins and tests for complementarity of projective views. Finally, if one additionally requires that
Application of NEWEUL in robot dynamics
Authors: Wolfgang Hirschberg, Dieter Schramm
Venue: Journal of Symbolic Computation (1989)

We consider the simulation of the dynamics of a complex robot system modeled as multibody system with rigid links and flexible drives. The symbolic equations, linearized with respect to a nominal motion, are generated by the program system NEWEUL. From these equations the dynamic behaviour of the system can be determined, using numeric standard procedures. The features of the program system as well as some problems occuring with the use of a symbolic formalism for the determination of equations of motion are discussed. The application of NEWEUL during the simulation of a robot system with complex dynamics leads to efficient program codes in the simulation program and guarantees high accuracy and stability during the numeric evaluation.
Performance of a dual-bus unidirectional broadcast network operating under probabilistic scheduling strategy
Authors: B. Mukherjee
Venue: ACM SIGMETRICS Performance Evaluation Review (1989)

Recent advances in fiber optic technology (viz. its promise to provide information-carrying capacity in the Gpbs range over long repeater-free distances) has triggered tremendous activity in the study of unidirectional bus networks (because signal flow in the fiber is unidirectional). A popular network structure that has received significant attention is the Dual-bus Unidirectional Broadcast System (DUBS) network topology. Most of the access mechanism studied on this structure are based on round-robin scheduling (or some variation thereof). However since round-robin schemes suffer a loss of channel capacity because of their inter-round overhead (which can be significant for long high-speed buses), a probabilistic scheduling strategy, called pi-persistent protocol, has recently been proposed and studied for single channel unidirectional bus systems. Our concern here is to apply this probabilistic scheduling strategy to each bus in DUBS, and study the corresponding network performance. In so doing, we allow stations to buffer multiple packets, represent a station's queue size by a Markov chain model, and employ an independence assumption. We find that the average packet delay is bounded and the maximum network throughput approaches two pkt/slot with increasing buffer size. Further, the protocol's performance is insensitive to bus characteristics, and it appears to be a particularly well suited for fiber-optic network application requiring long distances and high bandwidth. Simulation results, which verify the analytical model, are also included.
Motion and Structure From Two Perspective Views: Algorithms, Error Analysis, and Error Estimation
Authors: J. Weng, T. S. Huang, N. Ahuja
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1989)

Deals with estimating motion parameters and the structure of the scene from point (or feature) correspondences between two perspective views. An algorithm is presented that gives a closed-form solution for motion parameters and the structure of the scene. The algorithm utilizes redundancy in the data to obtain more reliable estimates in the presence of noise. An approach is introduced to estimating the errors in the motion parameters computed by the algorithm. Specifically, standard deviation of the error is estimated in terms of the variance of the errors in the image coordinates of the corresponding points. The estimated errors indicate the reliability of the solution as well as any degeneracy or near degeneracy that causes the failure of the motion estimation algorithm. The presented approach to error estimation applies to a wide variety of problems that involve least-squares optimization or pseudoinverse. Finally the relationships between errors and the parameters of motion and imaging system are analyzed. The results of the analysis show, among other things, that the errors are very sensitive to the translation direction and the range of field view. Simulations are conducted to demonstrate the performance of the algorithms and error estimation as well as the relationships between the errors and the parameters of motion and imaging systems. The algorithms are tested on images of real-world scenes with point of correspondences computed automatically.
A recursive algebra and query optimization for nested relations
Authors: Latha S. Colby
Venue: ACM SIGMOD Record (1989)

The nested relational model provides a better way to represent complex objects than the (flat) relational model, by allowing relations to have relation-valued attributes. A recursive algebra for nested relations that allows tuples at all levels of nesting in a nested relation to be accessed and modified without any special navigational operators and without having to flatten the nested relation has been developed. In this algebra, the operators of the nested relational algebra are extended with recursive definitions so that they can be applied not only to relations but also to subrelations of a relation. In this paper, we show that queries are more efficient and succinct when expressed in the recursive algebra than in languages that require restructuring in order to access subrelations of relations. We also show that most of the query optimization techniques that have been developed for the relational algebra can be easily extended for the recursive algebra and that queries are more easily optimizable when expressed in the recursive algebra than when they are expressed in languages like the non-recursive algebra.