ppxscal/embedding_network huggingface dataset:
To take arms against a sea of email
Authors: Andrew Arensburger, Azriel Rosenfeld
Venue: Communications of the ACM (1995)

The rapid growth of the Internet means there is more email traffic now than ever before, and there will be still more in years to come. There was a time when only hard-core hackers had to deal with significant amounts of email. As email becomes a standard medium of communication, and more and more nonprogrammers join mailing lists, an increasing number of people find themselves receiving large amounts of email and must cope with it.
Complexity Analysis for Partitioning Nearest Neighbor Searching Algorithms
Authors: Pierre Zakarauskas, John M. Ozard
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1996)

In this paper we present cost estimates for finding the k-nearest neighbors to a test pattern according to a Minkowski p-metric, as a function of the size of the buckets in partitioning searching algorithms. The asymptotic expected number of operations to find the nearest neighbor is presented as a function of the average number of patterns per bucket n and is shown to contain a global minimum.
Empirical risk minimization versus maximum-likelihood estimation: a case study
Authors: Ronny Meir
Venue: Neural Computation (1995)

We study the interaction between input distributions, learning algorithms, and finite sample sizes in the case of learning classification tasks. Focusing on the case of normal input distributions, we use statistical mechanics techniques to calculate the empirical and expected (or generalization) errors for several well-known algorithms learning the weights of a single-layer perceptron. In the case of spherically symmetric distributions within each class we find that the simple Hebb rule, corresponding to maximum-likelihood parameter estimation, outperforms the other more complex algorithms, based on error minimization. Moreover, we show that in the regime where the overlap between the classes is large, algorithms with low empirical error do worse in terms of generalization, a phenomenon known as overtraining.
On the optimality of change propagation for incremental evaluation of hierarchical attribute grammars
Authors: Alan Carle, Lori Pollock
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1996)

Several new attribute grammar dialects have recently been developed, all with the common goal of allowing large, complex language translators to be specified through a modular composition of smaller attribute grammars. We refer to the class of dialects as hierarchical attribute grammars. In this short article, we present a characterization of optimal incremental evaluation that indicates the unsuitability of change propagation as the basis of an optimal incremental evaluator for hierarchical attribute grammars. This result lends strong support to the use of incremental evaluators based on more applicative approaches to attribute evaluation, such as Carle and Pollock's evaluator based on more applicative approaches to attribute evaluation, such as Carle and Pollock's evaluator based on caching of partially attributed subtree, Pugh's evaluator based on function caching of semantic functions, and Swierstra and Vogt's evaluator based on functions, and Swierstra and Vogt's evaluator based on function caching of visit sequences.
The Existence of Homomorphisms to Oriented Cycles
Authors: Pavol Hell, Xuding Zhu
Venue: SIAM Journal on Discrete Mathematics (1995)

We discuss the existence of homomorphisms of arbitrary digraphs to a fixed oriented cycle $C$. Our main result asserts that if the cycle $C$ is unbalanced then a digraph $G$ is homomorphic to $C$ if and only if (1) every oriented path homomorphic to $G$ is also homomorphic to $C$, and (2) the length of every cycle of $G$ is a multiple of the length of $C$. This answers a conjecture from an earlier paper with H. Zhou and generalizes a result proved there. We also show that this characterization does not hold for balanced cycles. We relate these results to work on the complexity of homomorphism problems.
Generating parallel code from object oriented mathematical models
Authors: Niclas Andersson, Peter Fritzson
Venue: ACM SIGPLAN Notices (1995)

For a long time efficient use of parallel computers has been hindered by dependencies introduced in software through low-level implementation practice. In this paper we present a programming environment and language called Object-Math (Object oriented Mathematical language for scientific computing), which aims at eliminating this problem by allowing the user to represent mathematical equation-based models directly in the system. The system performs analysis of mathematical models to extract parallelism and automatically generates parallel code for numerical solution.In the context of industrial applications in mechanical analysis, we have so far primarily explored generation of parallel code for solving systems of ordinary differential equations (ODEs), in addition to preliminary work on generating code for solving partial differential equations. Two approaches to extracting parallelism have been implemented and evaluated: extracting parallelism at the equation system level and at the single equation level, respectively. We found that for several applications the corresponding systems of equations do not partition well into subsystems. This means that the equation system level approach is of restricted general applicability. Thus, we focused on the equation-level approach which yielded significant parallelism for ODE systems solution. For the bearing simulation applications we present here, the achieved speedup is however critically dependent on low communication latency of the parallel computer.
Establishment of Isolated Failure Immune Real-Time Channels in HARTS
Authors: Qin Zheng, Kang G. Shin
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

Fault-tolerant, real-time communication in distributed systems is very important yet difficult to achieve. Traditional protocols like the TCP/IP achieve reliable communication through acknowledgment and retransmission schemes, where one achieves the reliability at the cost of performance. In this paper, we discuss how both the timeliness and fault-tolerance of communication can be achieved by using the concept of real-time channel [1] and exploring the inherent spatial redundancy of a given network topology. Specifically, we show how isolated failure immune real-time channels can be established in wrapped hexagonal mesh networks, thus ensuring timely delivery of messages in the presence of network component failures as long as the failures are isolated. This kind of fault-tolerance cannot be achieved with other commonly-known topologies like rings, rectangular meshes, and hypercubes. The proposed approach is to be implemented in an experimental distributed real-time system, called HARTS [2], whose construction is underway.Index Terms¿Distributed computing systems, fault-tolerant real-time communications, wrapped hexagonal mesh, isolated failure immune networks, real-time channels.
The customer service office simulation
Authors: Marda Redditt
Venue: Proceedings of the 27th conference on Winter simulation (1995)

The paper presents the analysis of our Customer Service Office (CSO) process. The CSO was undergoing many changes and needed to look at automating more of their process. Under the "as-is" process, they were not keeping up with the customers' inquiries. They were averaging about 13,500 inquiries a year and a backlog of about 75 inquiries. Though 75 inquiries does not suggest an excessive backlog, when you are a customer waiting, it is. The Corporate Modeling and Simulation (CMS) Office reviewed the "as-is" process and then performed "what-if" analysis on the proposed automated effort. Looking at the proposed automation through simulation would let the CSO determine if there were any problems that might occur and correct prior to implementation.
Data-Structural Bootstrapping, Linear Path Compression, and Catenable Heap-Ordered Double-Ended Queues
Authors: Adam L. Buchsbaum, Rajamani Sundar, Robert E. Tarjan
Venue: SIAM Journal on Computing (1995)

A deque with heap order is a linear list of elements with real-valued keys that allows insertions and deletions of elements at both ends of the list. It also allows the findmin (alternatively findmax) operation, which returns the element of least (greatest) key, but it does not allow a general deletemin (deletemax) operation. Such a data structure is also called a mindeque (maxdeque). Whereas implementing heap-ordered deques in constant time per operation is a solved problem, catenating heap-ordered deques in sublogarithmic time has until now remained open. This paper provides an efficient implementation of catenable heap-ordered deques, yielding constant amortized time per operation. The important algorithmic technique employed is an idea that we call data-structural bootstrapping: we abstract heap-ordered deques by representing them by their minimum elements, thereby reducing catenation to simple insertion. The efficiency of the resulting data structure depends upon the complexity of a special case of path compression that we prove takes linear time.
How to share concurrent wait-free variables
Authors: Ming Li, John Tromp, Paul M. B. Vitányi
Venue: Journal of the ACM (JACM) (1996)

Sharing data between multiple asynchronous users&mdash;each of which can atomically read and write the data&mdash;is a feature that may help to increase the amount of parallelism in distributed systems. An algorithm implementing this feature is presented. The main construction of an n-user atomic variable directly from single-writer, single-reader atomic variables uses O(n) control bits and O(n) accesses per Read/Write running in O(1) parallel time.
Report on the microelectronics and computer technology corporation conference
Authors: Karen A. Frenkel
Venue: Communications of the ACM (1985)

MCC, the consortium of companies headed by Admiral B. R. Inman, that some consider America's reply to Japan's Fifth Generation initiative, invited members and nonmembers to brainstorm on software design. Also on the agenda was the announcement of LEONARDO, MCC's software research project.
Automated performance prediction of message-passing parallel programs
Authors: Robert J. Block, Sekhar Sarukkai, Pankaj Mehra
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

The increasing use of massively parallel supercomputers to solve large-scale scientific problems has generated a need for tools that can predict scalability trends of applications written for these machines. Much work has been done to create simple models that represent important characteristics of parallel programs, such as latency, network contention, and communication volume. But many of these methods still require substantial manual effort to represent an application in the model's format. The MK toolkit described in this paper is the result of an on-going effort to automate the formation of analytic expressions of program execution time, with a minimum of programmer assistance. In this paper we demonstrate the feasibility of our approach, by extending previous work to detect and model communication patterns automatically, with and without overlapped computations. The predictions derived from these models agree, within reasonable limits, with execution times of programs measured on the Intel iPSC/860 and Paragon. Further, we demonstrate the use of MK in selecting optimal computational grain size and studying various scalability metrics.
Compositional parallel programming languages
Authors: Ian Foster
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1996)

In task-parallel programs, diversee activities can take place concurrently, and communication and synchronization patterns are complex and not easily predictable. Previous work has identified compositionality as an important design principle for task-parallel programs. In this article, we discuss alternative approaches to the realization of this principle, which holds that properties of program components should be preserved when those co ponents are composed in parallel with other program components. We review two programming languages, Strand and Program Composition Notation, that support compositionality via a small number of simple concepts, namely, monotone operations on shared opbects, a uniform addressing mechanism, and parallel composition. Both languages have been used extensively for large-scale application development, allowing us to provide an informed assessment of both their strengths and their weaknesses. We observe that while compositionality simplifies development of complex applications, the use of specialized languages hinders reuse of existing code and tools and the specification of domain decomposition strategies. This suggests an alternative approach based on small extensions to existing sequential languages. We conclude the article with a discussion of two languages that realized this strategy.
Dynamically-valued constants: an underused language feature
Authors: Jonathan L. Schilling
Venue: ACM SIGPLAN Notices (1995)

Languages such as Ada and C++ allow programmers to declare an object as a constant, even though the object has a dynamic initial value. The benefits of using this construct are given. A sample of actual C++ code is measured to see how often dynamically-valued constants are used, and how often they could be used. This result is compared to previously published results for Ada sample code, and to some Ada code where this feature was consciously employed. The comparisons indicate that this language feature is generally underused. Possible reasons for this underuse are discussed.
An Efficient Parallel Recognition Algorithm For Bipartite-Permutation Graphs
Authors: Chang-Wu Yu, Gen-Huey Chen
Venue: IEEE Transactions on Parallel and Distributed Systems (1996)

In this paper, we present a parallel recognition algorithm for bipartite-permutation graphs. The algorithm can be executed in O(log n) time on the CRCW PRAM if O(n3 /log n) processors are used, or O(log2n) time on the CREW PRAM if O(n3 /log2n) processors are used. Previously, Chen and Yesha have presented another CRCW PRAM algorithm that takes O(log2n) time if O(n3) processors are used. Compared with Chen and Yesha's algorithm, our algorithm requires either less time and fewer processors on the same machine model, or fewer processors on a weaker machine model. Besides, our algorithm can be applied to determine if two bipartite-permutation graphs are isomorphic.
Reuse of requirements and specifications: a formal framework
Authors: Carlos Paredes, José Luiz Fiadeiro
Venue: ACM SIGSOFT Software Engineering Notes (1995)

It is claimed that requirements engineering, as a problem of formalization and agreement, can benefit from raising the level of reusability up to functional requirements elicitation and specification levels. At these levels, it is important to support incomplete information in a declarative, reusable and refineable form. For that purpose, a model is proposed which is based on temporal theories, in the logical sense, together with a set of incremental specification techniques formalized through categorial constructions on theories.
Monotonicity Maintenance in Information-Theoretic Machine Learning Algorithms
Authors: Arie Ben-David
Venue: Machine Learning (1995)

Decision trees that are based on information-theory are useful paradigms for learning from examples. However, in some real-world applications, known information-theoretic methods frequently generate nonmonotonic decision trees, in which objects with better attribute values are sometimes classified to lower classes than objects with inferior values. This property is undesirable for problem solving in many application domains, such as credit scoring and insurance premium determination, where monotonicity of subsequent classifications is important. An attribute-selection metric is proposed here that takes both the error as well as monotonicity into account while building decision trees. The metric is empirically shown capable of significantly reducing the degree of non-monotonicity of decision trees without sacrificing their inductive accuracy.
High performance Fortran: a practical analysis
Authors: Allan Knies, Matthew O'Keefe, Tom MacDonald
Venue: Scientific Programming (1994)

The recently released high performance Fortran forum (HPFF) proposal has stirred much interest in the high performance computing industry. HPFF's most important design goal is to create a language that has source code portability and that achieves high performance on single instruction multiple data (SIMD), distributed-memory multiple instruction multiple data (MIMD), and shared-memory MIMD architectures. The HPFF proposal brings to the forefront many questions about design of portable and efficient languages for parallel machines. In this article, we discuss issues that need to be addressed before an efficient production quality compiler will be available for any such language. We examine some specific issues that are related to HPF's model of computation and analyze several implementation issues. We also provide some results from another data parallel compiler to help gain insight on some of the implementation issues that are relevant to HPF. Finally, we provide a summary of options currently available for application developers in industry.
Scaling Algorithms for the Shortest Paths Problem
Authors: Andrew V. Goldberg
Venue: SIAM Journal on Computing (1995)

We describe a new method for designing scaling algorithms for the single-source shortest paths problem and use this method to obtain an $O(\sqrt n m \log N)$ algorithm for the problem. (Here $n$ and $m$ is the number of nodes and arcs in the input network and $N$ is essentially the absolute value of the most negative arc length, and arc lengths are assumed to be integral.) This improves previous bounds for the problem. The method extends to related problems.
Local and temporal predicates in distributed systems
Authors: Bernadette Charron-Bost, Carole Delporte-Gallet, Hugues Fauconnier
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1995)

The definitions of the predicates Possibly &fgr; and Definitely &fgr;, where &fgr; is a global predicate of a distributed computation, lead to the definitions of two predicate transformers P and D. We show that P plays the same role with respect to time as the predicate transformers Ki in knowledge theory play with respect to space. Pursuing this analogy, we prove that local predicates are exactly the fixed points of the Ki's while the stable predicates are the fixed points of P. In terms of the predicate transformers P and D, we define a new class of predicates that we call observer-independent predicates and for which the detection of Possibly &fgr; and Definitely &fgr; is quite easy. Finally, we establish a temporal counterpart to the knowledge change theorem of Chandy and Misra which formally proves that the global view of a distributed system provided by its various observations does not differ too much from its truth behavior.
Networking support for large scale multiprocessor servers
Authors: David J. Yates, Erich M. Nahum, James F. Kurose, Don Towsley
Venue: Proceedings of the 1996 ACM SIGMETRICS international conference on Measurement and modeling of computer systems (1996)

Over the next several years the performance demands on globally available information servers are expected to increase dramatically. These servers must be capable of sending and receiving data over hundreds or even thousands of simultaneous connections. In this paper, we show that connection-level parallel protocols (where different connections are processed in parallel) running on a shared-memory multiprocessor can deliver high network bandwidth across a large number of connections.We experimentally evaluate connection-level parallel implementations of both TCP/IP and UDP/IP protocol stacks. We focus on three questions in our performance evaluation: how throughput scales with the number of processors, how throughput changes as the number of connections increases, and how fairly the aggregate bandwidth is distributed across connections. We show how several factors impact performance: the number of processors used, the number of threads in the system, the number of connections assigned to each thread, and the type of protocols in the stack (i.e., TCP versus UDP).Our results show that with careful implementation connection-level parallel protocol stacks scale well with the number of processors, and deliver high throughput which is, for the most part, sustained as the number of connections increases. Maximizing the number of threads in the system yields the best overall throughput. However, the best fairness behavior is achieved by matching the number of threads to the number of processors and scheduling connections assigned to threads in a round-robin manner.
Evaluation of model-based retrieval effectiveness with OCR text
Authors: Kazem Taghva, Julie Borsack, Allen Condit
Venue: ACM Transactions on Information Systems (TOIS) (1996)

We give a comprehensive report on our experiments with retrieval from OCR-generated text using systems based on standard models of retrieval. More specifically, we show that average precision and recall is not affected by OCR errors across systems for several collections. The collections used in these experiments include both actual OCR-generated text and standard information retrieval collections corrupted through the simulation of OCR errors. Both the actual and simulation experiments include full-text and abstract-length documents. We also demonstrate that the ranking and feedback methods associated with these models are generally not robust enough to deal with OCR errors. It is further shown that the OCR errors and garbage strings generated from the mistranslation of graphic objects increase the size of the index by a wide margin. We not only point out problems that can arise from applying OCR text within an information retrieval environment, we also suggest solutions to overcome some of these problems.
Constrained types and their expressiveness
Authors: Jens Palsberg, Scott Smith
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1996)

A constrained type consists of both a standard type and a constraint set. Such types enable efficient type inference for object-oriented languages with polymorphism and subtyping, as demonstrated by Eifrig, Smith, and Trifonov. Until now, it has been unclear how expressive constrained types are. In this article we study constrained types without universal quantification. We prove that they accept the same programs as the type system of Amadio and Cardelli with subtyping and recursive types. This result gives a precise connection between constrained types and the standard notion of types.
Identification of $q(x)$ in $u_t=\Delta u-qu$ from Boundary Observations
Authors: Sergei Avdonin, Thomas I. Seidman
Venue: SIAM Journal on Control and Optimization (1995)

We consider the problem of recovering the coefficient $q(x)$ in the equation $u_t=\Delta u-qu$ from boundary observations. Uniqueness of $q$ based on knowledge of the Neumann $\mapsto$ Dirichlet response operator is shown as an implication of (known) corresponding results concerning the inverse problem for the corresponding hyperbolic equation $w_{tt}=\Delta w-qw$. This is then reduced to use of the response to a single input with some consideration of computational approximation.
The Internet is not TV: Web publishing
Authors: Larry Press
Venue: Communications of the ACM (1995)

Don't turn the page. This is not yet-another article on how great the World-Wide Web is, and how fast it is growing. By now you must have read many of those, and surfed the Web a bit. But, the Internet is not television&mdash;are you ready to become a Web author? This article describes tools and considerations for publishing on them Web, and looks toward the future. Let's start with server platfroms.