ppxscal/embedding_network huggingface dataset:
Extending PowerEpsilon with algebraic rewriting
Authors: Li-Xin Zeng, Ming-Yuan Zhu
Venue: ACM SIGPLAN Notices (1994)

PowerEpsilon ([ZhuW9l]) is a strongly-typed polymorphic functional programming language based on Martin-L ouml;f's type theory and the Calculus of Constructions. In PowerEpsilon there are no constant time definitions of the predecessor functions which will lead to non-efficient programs. In this paper, we give a solution to this problem by introducing an algebraic rewriting mechanism into the system.
Remembering while mousing: the cognitive costs of mouse clicks
Authors: Patricia Wright, Ann Lickorish, Robert Milroy
Venue: ACM SIGCHI Bulletin (1994)

Thinking harder, attending more carefully, remembering more or for longer periods are activities that all contribute to the mental overheads that may have to be met when working with computer displays. One way of measuring these cognitive costs is by providing users with tools (e.g. memory aids) and then seeing how features of the interface influence the way people use these tools. In some respects this is like providing a hiker with a walking stick; the stick may not be used much until the going gets tough. This technique was developed in order to explore the memory load people experienced when working with a document on a computer screen. The practical issues concern saving space on the screen by removing some of the information that readers will need only intermittently but leaving the material accessible, just a mouse click away from the current screen display. The scientific issues concern the memory processes involved when people are working with indexes or menus that have to be summoned into view by clicking a button on the screen.
Stochastic query optimization in distributed databases
Authors: P. E. Drenick, E. J. Smith
Venue: ACM Transactions on Database Systems (TODS) (1993)

Many algorithms have been devised for minimizing the costs associated with obtaining the answer to a single, isolated query in a distributed database system. However, if more than one query may be processed by the system at the same time and if the arrival times of the queries are unknown, the determination of optimal query-processing strategies becomes a stochastic optimization problem. In order to cope with such problems, a theoretical state-transition model is presented that treats the system as one operating under a stochastic load. Query-processing strategies may then be distributed over the processors of a network as probability distributions, in a manner which accommodates many queries over time. It is then shown that the model leads to the determination of optimal query-processing strategies as the solution of mathematical programming problems, and analytical results for several examples are presented. Furthermore, a divide-and-conquer approach is introduced for decomposing stochastic query optimization problems into distinct subproblems for processing queries sequentially and in parallel.
Generalized algorithmic debugging and testing
Authors: Peter Fritzson, Nahid Shahmehri, Mariam Kamkar, Tibor Gyimothy
Venue: ACM Letters on Programming Languages and Systems (LOPLAS) (1992)

This paper presents a method for semi-automatic bug localization, generalized algorithmic debugging, which has been integrated with the category partition method for functional testing. In this way the efficiency of the algorithmic debugging method for bug localization can be improved by using test specifications and test results. The long-range goal of this work is a semi-automatic debugging and testing system which can be used during large-scale program development of nontrivial programs. The method is generally applicable to procedural langua ges and is not dependent on any ad hoc assumptions regarding the subject program. The original form of algorithmic debugging, introduced by Shapiro, was however limited to small Prolog programs without side-effects, but has later been generalized to concurrent logic programming languages. Another drawback of the original method is the large number of interactions with the user during bug localization. To our knowledge, this is the first method which uses category partition testing to improve the bug localization properties of algorithmic debugging. The method can avoid irrelevant questions to the programmer by categorizing input parameters and then match these against test cases in the test database. Additionally, we use program slicing, a data flow analysis technique, to dynamically compute which parts of the program are relevant for the search, thus further improving bug localization. We believe that this is the first generalization of algorithmic debugging for programs with side-effects written in imperative languages such as Pascal. These improvements together makes it more feasible to debug larger programs. However, additional improvements are needed to make it handle pointer-related side-effects and concurrent Pascal programs. A prototype generalized algorithmic debugger for a Pascal subset without pointer side-effects and a test case generator for application programs in Pascal, C, dBase, and LOTUS have been implemented.
Static dependent costs for estimating execution time
Authors: Brian Reistad, David K. Gifford
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

We present the first system for estimating and using data-dependent expression execution times in a language with first-class procedures and imperative constructs. The presence of first-class procedures and imperative constructs makes cost estimation a global problem that can benefit from type information. We estimate expression costs with the aid of an algebraic type reconstruction system that assigns every procedure a type that includes a static dependent cost. A static dependent cost describes the execution time of a procedure in terms of its inputs. In particular, a procedure's static dependent cost can depend on the size of input data structures and the cost of input first-class procedures. Our cost system produces symbolic cost expressions that contain free variables describing the size and cost of the procedure's inputs. At run-time, a cost estimate is dynamically computed from the statically determined cost expression and run-time cost and size information. We present experimental results that validate our cost system on three compilers and architectures. We experimentally demonstrate the utility of cost estimates in making dynamic parallelization decisions. In our experience, dynamic parallelization meets or exceeds the parallel performance of any fixed number of processors.
Cluster Analysis by Binary Morphology
Authors: J.-G. Postaire, R. D. Zhang, C. Lecocq-Botte
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1993)

An approach to unsupervised pattern classification that is based on the use of mathematical morphology operations is developed. The way a set of multidimensional observations can be represented as a mathematical discrete binary set is shown. Clusters are then detected as well separated subsets by means of binary morphological transformations.
Analysis of the impact of memory in distributed parallel processing systems
Authors: Vinod G. J. Peris, Mark S. Squillante, Vijay K. Naik
Venue: Proceedings of the 1994 ACM SIGMETRICS conference on Measurement and modeling of computer systems (1994)

We consider an important tradeoff between processor and memory allocation in distributed parallel processing systems. To study this tradeoff, we formulate stochastic models of parallel program behavior, distributed parallel processing environments and memory overheads incurred by parallel programs as a function of their processor allocation. A mathematical analysis of the models is developed, which includes the effects of contention for shared resources caused by paging activity. We conduct a detailed analysis of real large-scale scientific applications and use these results to parameterize our models. Our results show that memory overhead resulting from processor allocation decisions can have a significant effect on system performance in distributed parallel environments, strongly suggesting that memory considerations must be incorporated in the resource allocation policies for parallel systems. We also demonstrate the importance of the inter-locality miss ratio, which is introduced in this paper and analyzed for the first time.
A particular solution to provide secure communications in an Ethernet environment
Authors: Miguel Soriano, Jordi Forné, Francisco Recacha, José L. Melús
Venue: Proceedings of the 1st ACM conference on Computer and communications security (1993)

In this paper we describe the adopted and implemented solution to provide secure communications over the extended area Ethernet network of the Polytechnic University of Catalonia (U.P.C.). The developed solution is not adapted to the current standards about security on local networks (IEEE-802.10, ISO 7498-2, etc.). This solution is based on the construction of a set of ciphering devices (CRYPTONETS), whose function is similar to the one carried out by a classic bridge, but incorporating ciphering facilities. Moreover, there is a Supervision and Administration Center (SAC), which takes care of the key renewal and System Management. The cryptographic algorithms used are the D.E.S. for the Ethernet frames ciphering, and the R.S.A., for key-management.Finally, we evaluate the degradation of the network performances due to the introduction of security services within an already working network. The prototype shown here is a second version of the one described in [16]. Although the measures carried out are only partial, it can be asserted that they substantially improve the performances obtained with the first prototype, reaching the desired values.
Simulating reactive systems by deduction
Authors: Yishai A. Feldman
Venue: ACM Transactions on Software Engineering and Methodology (TOSEM) (1993)

Debugging is one of the main uses of simulation. Localizing bugs or finding the reasons for unclear behavior involves going backwards in time, whereas simulation goes forward in time. Therefore, identifying causes with the aid of most existing simulation tools usually requires repeating the simulation several times, each time with reduced holes in the sieve. An alternative is simulation by deduction, a technique in which the steps in the dynamic behavior of the simulated model are deduced by a reasoning system. A simulation system that uses simulation by deduction can give direct answers to questions about the reasons for the simulation results. By recording the support for its deductions, such a system can answer &ldquo;why&rdquo; and &ldquo;why not&rdquo; questions about the scenario. Another benefit of simulation by deduction is that it enables symbolic simulation, that is, simulating a scenario given only a partial description of the environment and the simulated model. This allows verifying properties of an evolving design at any stage of the design process, and thus checking the consequences of the design decisions made so far. In order to allow deducing as much as possible from partial information, the axiom system has to be minimalistic, i.e., axioms have to require the minimum amount of knowledge of simulation inputs. These ideas were implemented in a system called SIP, which simulates the behavior of reactive systems. SIP is capable of answering &ldquo;why,&rdquo; &ldquo;why not,&rdquo; and &ldquo;what if&rdquo; questions. It also has a limited capability of dealing with partial knowledge. SIP is based on a reasoning system that is responsible for deducing the effects of the external inputs on the state of the simulated model, and recording the support for its deductions. The logical basis for the deduction of a step in SIP is provided by a minimalistic axiom system for statecharts. Although SIP simulates reactive systems described as statecharts, the principle of simulation by deduction is applicable to other types of systems and descriptions, provided only that they have a well-defined formal semantics.
Decision trees for geometric models
Authors: Esther M. Arkin, Henk Meijer, Joseph S. B. Mitchell, David Rappaport, Steven S. Skiena
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

A fundamental problem in model-based computer vision is that of identifying which of a given set of geometric models is present in an image. Considering a &ldquo;probe&rdquo; to be an oracle that tells us whether or not a model is present at a given point, we study the problem of computing efficient strategies (&ldquo;decision trees&rdquo;) for probing an image, with the goal to minimize the number of probes necessary (in the worst case) to determine which single model is present. We show that a lgk height binary decision tree always exists for k polygonal models (in fixed position), provided (1) they are non-degenerate (do not share boundaries) and (2) they share a common point of intersection. Further, we give an efficient algorithm for constructing such decision trees when the models are given as a set of polygons in the plane. We show that constructing a minimum height tree is NP-complete if either of the two assumptions is omitted. We provide an efficient greedy heuristic strategy and show that, in the general case, it yields a decision tree whose height is at most lgn times that of an optimal tree. Finally, we discuss some restricted cases whose special structure allows for improved results.
Query evaluation techniques for large databases
Authors: Goetz Graefe
Venue: ACM Computing Surveys (CSUR) (1993)

Database management systems will continue to manage large data volumes. Thus, efficient algorithms for accessing and manipulating large sets and sequences will be required to provide acceptable performance. The advent of object-oriented and extensible database systems will not solve this problem. On the contrary, modern data models exacerbate the problem: In order to manipulate large sets of complex objects as efficiently as today's database systems manipulate simple records, query-processing algorithms and software will become more complex, and a solid understanding of algorithm and architectural issues is essential for the designer of database management software. This survey provides a foundation for the design and implementation of query execution facilities in new database management systems. It describes a wide array of practical query evaluation techniques for both relational and postrelational database systems, including iterative execution of complex query evaluation plans, the duality of sort- and hash-based set-matching algorithms, types of parallel query execution and their implementation, and special operators for emerging database application domains.
Loading data into description reasoners
Authors: Alex Borgida, Ronald J. Brachman
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Knowledge-base management systems (KBMS) based on description logics are being used in a variety of situations where access is needed to large amounts of data stored in existing relational databases. We present the architecture and algorithms of a system that converts most of the inferences made by the KBMS into a collection of SQL queries, thereby relying on the optimization facilities of existing DBMS to gain efficiency, while maintaining an object-centered view of the world with a substantive semantics and significantly different reasoning facilities than those provided by Relational DBMS and their deductive extensions. We address a number of optimization issues that arise in the translation process due to the fact that SQL queries with different syntax (but identical semantics) are not treated uniformly by current database management systems.
The generalized Schur decomposition of an arbitrary pencil A&ndash;&lgr;B&mdash;robust software with error bounds and applications. Part II: software and applications
Authors: James Demmel, Bo Kågström
Venue: ACM Transactions on Mathematical Software (TOMS) (1993)

Robust software with error bounds for computing the generalized Schur decomposition of an arbitrary matrix pencil A &ndash; &lgr;B (regular or singular) is presented. The decomposition is a generalization of the Schur canonical form of A &ndash; &lgr;I to matrix pencils and reveals the Kronecker structure of a singular pencil. The second part of this two-part paper describes the computed generalized Schur decomposition in more detail and the software, and presents applications and an example of its use. Background theory and algorithms for the decomposition and its error bounds are presented in Part I of this paper.
Parallel proximity detection and the distribution list algorithm
Authors: Jeff S. Steinman, Frederick Wieland
Venue: ACM SIGSIM Simulation Digest (1994)

Generalized proximity detection for moving objects in a logically correct parallel discrete-event simulation is an interesting and fundamentally challenging problem. Determining who can see whom in a manner that is fully scalable in terms of CPU usage, number of messages, and memory requirements is highly non-trivial. A new scalable approach has been developed to solve this problem. This algorithm, called The Distribution List, has been designed and tested using the object-oriented Synchronous Parallel Environment for Emulation and Discrete-Event Simulation (SPEEDES) operating system. Preliminary results show that the Distribution List algorithm achieves excellent parallel performance.
Combining Microcontroller Units and PLDs for Best System Design
Authors: Alan E. Clapp, Thomas L. Harman
Venue: IEEE Micro (1994)

Microcontroller timer units and programmable logic devices both can create complex system timing functions. Using the Motorola time processor unit available on the MC68332 and MC68HC1GY1 microcontrollers and PLDs from Altera, we compared the performance and flexibility of these devices in applications that require various timing functions. These investigations show that in certain systems the combination of a microcontroller timer and a PLD provides the most efficient design.
A baby babble-blanket
Authors: Linda J. Ferrier, Harriet J. Fell, Charles Silverman, David Horowitz, George Silvestri, Michael Harm
Venue: ACM SIGCHI Bulletin (1993)

We have developed a multiple-switch-activated device with speech output for use by infants with severe speech and physical impairments. It is hoped that using this device for early intervention will provide these infants with a means of environmental control and communication with parents.
The making of the SIGCHI identity design
Authors: Suzanne Watzman
Venue: ACM SIGCHI Bulletin (1993)

As of this writing (December 1992), SIGCHI is in the midst of developing an organizational identity program. As chair of the committee responsible for this identity program, I'd like to tell you about our plans and what we've done so far.
Distributed timestamp generation in planar lattice networks
Authors: Paul Ammann, Sushil Jajodia
Venue: ACM Transactions on Computer Systems (TOCS) (1993)

Timestamps are considered for distributed environments in which information flow is restricted to one direction through a planar lattice imposed on a network. For applications in such networks, existing timestamping algorithms require extension and modification. For example, in secure environments, typical timestamps provide a potential signaling channel between incomparable levels. In hierarchical databases, typical timestamps cause peripheral sites to unnecessarily affect the behavior at main sites. Algorithms are presented by which a network node may generate and compare timestamps using timestamp components maintained at dominated nodes in the network. The comparison relation is shown to be acyclic for timestamps produced by the generation algorithm. We discuss ways to safely relax the requirement that the network be a lattice. By example, we show how to modify a simple nonplanar lattice so that the generation algorithm can be applied. Uses of the timestamp generation algorithm in the motivating applications are outlined.
An NC parallel 3D convex hull algorithm
Authors: Nancy M. Amato, Franco P. Preparata
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

In this paper we present an Ologn time parallel algorithm for computing the convex hull of n points in R3 . This algorithm uses On1+a processors on a CREW PRAM, for any constant 0 < &dgr; &le; 1. So far, all adequately documented parallel algorithms proposed for this problem use time at least Olog2 n . In addition, the algorithm presented here is the first parallel algorithm for the three-dimensional convex hull problem that is not based on the serial divide-and-conquer algorithm of Preparata and Hong, whose crucial operation is the merging of the convex hulls of two linearly separated point sets. The contributions of this paper are therefore (i) an Ologn time parallel algorithm for the three-dimensional convex hull problem, and (ii) a parallel algorithm for this problem that does not follow the traditional divide-and-conquer paradigm.
Computational geometry column 18
Authors: Joseph O'Rourke
Venue: ACM SIGACT News (1993)

Results on visibility graphs are classified and organized into five tables.
Kassandra: the automatic grading system
Authors: urs von Matt
Venue: ACM SIGCUE Outlook (1994)

An automatic grading system is presented for grading assignments in scientific computing. A student can interactively use this system to check the correctness of his program assignments. The grade for a correct solution is automatically recorded. This paper also considers the security problems with such an automatic grading system.
Getting started in visual interaction design: a bibliography
Authors: Andy Cargile
Venue: ACM SIGCHI Bulletin (1993)

Visual interaction design, as Maria Wadlow described in the January issue of the SIGCHI Bulletin, involves the visual aspects of interaction in interface design (Wadlow, 1993). It is an "intersection" of the disciplines of graphic design and interface design. Though it combines elements of both, it does not encompass the entire spectrum of each of these disciplines.
DIRECT: a query facility for multiple databases
Authors: Ulla Merz, Roger King
Venue: ACM Transactions on Information Systems (TOIS) (1994)

The subject of this research project is the architecture and design of a multidatabase query facility. These databases contain structured data, typical for business applications. Problems addressed are: presenting a uniform interface for retrieving data from multiple databases, providing autonomy for the component databases, and defining an architecture for semantic services.DIRECT is a query facility for heterogeneous databases. The databases and their definitions can differ in their data models, names, types, and encoded values. Instead of creating a global schema, descriptions of different databases are allowed to coexist. A multidatabase query language provides a uniform interface for retrieving data from different databases. DIRECT has been exercised with operational databases that are part of an automated business system.
Parallel independent replicated simulation on a network of workstations
Authors: Yi-Bing Lin
Venue: ACM SIGSIM Simulation Digest (1994)

Parallel independent replicated simulation (PIRS) is an effective approach to speed up the simulation processes. In a PIRS, a single simulation run is executed by multiple computers in parallel. The statistical properties for a PIRS may be affected by the scheduling policies. For an unbiased PIRS scheduling policy, a reliable distributed computing environment is required. We consider an unbiased PIRS scheduling policy on a distributed platform such as a network of workstations. We observe that including more computing resources may degrade the performance of PIRS. Simple rules are proposed to select processors for PIRS.