ppxscal/embedding_network huggingface dataset:
Strip trees: a hierarchical representation for curves
Authors: Dana H. Ballard
Venue: Communications of the ACM (1981)

The use of curves to represent two-dimensional structures is an important part of many scientific investigations. For example, geographers use curves extensively to represent map features such as contour lines, roads, and rivers. Circuit layout designers use curves to specify the wiring between circuits. Because of the very large amount of data involved and the need to perform operations on this data efficiently, the representation of such curves is a crucial issue. A hierarchical representation consisting of binary trees with a special datum at each node is described. This datum is called a strip and the tree that contains such data is called a strip tree. Lower levels in the tree correspond to finer resolution representations of the curve. The strip tree structure is a direct consequence of using a special method for digitizing lines and retaining all intermediate steps. This gives several desirable properties. For curves that are well-behaved, intersection and point-membership (for closed curves) calculations can be solved in 0(log n) where n is the number of points describing the curve. The curves can be efficiently encoded and displayed at various resolutions. The representation is closed under intersection and union and these operations can be carried out at different resolutions. All these properties depend on the hierarchical tree structure which allows primitive operations to be performed at the lowest possible resolution with great computational time savings. Strip trees is a linear interpolation scheme which realizes an important space savings by not representing all the points explicitly. This means that even when the overhead of the tree indexing is added, the storage requirement is comparable to raster representations which do represent most of the points explicitly.
A note on storage of strings
Authors: A. T. Berztiss
Venue: Communications of the ACM (1965)

A method for storing strings is described which uses blocks of indefinite size, and is therefore completely dynamic. Its relation to similar schemes is discussed.
Cheap eagerness: speculative evaluation in a lazy functional language
Authors: Karl-Filip Faxén
Venue: Proceedings of the fifth ACM SIGPLAN international conference on Functional programming (2000)

Cheap eagerness is an optimization where cheap and safe expressions are evaluated before it is known that their values are needed. Many compilers for lazy functional languages implement this optimization, but they are limited by a lack of information about the global flow of control and about which variables are already evaluated. Without this information, even a variable reference is a potentially unsafe expression!In this paper we show that significant speedups are achievable by cheap eagerness. Our cheapness analysis uses the results of a program-wide data and control flow analysis to find out which variables may be unevaluated and which variables may be bound to functions which are dangerous to call.
Data input by question and answer
Authors: I. C. Pyle
Venue: Communications of the ACM (1965)

A data input scheme for a time-sharing computer is described in this paper. Instead of using format statements to determine the input, the computer asks the user for the required values one at a time. The computer converses with the user during the input process, checks for errors, provides standard data, and allows editing of values input.
Causal consistency in mobile environment
Authors: D. Janaki Ram, M. Uma Mahesh, N. S. K. Chandra Sekhar, Chitra Babu
Venue: ACM SIGOPS Operating Systems Review (2001)

Causal consistency stipulates that causally dependent writes to data items should be executed in causal order. Traditionally this has been done by causally ordered message delivery using vector clocks. In a vector clock of size N, each element of the vector corresponds to each of the N hosts in the system and hence the message overhead is Theta;(N). In a mobile environment the number of hosts can not be fixed because hosts join and leave the system dynamically. Hence traditional vector clocks are not suitable in a mobile environment. Consistency of a system consisting of M data items can be maintained using a vector in which each element corresponds to each data item. We propose a mechanism for maintaining causal consistency whose message overhead is Theta;(M). Such a model will be advantageous in a mobile environment, because the message overhead is independent of the number of hosts. Further in applications such as collaboration the number of data items is small. Also, the delivery of a message is never inhibited due to causally overwritten messages.
A process for the determination of addresses in variable length addressing
Authors: Gideon Frieder, Harry J. Saal
Venue: Communications of the ACM (1976)

An algorithm is presented for the assignment of instruction addresses and formats under the following conditions: (1) the length of the instruction varies as a function of the distance of the instruction from its target; (2) there exists an optimality criterion which implies some preferential choices subject to the addressing constraints. This may be, for example, achieving the smallest number of long instructions, in which case the total code length is minimized, or minimizing the assigned address of a specified point in the program. The algorithm is suitable for arbitrary program structure and a choice of optimization criteria.
The MiddGo project
Authors: Brian McQuade
Venue: Journal of Computing Sciences in Colleges (2001)

The ancient game of go, still the most popular strategy game in the Far East, has proven very challenging for artificial intelligence (AI) researchers trying to develop go-playing programs. In contrast to the best chess, checkers, backgammon, Othello, and Scrabble programs, all of which play at or better than the level of the top human players, the best go programs play only at the level of advanced beginners. The MiddGo project, begun in the Fall of 1999, aims to better understand the challenges posed by go and to investigate approaches for improving the performance of go-playing systems.
Casablanca: designing social communication devices for the home
Authors: Debby Hindus, Scott D. Mainwaring, Nicole Leduc, Anna Elizabeth Hagström, Oliver Bayley
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (2001)

The Casablanca project explored how media space concepts could be incorporated into households and family life. This effort included prototypes built for the researchers' own home use, field studies of households, and consumer testing of design concepts. A number of previously unreported consumer preferences and concerns were uncovered and incorporated into several original prototypes, most notably ScanBoard and the Intentional Presence Lamp. Casablanca also resulted in conclusions about designing household social communication devices.
Cite me, cite my references?: (Scholarly use of the ACM SIGIR proceedings based on two citation indexes)
Authors: Elana Broch
Venue: Proceedings of the 24th annual international ACM SIGIR conference on Research and development in information retrieval (2001)

A three-part study was designed to document Internet use in scholarly research, using the Annual SIGIR Conference Proceedings from 1997 through 1999. The results suggest an increasing trend toward electronic self-publishing. Furthermore, while electronic availability did not insure that one would be cited, the most highly cited articles were available on the "free" web. The study also found that electronic availability has not, in most cases, decreased the length of time between publication and citation.
Deploying the Squid Proxy Server on Linux
Authors: Ian Spare
Venue: Linux Journal (2001)

Ian gives an example of the installation, configuration and maintenance of this multi-tentacled invertebrate proxy server.
A second look at bloom filters
Authors: James K. Mullin
Venue: Communications of the ACM (1983)

This note deals with a paper by Gremillion demonstrating the simulation approach to the design of a Bloom filter. It is shown that an analytical approach can yield insights into competing filter design and give expected values for the goodness-of-hash transformations not available with simulation. On the other hand, simulation gives insight into what can be expected with available hash transformation not available from an analytic approach.
Bound Computation of Dependability and Performance Measures
Authors: Stephanie Mahévas, Gerardo Rubino
Venue: IEEE Transactions on Computers (2001)

We propose a new method to obtain bounds of dependability, performance or performability measures concerning complex systems modeled by a large Markov model. It extends previously published techniques mainly designed to the analysis of dependability measures only and working under more restrictive conditions. Our approach allows us to obtain tight bounds of performance measures on certain cases and, in particular, on models having an infinite state space. We illustrate the method with some analytically intractable open queuing networks, as well as with large dependability models.
A fast algorithm for finding dominators in a flowgraph
Authors: Thomas Lengauer, Robert Endre Tarjan
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1979)

A fast algorithm for finding dominators in a flowgraph is presented. The algorithm uses depth-first search and an efficient method of computing functions defined on paths in trees. A simple implementation of the algorithm runs in O(m log n) time, where m is the number of edges and n is the number of vertices in the problem graph. A more sophisticated implementation runs in O(m&agr;(m, n)) time, where &agr;(m, n) is a functional inverse of Ackermann's function. Both versions of the algorithm were implemented in Algol W, a Stanford University version of Algol, and tested on an IBM 370/168. The programs were compared with an implementation by Purdom and Moore of a straightforward O(mn)-time algorithm, and with a bit vector algorithm described by Aho and Ullman. The fast algorithm beat the straightforward algorithm and the bit vector algorithm on all but the smallest graphs tested.
Cubic spline solutions to fourth-order boundary value problems
Authors: W. D. Hoskins
Venue: Communications of the ACM (1973)

The cubic spline approximation to the fourth-order differential equation yi&ugr; + p(x)y&Prime; + q(x)y&prime; + r(x)y = t(x) is shown to reduce to the solution of a five-term recurrence relationship. For some special cases the approximation is shown to be simply related to a finite difference representation with a local truncation error of order (1/720)&dgr;8y.
Estimating routing congestion using probabilistic analysis
Authors: Jinan Lou, Shankar Krishnamoorthy, Henry S. Sheng
Venue: Proceedings of the 2001 international symposium on Physical design (2001)

Design routability is a major concern in the ASIC design flow, particularly with todays increasingly aggressive process technology nodes. Increased die areas, cell densities, routing layers, and net count all contribute to complex interconnect requirements, which can significantly deteriorate performance, and sometimes lead to unroutable solutions. Congestion analysis and optimization must be performed early in the design cycle to improve routability. This paper presents a congestion estimation algorithm for a placed netlist. We propose a net-based stochastic model for computing expected horizontal and vertical track usage, which considers routing blockages. The main advantages of this algorithm are accuracy and fast runtime. We show that the congestion estimated by this algorithm correlates well with post-route congestion, and show experimental results of subsequent congestion optimization based this algorithm.
Performance evaluation of multidimensional access methods
Authors: Ricardo Rodrigues Ciferri, Ana Carolina Salgado
Venue: Proceedings of the 8th ACM international symposium on Advances in geographic information systems (2000)

In this paper, we describe an experimental examination of a well-known group of multidimensional access methods, called the R-tree group. The test environment aimed at investigating how the performance of such access methods is affected by factors such as datasets volume scalability, disk page size and the area of non-zero size objects. The workload was composed of point queries, intersection and containment range queries. Moreover, we analyzed the efficiency of initial indexing structure building. We based our comparison mainly on the number of disk accesses.
A comparison of three approaches to language, compiler, and library support for multidimensional arrays in Java
Authors: José E. Moreira, Samuel P. Midkiff, Manish Gupta
Venue: Proceedings of the 2001 joint ACM-ISCOPE conference on Java Grande (2001)

The lack of direct support for multidimensional arrays in Java&trade; has been recognized as a major deficiency in the language's applicability to numerical computing. The typical approach to adding multidimensional arrays to Java has been through class libraries that implement these structures. It has been shown that the class library approach can achieve very high-performance for numerical computing, through the use of compiler techniques and efficient implementations of aggregate array operations. Because of the inconvenience of accessing array elements through method invocations, it is advocated by many that class libraries for multidimensional arrays should be combined with new language syntax to facilitate manipulation of those multidimensional arrays. Another approach that has been discussed in the literature is that of relying exclusively on the JVM to recognize those arrays of arrays that are being used to stimulate multidimensional arrays. This approach can also deliver good performance, but it does not improve the existing interfaces for numerical computing. There is yet a third approach: extending the Java language with new syntactic constructs for multidimensional arrays and directly compiling those constructs to bytecode. The new constructs provide a more convenient interface for numerical computing, without requiring a matching class library. This paper is a comparative discussion or the three approaches to adding multidimensional arrays to Java mentioned above. We present a description of the three approaches, listing the pros and cons of each. We give a more detailed description of the third approach &mdash; language constructs translated to bytecode &mdash; as it is a new contribution. We compare each of the approaches with regards to functionality, impact on the language and virtual machine specification, implementation efforts, and typical achievable performance. We show that the best choice depends on the relative importance attached to the above metrics.
Understanding memory allocation of scheme programs
Authors: Manuel Serrano, Hans-J. Boehm
Venue: Proceedings of the fifth ACM SIGPLAN international conference on Functional programming (2000)

Memory is the performance bottleneck of modern architectures. Keeping memory consumption as low as possible enables fast and unobtrusive applications. But it is not easy to estimate the memory use of programs implemented in functional languages, due to both the complex translations of some high level constructs, and the use of automatic memory managers.To help understand memory allocation behavior of Scheme programs, we have designed two complementary tools. The first one reports on frequency of allocation, heap configurations and on memory reclamation. The second tracks down memory leaks1. We have applied these tools to our Scheme compiler, the largest Scheme program we have been developing. This has allowed us to drastically reduce the amount of memory consumed during its bootstrap process, without requiring much development time.Development tools will be neglected unless they are both conveniently accessible and easy to use. In order to avoid this pitfall, we have carefully designed the user interface of these two tools. Their integration into a real programming environment for Scheme is detailed in the paper.
A method for obtaining digital signatures and public-key cryptosystems
Authors: R. L. Rivest, A. Shamir, L. Adleman
Venue: Communications of the ACM (1978)

An encryption method is presented with the novel property that publicly revealing an encryption key does not thereby reveal the corresponding decryption key. This has two important consequences: (1) Couriers or other secure means are not needed to transmit keys, since a message can be enciphered using an encryption key publicly revealed by the intented recipient. Only he can decipher the message, since only he knows the corresponding decryption key. (2) A message can be &ldquo;signed&rdquo; using a privately held decryption key. Anyone can verify this signature using the corresponding publicly revealed encryption key. Signatures cannot be forged, and a signer cannot later deny the validity of his signature. This has obvious applications in &ldquo;electronic mail&rdquo; and &ldquo;electronic funds transfer&rdquo; systems. A message is encrypted by representing it as a number M, raising M to a publicly specified power e, and then taking the remainder when the result is divided by the publicly specified product, n, of two large secret primer numbers p and q. Decryption is similar; only a different, secret, power d is used, where e * d &equiv; 1(mod (p - 1) * (q - 1)). The security of the system rests in part on the difficulty of factoring the published divisor, n.
Cycles to recycle: garbage collection to the IA-64
Authors: Richard L. Hudson, J. Elliot Moss, Sreenivas Subramoney, Weldon Washburn
Venue: Proceedings of the 2nd international symposium on Memory management (2000)

The IA-64, Intel's 64-bit instruction set architecture, exhibits a number of interesting architectural features. Here we consider those features as they relate to supporting garbage collection (GC). We aim to assist GC and compiler implementors by describing how one may exploit features of the IA-64. Along the way, we record some previously unpublished object scanning techniques, and offer novel ones for object allocation (suggesting some simple operating system support that would simplify it) and the Java &ldquo;jsr problem&rdquo;. We also discuss ordering of memory accesses and how the IA-64 can achieve publication safety efficiently. While our focus is not on any particular GC implementation or programming language, we draw on our experience designing and implementing GC for the Intel Java Virtual Machine for the IA-64.
A tight bound on the number of geometric permutations of convex fat objects in {\huge $\mathbf{\reals^d}$}
Authors: Matthew J. Katz, Kasturi Varadarajan
Venue: Proceedings of the seventeenth annual symposium on Computational geometry (2001)

We show that the maximum number of geometric permutations of a set of $n$ pairwise-disjoint convex and fat objects in $\reals^d$ is $O(n^{d-1})$. This generalizes the bound of $\Theta (n^{d-1})$ obtained by Smorodinsky et al. \cite{ssm98} on the number of geometric permutations of $n$ pairwise-disjoint balls.
Line-Sum Symmetry via the DomEig Algorithm
Authors: Charles R. Johnson, Joel Pitkin, David P. Stanford
Venue: Computational Optimization and Applications (2000)

We propose a new algorithm, the DomEig algorithm, for obtaining the line-sum-symmetric similarity-scaling of a given irreducible, essentially nonnegative matrix A. It is based on results concerning the minimum dominant eigenvalue of an essentially nonnegative matrix under trace-preserving perturbations of its diagonal. In this note we relate the minimum dominant eigenvalue problem to the problem of determining the diagonal scaling matrix for line-sum-symmetry. We present the DomEig algorithm, prove its convergence, and discuss briefly the results of a comparison of this algorithm with another algorithm, the DSS algorithm, often used for line-sum symmetry. The experiments suggest that, for matrices of order greater than 50, the convergence rate, measured either in flop counts or CPU time, is significantly greater for DomEig than for DSS, with the improvement in rate increasing as the order increases. The algorithm may be useful in such applications as the scaling of large social accounting matrices.
Decoupling capacitance allocation for power supply noise suppression
Authors: Shiyou Zhao, Kaushik Roy, Cheng-Kok Koh
Venue: Proceedings of the 2001 international symposium on Physical design (2001)

We investigate the problem of decoupling capacitance allocation for power supply noise suppression at floorplan level. Decoupling capacitance budgets for the circuit modules are calculated based on the power supply noise estimates. A linear programming technique is used to maximize the allocation of the existing white space in the floorplan for the placement of decoupling capacitors. An incremental heuristic is proposed to insert more white space into the existing floorplan to meet the remaining demand required for decoupling capacitance fabrication. Experimental results on six MCNC benchmark circuits show that the white space allocated for decoupling capacitance is about 6%-12% of the chip area for the 0.25&mgr;&mgr; technology, and the power supply noise can be kept below 10%Vdd.
Enlarging the Margins in Perceptron Decision Trees
Authors: Kristin P. Bennett, Nello Cristianini, John Shawe-Taylor, Donghui Wu
Venue: Machine Learning (2000)

Capacity control in perceptron decision trees is typically performed by controlling their size. We prove that other quantities can be as relevant to reduce their flexibility and combat overfitting. In particular, we provide an upper bound on the generalization error which depends both on the size of the tree and on the margin of the decision nodes. So enlarging the margin in perceptron decision trees will reduce the upper bound on generalization error. Based on this analysis, we introduce three new algorithms, which can induce large margin perceptron decision trees. To assess the effect of the large margin bias, OC1 (Journal of Artificial Intelligence Research, 1994, 2, 1&ndash;32.) of Murthy, Kasif and Salzberg, a well-known system for inducing perceptron decision trees, is used as the baseline algorithm. An extensive experimental study on real world data showed that all three new algorithms perform better or at least not significantly worse than OC1 on almost every dataset with only one exception. OC1 performed worse than the best margin-based method on every dataset.
Revisiting floorplan representations
Authors: Bo Yao, Hongyu Chen, Chung-Kuan Cheng, Ronald Graham
Venue: Proceedings of the 2001 international symposium on Physical design (2001)

Floorplan representations are a fundamental issue in designing floorplan algorithms. In this paper, we first derive the exact number of configurations of mosaic floorplans and slicing floorplans. We then present two non-redundant representations: a twin binary tree structure for mosaic floorplans and a slicing ordered tree for slicing floorplans. Finally, the relations between the state-of-the-art floorplan representations are discussed and their efficiency is explored.
Geometric constraint solver using multivariate rational spline functions
Authors: Gershon Elber, Myung-Soo Kim
Venue: Proceedings of the sixth ACM symposium on Solid modeling and applications (2001)

We present a new approach to building a solver for a set of geometric constraints represented by multivariate rational functions. The constraints are formulated using inequalities as well as equalities. When the solution set has dimension larger than zero, we approximate it by fitting a hypersurface to discrete solution points. We also consider a variety of constraint solving problems common in geometric modeling. These include computing ray-traps, bisectors, sweep envelopes, and regions accessible during 5-axis machining.