ppxscal/embedding_network huggingface dataset:
Minimal Paths between Maximal Chains in Finite Rank Semimodular Lattices
Authors: David Samuel Herscovici
Venue: Journal of Algebraic Combinatorics: An International Journal (1998)

We study paths between maximal chains, or &ldquo;flags,&rdquo; in finite rank semimodular lattices. Two flags are adjacent if they differ on at most one rank. A path is a sequence of flags in which consecutive flags are adjacent. We study the union of all flags on at least one minimum length path connecting two flags in the lattice. This is a subposet of the original lattice. If the lattice is modular, the subposet is equal to the sublattice generated by the flags. It is a distributive lattice which is determined by the &ldquo;Jordan-H&ouml;lder permutation&rdquo; between the flags. The minimal paths correspond to all reduced decompositions of this permutation. In a semimodular lattice, the subposet is not uniquely determined by the Jordan-H&ouml;lder permutation for the flags. However, it is a join sublattice of the distributive lattice corresponding to this permutation. It is semimodular, unlike the lattice generated by the two flags, which may not be ranked. The minimal paths correspond to some reduced decompositions of the permutation, though not necessarily all. We classify the possible lattices which can arise in this way, and characterize all possibilities for the set of shortest paths between two flags in a semimodular lattice.
A toolkit for negotiation support interfaces to multi-dimensional data
Authors: Michael Gebhardt, Matthias Jarke, Stephan Jacobs
Venue: Proceedings of the 1997 ACM SIGMOD international conference on Management of data (1997)

CoDecide is an experimental user interface toolkit that offers an extension to spreadsheet concepts specifically geared towards support for cooperative analysis of the kinds of multi-dimensional data encountered in data warehousing. It is distinguished from previous proposals by direct support for drill-down/roll-up analysis without redesign of an interface; more importantly, CoDecide can link multiple views on a data cube for synchronous or asynchronoous cooperation by multiple analysts, through a conceptual model visualizing the problem dimensions on so-called tapes. Tapes generalize the ideas of ranging and pivoting in current data warehouses for the multi-perspective and multi-user case. CoDecide allows the rapid composition of multi-matrix interfaces and their linkage to underlying data sources. A LAN version of CoDecide has been used in a number of design decision support applications. A WWW version representing externally materialized views on databases is currently under development.
An SQL interface for VS APL
Authors: Casey Bley
Venue: ACM SIGAPL APL Quote Quad (1985)

The success of APL at Firemans Fund American Life Insurance Company (FFAL) has led to a problem which seems common to growing APL shops: data management. As the volume and complexity of data grows, a component file system soon becomes cumbersome, inefficient and application dependent. The result is a myriad of satellite systems which are unable to communicate and difficult to maintain because of unique file designs. To solve this problem, a database management system (DBMS) should be used to provide a more uniform approach to data management. SQL is a likely choice since it is a relational system which lends itself nicely to APL's array processing. FFAL is currently running SQL and APL under VM. Both VS APL and STSC's APL*PLUS are available. Unfortunately, neither environment has an interface to SQL. In order to solve this problem, an interface was developed in house. It provides APL with the advantages of a DBMS and gives programmers and applications easy access to SQL from APL. Also, the APL portion of the interface followed VS APL standards providing compatibility across APL environments.
Weighted Sensitivity Minimization for Causal, Linear, Discrete Time--Varying Systems
Authors: Michel Verhaegen
Venue: SIAM Journal on Control and Optimization (1997)

The weighted sensitivity minimization problem for discrete time--varying systems is treated in a state space framework. Given a controllable and causal (stable) state space realization of the plant to be controlled, the first step in the solution is the computation of an outer-inner factorization of the plant. The key algorithmic step here is the solution of a Lyapunov type of equation running backward in time. Based on the part of the realization of the inner (isometric) factor related to its output state space we then formulate and solve a Nevanlinna--Pick interpolation problem. This second step is also characterized by a Lyapunov equation. It is shown that the solution to the sensitivity minimization problem exists when the solution to this Lyapunov equation is positive definite for all time instances. Finally, we pay special attention to the minimal disturbance attenuation level when the latter is assumed to be equal to a constant scalar for all time instances as well as to a square root implementation of the recursive equations.
Exploiting hardware performance counters with flow and context sensitive profiling
Authors: Glenn Ammons, Thomas Ball, James R. Larus
Venue: ACM SIGPLAN Notices (1997)

A program profile attributes run-time costs to portions of a program's execution. Most profiling systems suffer from two major deficiencies: first, they only apportion simple metrics, such as execution frequency or elapsed time to static, syntactic units, such as procedures or statements; second, they aggressively reduce the volume of information collected and reported, although aggregation can hide striking differences in program behavior.This paper addresses both concerns by exploiting the hardware counters available in most modern processors and by incorporating two concepts from data flow analysis--flow and context sensitivity--to report more context for measurements. This paper extends our previous work on efficient path profiling to flow sensitive profiling, which associates hardware performance metrics with a path through a procedure. In addition, it describes a data structure, the calling context tree, that efficiently captures calling contexts for procedure-level measurements.Our measurements show that the SPEC95 benchmarks execute a small number (3--28) of hot paths that account for 9--98% of their L1 data cache misses. Moreover, these hot paths are concentrated in a few routines, which have complex dynamic behavior.
User-specified domain knowledge for document retrieval
Authors: W. B. Croft
Venue: Proceedings of the 9th annual international ACM SIGIR conference on Research and development in information retrieval (1986)

The introduction of domain knowledge into a document retrieval system has two important consequences; an increase in the effectiveness of retrieval and a decrease in the efficiency of text processing. In this paper, a method is presented of combining user-specified domain knowledge with efficient retrieval techniques based on probabilistic models. The domain knowledge is represented as a collection of frames that contain rules specifying recognition conditions for domain concepts and relationships between concepts. The inference network represented in these frames is used to infer the concepts that are related to a user's query. This approach is being implemented as part of the I3R expert intermediary system.
A new process migration algorithm
Authors: Michael Richmond, Michael Hitchens
Venue: ACM SIGOPS Operating Systems Review (1997)

Process migration has been advocated as a means of improving the load balancing and reliability of distributed systems. This paper reviews the major design issues for process migration algorithms, such as the amount of state information to be transferred and times at which information should be transferred. This examination demonstrates the existence of a process migration algorithm which has not previously been documented. After describing existing algorithms, the new algorithm is given and compared to the other algorithms. The new algorithm promises better load balancing results while avoiding residual dependencies
Enriched View Synchrony: A Programming Paradigm for Partitionable Asynchronous Distributed Systems
Authors: Özalp Babaoğlu, Alberto Bartoli, Gianluca Dini
Venue: IEEE Transactions on Computers (1997)

Distributed systems constructed using off-the-shelf communication infrastructures are becoming common vehicles for doing business in many important application domains. Large geographic extent due to increased globalization, increased probability of failures, and highly dynamic loads all contribute toward a partitionable and asynchronous characterization for these systems. In this paper, we consider the problem of developing reliable applications to be deployed in partitionable asynchronous distributed systems. What makes this task difficult is guaranteeing the consistency of shared state despite asynchrony, failures, and recoveries, including the formation and merging of partitions. While view synchrony within process groups is a powerful paradigm that can significantly simplify reasoning about asynchrony and failures, it is insufficient for coping with recoveries and merging of partitions after repairs. We first give an abstract characterization for shared state management in partitionable asynchronous distributed systems and then show how views can be enriched to convey structural and historical information relevant to the group's activity. The resulting paradigm, called enriched view synchrony, can be implemented efficiently and leads to a simple programming methodology for solving shared state management in the presence of partitions.
A parallel/serial trade-off methodology for look-up table based decoders
Authors: Claus Schneider
Venue: Proceedings of the 34th annual Design Automation Conference (1997)

A methodology for architecture exploration of look-up tablebased decoders is presented. For the degree of parallel processinga trade-off can be made by exploring system leveland register transfer level models. Executable specifications(pure functional software models, VHDL behavior models)are used to analyze the performance of different architectures.Hardware cost (area) and feasibility (timing) aredetermined by synthesis of RTL models. These models aregenerated directly out of the specification to avoid errorsdue to manual transformations and to reduce overall designtime. Generator-based reuse modeling and hardware costestimation is demonstrated using a decoder for MPEG variablelength codes (VLC).
Experiences teaching data structures with Java
Authors: Mark Allen Weiss
Venue: ACM SIGCSE Bulletin (1997)

This paper describes our experiences incorporating Java in a Data Structures course. We describe the features of Java that made for a more interesting course, the difficulties that we encountered, and compare Java to the prior languages used in this course, Ada and C++. All in all, we found Java to be a reasonable, but not overwhelming better, alternative. Our students were particularly happy with the experiment.
Efficient Distributed Detection of Conjunctions of Local Predicates
Authors: Michel Hurfin, Masaaki Mizuno, Mukesh Singhal, Michel Raynal
Venue: IEEE Transactions on Software Engineering (1998)

Global predicate detection is a fundamental problem in distributed systems and finds applications in many domains such as testing and debugging distributed programs. This paper presents an efficient distributed algorithm to detect conjunctive form global predicates in distributed systems. The algorithm detects the first consistent global state that satisfies the predicate even if the predicate is unstable. Unlike previously proposed run-time predicate detection algorithms, our algorithm does not require exchange of control messages during the normal computation. All the necessary information to detect predicates is piggybacked on computation messages of application programs. The algorithm is distributed because the predicate detection efforts as well as the necessary information are equally distributed among the processes. We prove the correctness of the algorithm and compare its performance with respect to message, storage, and computational complexities with that of the previously proposed run-time predicate detection algorithms.
Getting started with computer ethics
Authors: Laurie H. Werth
Venue: ACM SIGCSE Bulletin (1997)

Computer professionals face dilemmas which demand both technical knowledge and an understanding of ethical principles and skills, but how to best teach these principles and necessary skills to students? ACM's Curriculum '91 and the problems inherent in the growth of information technology call for educators to integrate computer ethics material into the computer science curriculum. Unfortunately, most faculty have neither background information nor experience teaching ethics and professionalism topics.This paper discusses basic instructional issues and provides elementary approaches for inexperienced faculty. Several simple techniques to identify and analyze ethical issues are presented. Next we look at two intermediate techniques suitable for computer science students which have been particularly successful in my classes. Finally, Project ImpactCS' model for teaching computer ethics, a valuable framework for the study of ethics and social principles and skills is summarized. This model leverages ethics experts experience to jump-start computer science faculty.
Voting over Multiple Condensed Nearest Neighbors
Authors: Ethem Alpaydin
Venue: Artificial Intelligence Review (1997)

Lazy learning methods like the k-nearest neighbor classifier require storing the whole training set and may be too costly when this set is large. The condensed nearest neighbor classifier incrementally stores a subset of the sample, thus decreasing storage and computation requirements. We propose to train multiple such subsets and take a vote over them, thus combining predictions from a set of concept descriptions. We investigate two voting schemes: simple voting where voters have equal weight and weighted voting where weights depend on classifiers&lsquo; confidences in their predictions. We consider ways to form such subsets for improved performance: When the training set is small, voting improves performance considerably. If the training set is not small, then voters converge to similar solutions and we do not gain anything by voting. To alleviate this, when the training set is of intermediate size, we use bootstrapping to generate smaller training sets over which we train the voters. When the training set is large, we partition it into smaller, mutually exclusive subsets and then train the voters. Simulation results on six datasets are reported with good results. We give a review of methods for combining multiple learners. The idea of taking a vote over multiple learners can be applied with any type of learning scheme.
Synchronization in Time-delayed Binary Oscillatory Network
Authors: Ziyi Lu, Luxi Yang, Zhenya He
Venue: Neural Processing Letters (1997)

We introduce a network of binary oscillators coupled with time delays. Based on the investigation of the dynamics of single time-delayed binary oscillator, the behaviour of a pair of oscillators with excitatory coupling is analyzed in detail. It is shown that perfect synchronous solutions exist for a wide range of initial conditions in the presented oscillatory network.
The measured cost of copying garbage collection mechanisms
Authors: Michael W. Hicks, Jonathan T. Moore, Scott M. Nettles
Venue: ACM SIGPLAN Notices (1997)

We examine the costs and benefits of a variety of copying garbage collection (GC) mechanisms across multiple architectures and programming languages. Our study covers both low-level object representation and copying issues as well as the mechanisms needed to support more advanced techniques such as generational collection, large object spaces, and type segregated areas.Our experiments are made possible by a novel performance analysis tool, Oscar. Oscar allows us to capture snapshots of programming language heaps that may then be used to replay garbage collections. The replay program is self-contained and written in C, which makes it easy to port to other architectures and to analyze with standard performance analysis tools. Furthermore, it is possible to study additional programming languages simply by instrumenting existing implementations to capture heap snapshots.In general, we found that careful implementation of GC mechanisms can have a significant benefit. For a simple collector, we measured improvements of as much as 95%. We then found that while the addition of advanced features can have a sizeable overhead (up to 15%), the net benefit is quite positive, resulting in additional gains of up to 42%. We also found that results varied depending upon the platform and language. Machine characteristics such as cache arrangements, instruction set (RISC/CISC), and register pool were important. For different languages, average object size seemed to be most important.The results of our experiments demonstrate the usefulness of a tool like Oscar for studying GC performance. Without much overhead, we can easily identify areas where programming language implementors could collaborate with GC implementors to improve GC performance.
Disk load balancing for video-on-demand systems
Authors: Joel L. Wolf, Philip S. Yu, Hadas Shachnai
Venue: Multimedia Systems (1997)

For a video-on-demand computer system, we propose a scheme which balances the load on the disks, therebyhelping to solve a performance problem crucial to achievingmaximal video throughput. Our load-balancing scheme consists of two components. The static component determinesgood assignments of videos to groups of striped disks. Thedynamic component uses these assignments, and features a"DASD dancing" algorithm which performs real-time diskscheduling in an effective manner. Our scheme works synergistically with disk striping. We examine the performanceof the proposed algorithm via simulation experiments.
Integrating the practical use of a database product into a theoretical curriculum
Authors: Susan D. Urban, Suzanne W. Dietrich
Venue: Proceedings of the twenty-eighth SIGCSE technical symposium on Computer science education (1997)

Integrating the practical use of a database product into the theoretical curriculum of a database management course is a challenge. The approach described minimizes the amount of class time that is allocated to teaching students the use of a database product, while providing guidance to the students in the use of the tool. Introduction of the database product is accomplished through cooperative learning, where students help each other learn the intricacies of the system. To facilitate this process, the students are provided with a complete database implementation example. Using this example, students gradually advance from a tutorial exercise, to a step-by-step extension of the example, and finally to more difficult extensions. These self-paced assignments provide a solid foundation for the students' knowledge in the implementation of their own cooperative group project.
Power management techniques for control-flow intensive designs
Authors: Anand Raghunathan, Sujit Dey, Niraj K. Jha, Kazutoshi Wakabayashi
Venue: Proceedings of the 34th annual Design Automation Conference (1997)

This paper presents a low-overhead controller-based powermanagement technique that re-specifies control signals to reconfigureexisting multiplexer networks and functional units to minimizeunnecessary activity. We demonstrate that conventional powermanagement techniques may often not be suited to control-flowintensive designs, and provide a comprehensive analysis of thepotential negative effects of power management on circuit delay,glitching activity at control and data path signals, and formationof false combinational cycles. We present techniques to performpower management through controller re-specification while avoidingthe above negative effects, and demonstrate the efficiency ofthe techniques through experiments.
Laser correcting defects to create transparent routing for large area FPGA's
Authors: G. H. Chapman, Benoit Dufort
Venue: Proceedings of the 1997 ACM fifth international symposium on Field-programmable gate arrays (1997)

Creating large area FPGA's is limited by the presence of defective sections. The techniques developed in wafer scale work solve this problem by using defect avoidance routing around flawed blocks to build complete working systems. FPGA's have the main features required for successful defect avoidance systems: a repeatable cell, built in need for switchable flexible routing and high flexibility with potentially large number of applications. Laser formed connections and cuts have proved to be effective in bypassing fabrication time defects and creating defect free working systems up to wafer scale in area. Power shorts and clock distribution errors can effectively be eliminated using these laser links. In addition it is important to minimize signal delays so the bypassing of the defective cells is nearly invisible. Experiments on a small test FPGA shows defect avoidance routing using laser link structures generates delays which are about half those obtained by the active switches required for the FPGA's operation. Thus laser defect avoidance after fabrication removes the errors creating a large area FPGA whose defective cell distribution is nearly unseen by the user.
Ada and Java on the WWW
Authors: Robert G. Munck, Richard F. Hilliard,  II
Venue: ACM SIGAda Ada Letters (1997)

The Java language for World-Wide Web (WWW, "Web") programming, a "cleaned-up" variant of C++, is currently receiving great amounts of publicity. It compiles to an executable byte-code that is run interpretively, making it object-code portable to any platform having an interpreter. The primary use is to download logic embedded in Web pages, allowing them to have animated images, automatic playing of digitized audio and video, syntactic checking of forms entries, interactive games, and other actions.Intermetrics is in the final testing phase for an Ada 95 compiler called AppletMagic trade; that targets the same executable byte-codes and run-time environment as Java. Given the superior features and greater maturity of Ada and the compiler-writing expertise of Intermetrics, this represents an extraordinary opportunity to expand the use of Ada to a much wider programming community. This paper summarizes the underlying technology, reviews the history and characteristics of Java, compares Java, C++, and Ada, and finally discusses efforts to promote the use of Ada for Web programming.
Set-Valued Means of Random Particles
Authors: Dietrich Stoyan, Ilya S. Molchanov
Venue: Journal of Mathematical Imaging and Vision (1997)

Planar images of powder particles or sand grains can be interpreted as &ldquo;figures&rdquo;, i.e., equivalence classes of directly congruent compact sets. The paper introduces a concept of set-valued means and real-valued variances for samples of such figures. In obtaining these results, the images are registered to have similar locations and orientations. The method is applied to find a mean figure of a sample of polygonal particles.