ppxscal/embedding_network huggingface dataset:
A vector space model for automatic indexing
Authors: G. Salton, A. Wong, C. S. Yang
Venue: Communications of the ACM (1975)

In a document retrieval, or other pattern matching environment where stored entities (documents) are compared with each other or with incoming patterns (search requests), it appears that the best indexing (property) space is one where each entity lies as far away from the others as possible; in these circumstances the value of an indexing system may be expressible as a function of the density of the object space; in particular, retrieval performance may correlate inversely with space density. An approach based on space density computations is used to choose an optimum indexing vocabulary for a collection of documents. Typical evaluation results are shown, demonstating the usefulness of the model.
A practitioner's guide to addressing algorithms
Authors: Dennis Severance, Ricardo Duhne
Venue: Communications of the ACM (1976)

This paper consolidates a number of popular rules of thumb which have been suggested for the design of record addressing algorithms, and discusses the applicability of these rules to large commercial databases. Guidelines for selecting identifier transformations, overflow techniques, loading factors, bucket sizes, and loading order are considered. Particular attention is focused on the reasonableness of common heuristics for determining primary or secondary bucket sizes. A mathematical model which explicitly considers storage device characteristics and time/space cost tradeoffs is used to analyze the effect of design parameters on overall system costs. A specific design example is presented and solved.
A base for a mobile programming system
Authors: Richard J. Orgass, William M. Waite
Venue: Communications of the ACM (1969)

An algorithm for a macro processor which has been used as the base of an implementation, by bootstrapping, of processors for programming languages is described. This algorithm can be easily implemented on contemporary computing machines. Experience with programming languages whose implementation is based on this algorithm indicates that such a language can be transferred to a new machine in less than one man-week without using the old machine.
Experiments with an automated instructional system for numerical methods
Authors: A. E. Oldehoeft, S. D. Conte
Venue: Communications of the ACM (1971)

A comer system was developed at Purdue University to teach portions of an undergraduate course in numerical methods. Each instructional unit or lesson is divided into three modes of instruction which allow the student to press from a computer-controlled presentation to a student-controlled investigation. The system is designed as a classroom-independent course of study, and has been used for two semesters by students in lieu of conventional classroom instruction. Initial measures of effectiveness, student acceptance, and operational cost are the result of testing the system independent of instructor intervention. The system is operational on a CDC 6500 with teletype terminals.
A Space Efficient Dynamic Allocation Algorithm for Queuing Messages
Authors: Eric Beyer, Peter Buneman
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1979)

A simple dynamic allocation algorithm is described for queuing variable length messages in memory. The algorithm makes use of the ability of many operating system to increase and decrease available memory as required. Some results describing its efficiency are presented.
A general program for the analysis of square and rectanglar lattice designs
Authors: K. W. Smillie
Venue: Communications of the ACM (1963)

This paper describes a general-purpose program that will handle those incomplete block designs known as square and rectangular lattices. Flow diagrams are given so that the method of calculation may be programmed for any digital computer.
EXercita: automatic web publishing of programming exercises
Authors: C. Gregorio-Rodríguez, L. Llana-Díaz, P. Palao-Gostanza, C. Pareja-Flores, R. Martínez-Unanue, J. Á. Velázquez-Iturbide
Venue: ACM SIGCSE Bulletin (2001)

EXercita is a system designed to archive and publish programming exercises. It consists of a repository of structured documents, each describing an exercise, and several tools to manage it. Documents are marked-up with an extension of LaTeX we have designed, called eXercita, and can be automatically published as PostScript files or Web pages. In addition, exercises can be automatically published as a hierarchical Web site that mirrors the structure of the repository.
Challenges in mathematical computing
Authors: Jonathan M. Borwein, Peter B. Borwein
Venue: Computing in Science and Engineering (2001)

Almost all interesting mathematical algorithmic questions relate to NP-hard questions. Such computation is prone to explode exponentially. The authors anticipate the greatest benefit will come from mathematical platforms that allow for computer-assisted insight generation, not from solutions of grand-challenge problems.
The reallocation of hash-coded tables
Authors: Carter Bays
Venue: Communications of the ACM (1973)

When the space allocation for a hash-coded table is altered, the table entries must be rescattered over the new space. A technique for accomplishing this rescattering is presented. The technique is independent of both the length of the table and the hashing function used, and can be utilized in conjunction with a linear reallocation of the table being rescattered. Moreover, it can be used to eliminate previously flagged deletions from any hash-coded table, or to change from one hashing method to another. The efficiency of the technique is discussed and theoretical statistics are given.
Interfaces for understanding multi-agent behavior
Authors: Pedro Szekely, Craig Milo Rogers, Martin Frank
Venue: Proceedings of the 6th international conference on Intelligent user interfaces (2001)

>Synchronized punch-card displaysare an interface technique to visualize tens of thousands of variables by encoding their values as color chips in a rectangular array. Our technique ties multiple such displays to a timeline of events enabling the punch-card displays to show animations of the behavior of complex systems. Punch-card displays not only make it easy to understand the high-level behavior of systems, but also enable users to quickly focus on individual variables and on fine-grained time intervals. This paper describes synchronized punch-card displays and shows how this technique is extremely powerful for understanding the behavior of complex multi-agent systems.
Algorithm 486: Numerical inversion of Laplace transform [D5]
Authors: Francoise Veillon
Venue: Communications of the ACM (1974)

This work forms part of a thesis presented in Grenoble in March 1972. Improvements made to the Dubner and Abate algorithm for numerical inversion of the Laplace transform [1] have led to results which compare favorably with theirs and those of Bellmann [2], and Stehfest [3]. The Dubner method leads to the approximation formula: &fnof;(t) = 2eat/T[1/2Re{F(a)} + &sum;&infin;k-1 Re{F(a + ik&pgr;/T)}cos(k&pgr;t/T)], (1) where F(s) is the Laplace transform of &fnof;(t) and a is positive and greater than the real parts of the singularities of &fnof;(t).
Graduate education: the Ph.D. glut
Authors: W. H. Payne
Venue: Communications of the ACM (1973)

[Two years ago the author was elected by the Washington State University faculty to a three-year term as a faculty representative to a Graduate Studies Committee charged &ldquo;to examine and evaluate proposed changes in the policy of the Graduate School.&rdquo; After his experiences and considerable study, the author says he feels compelled to express his observations and opinions to his fellow members of the Association for Computing Machinery.]
The dynamics of software project scheduling
Authors: Tarek K. Abdel-Hamid, Stuart E. Madnick
Venue: Communications of the ACM (1983)

Software project scheduling is one of the major problem areas faced by software project managers today. While several quantitative software project resource and schedule estimation methods have been developed, such techniques raise some important, but as yet unresolved, dynamic issues. A systems dynamics (SD) approach is used to analyze several key dynamic software project scheduling issues.
Binary Quasi-Cyclic Goppa Codes
Authors: Grégoire Bommier, Francis Blanchet
Venue: Designs, Codes and Cryptography (2000)

We obtain here a necessary and sufficient condition for a certain class of binary Goppa code to be quasi-cyclic. We also give another sufficient condition which is easier to check. We define a class of quasi-cyclic Goppa codes. We find the true dimension for a part of those quasi-cyclic codes. and also a class of extended quasi-cyclic codes the minimum distance of which is equal to the designed distance.
A Parallel Algorithm for Volume Projections on SIMD Mesh-Connected Computers
Authors: Hongzheng Li, Hongchi Shi
Venue: The Journal of Supercomputing (2000)

Projections are widely used in machine vision, volume rendering, and computer graphics. For applications with 3D volume data, we design a parallel projection algorithm on SIMD mesh-connected computers and implement the algorithm on the Parallel Algebraic Logic (PAL) computer. The algorithm is a parallel ray casting algorithm for both orthographic and perspective projections. It decomposes a volume projection into two transformations that can be implemented in the SIMD fashion to solve the data distribution and redistribution problem caused by non-regular data access patterns in volume projections.
Computational Linguistics: Graphical input/output of nonstandard characters
Authors: Hideyuki Hayashi, Sheila Duncan, Susumu Kuno
Venue: Communications of the ACM (1968)

A system developed at Harvard for graphically inputting and outputting nonstandard characters on a computer is printed. In principle, the system can deal with any orthography, although at present it is limited to 4000 Chinese characters and some mathematical symbols. New characters can be added to the repertoire of the system by graphical input on a display scope. Text inputting is accomplished via a display scope or a Rand Tablet. The organization and operation of the current system are described, and a discussion of the relative merits of such a system is given. Illustrations of the computer input and output of Chinese characters are included.
Talking to UNIX in English: an overview of UC
Authors: Robert Wilensky, Yigal Arens, David Chin
Venue: Communications of the ACM (1984)

UC is a natural language help facility which advises users in using the UNIX operating system. Users can query UC about how to do things, command names and formats, online definitions of UNIX or general operating systems terminology, and debugging problems in using commands. UC is comprised of the following components: a language analyzer and generator, a context and memory model, an experimental common-sense planner, highly extensible knowledge bases on both the UNIX domain and the English language, a goal analysis component, and a system for acquisition of new knowledge through instruction in English. The language interface of UC is based on a &ldquo;phrasal analysis&rdquo; approach which integrates semantic, grammatical and other types of information. In addition, it includes capabilities for ellipsis resolution and reference disambiguation.
On the criteria to be used in decomposing systems into modules
Authors: D. L. Parnas
Venue: Communications of the ACM (1972)

This paper discusses modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time. The effectiveness of a &ldquo;modularization&rdquo; is dependent upon the criteria used in dividing the system into modules. A system design problem is presented and both a conventional and unconventional decomposition are described. It is shown that the unconventional decompositions have distinct advantages for the goals outlined. The criteria used in arriving at the decompositions are discussed. The unconventional decomposition, if implemented with the conventional assumption that a module consists of one or more subroutines, will be less efficient in most cases. An alternative approach to implementation which does not have this effect is sketched.
A comparison of floating point summation methods
Authors: James Gregory
Venue: Communications of the ACM (1972)

In the June 1970 issue of Communications, Linz [1] proposed a method of pairwise summing of numbers to reduce accumulated roundoff error. Linz compared his method with only a simple recursive summation. The Linz method should have also been compared with a method published in the January 1965 issue by Kahan [2], which is more accurate. This note compares the schemes by Linz and Kahan with the straight recursive summation. Comparisons of accuracy, speed and storage were carried out on an IBM 360/75 with various compiler optimization levels. (Linz' restriction to a binary exponent is not essential to his method.)
Introducing computer systems from a programmer's perspective
Authors: Randal E. Bryant, David R. O'Hallaron
Venue: ACM SIGCSE Bulletin (2001)

The course "Introduction to Computer Systems" at Carnegie Mellon University presents the underlying principles by which programs are executed on a computer. It provides broad coverage of processor operation, compilers, operating systems, and networking. Whereas most systems courses present material from the perspective of one who designs or implements part of the system, our course presents the view visible to application programmers. Students learn that, by understanding aspects of the underlying system, they can make their programs faster and more reliable. This approach provides immediate benefits for all computer science and engineering students and also prepares them for more advanced systems courses. We have taught our course for five semesters with enthusiastic responses by the students, the instructors, and the instructors of subsequent systems courses.
Dynamic 3D maps as visual interfaces for spatio-temporal data
Authors: Jürgen Döllner, Oliver Kersting
Venue: Proceedings of the 8th ACM international symposium on Advances in geographic information systems (2000)

Dynamic 3D maps represent visual interfaces used to present and explore spatial and spatio-temporal data. They provide powerful design capabilities for map contents compared to current map toolkits and general-purpose 3D graphics systems. The underlying object model introduces abstract building blocks which are configured for individual animated, interactive 3D maps. These building blocks do not only include visual primitives but also structural and behavioral primitives: Structural primitives permit to arrange and hierarchically organize 3D map contents, and behavioral primitives define the dynamics and interactivity of 3D maps. The building blocks also support dynamic design of map contents to facilitate visualizing temporal data and phenomena. An embedded scripting language assists to configure 3D maps at run-time as well as to customize and extend 3D maps by the user. Possible applications include interactive, animated cartography, virtual geo-environments, and exploratory, visual interfaces for GIS.
The OMG life sciences research domain task force
Authors: David Benton, Karl Konnerth, Scott Markel
Venue: ACM SIGBIO Newsletter (2000)

The life sciences research community has long recognized the need for component-based software. Just as standard hardware interfaces make it possible to purchase the components of a hardware system from different vendors, component-based software allows system builders to choose components from a variety of vendors and assemble them to meet the unique needs of each researcher or project. Component-based software construction depends on the availability of components that perform the required functions and are accessed through standardized interfaces. The Life Sciences Research Domain Task Force of the Object Management Group was established as a forum for collaboratively specifying the requirements for software components for the life sciences research vertical domain and assisting the OMG in adopting technically excellent specifications for the standard interfaces that enable interoperation. In this paper, we describe the mission and status of this Task Force.
Operational systems of computer machines in the Galua's base
Authors: Yaroslav Nykolajchuk, Roman Korol
Venue: Proceedings of the symposium on Contemporary computing in Ukraine (2000)

In the article are circumscribed the theoretical fundamentalses and structural solutions of realization operational systems of computers because of submissions of datas in the Galua's base.
An interactive graphical display monitor in a batch-processing environment with remote entry
Authors: Alan H. Bond, Jerry Rightnour, L. Steven Coles
Venue: Communications of the ACM (1969)

A graphic monitor program is described. It was developed at Carnegie-Mellon University for the CDC G21 computer, which is a general purpose, batch-processing system with remote entry. The existing G21 system and the graphics hardware are described. The graphic monitor is a resident auxiliary monitor which provides comprehensive managerial capability over the graphical system in response to commands from the human user. It also will respond to commands from a user program through a similar interface, where routine calls take the place of manual actions. Thus the human and program can interact on a symmetrical and equal basis through the medium of the graphic monitor. The choices made in designing the graphic monitor, given the constraints of the existing hardware and computer system, are discussed. The structure of the monitor program and the human and program interfaces are described. There is also a transient swapping version with a small resident part, and provision for swapped used submonitors.
Real-world programming
Authors: Toshiyuki Masui
Venue: Proceedings of DARE 2000 on Designing augmented reality environments (2000)

Although more and more computing is performed away from desktop computers, most programs used in handheld computers, ubiquitous computers, and augmented-reality systems in the real world are still developed on desktop computers, and users of these systems cannot modify the behavior of the systems or make a new program for the systems without using desktop computers. Programs used in real-world environments should also be programmed in the real world, so we have developed a new programming paradigm, &ldquo;Real-World Programming (RWP),&rdquo; which enables users to make programs for handling real-world environments as well as data in computers. By combining simple hardware and software, users can specify actions and conditions and create programs in the real world without using desktop computers. In this paper we describe the features required for RWP, programming techniques for RWP, useful devices for RWP, and examples of RWP.
Classical floorplanning harmful?
Authors: A. B. Kahng
Venue: Proceedings of the 2000 international conference on Computer-aided design (2001)

Classical floorplanning formulations may lead researchers to solve the wrong problems. This paper points out several examples, including (i) the preoccupation with packing-driven, as opposed to connectivity-driven, problem formulations and benchmarking standards; (ii) the preoccupation with rectangular (and L or T shaped) block shapes; and (iii) the lack of attention to algorithm scalability, fixed-die layout requirements, and the overall RTL-down methodology context. The right problem formulations must match the purpose and context of prevailing RTL-down design methodologies, and must be neither overconstrained nor underconstrained. The right solution ingredients are those which are scalable while delivering good solution quality according to relevant metrics. We also describe new problem formulations and solution ingredients, notably a perfect rectilinear floorplanning formulation that seeks zero-whitespace, perfectly packed rectilinear floorplans in a fixed-die regime. The paper closes with a list of questions for future research.
Biopython: Python tools for computational biology
Authors: Brad Chapman, Jeffrey Chang
Venue: ACM SIGBIO Newsletter (2000)

The Biopython project was formed in August 1999 as a collaboration to collect and produce open source bioinformatics tools written in Python, an object-oriented scripting language. It is modeled on the highly successful Bioperl project, but has the goal of making libraries available for people doing computations in Python. The philosophy of all the Bio* projects is that part of bioinformaticists' work involves software development. In order to prevent repeated efforts we believe that the field can be advanced more quickly if libraries that perform common programming functions are available. Thus, we hope to create a central source for high-quality bioinformatics tools that researchers can use.As an open source project, Biopython can be downloaded for free from the web site at http://www.biopython.org. Biopython libraries are currently under heavy development. This paper describes the current state of available Biopython tools, shows examples of their use in common bioinformatics problems, and describes plans for future development.
Efficient generation of the binary reflected gray code and its applications
Authors: James R. Bitner, Gideon Ehrlich, Edward M. Reingold
Venue: Communications of the ACM (1976)

Algorithms are presented to generate the n-bit binary reflected Gray code and codewords of fixed weight in that code. Both algorithms are efficient in that the time required to generate the next element from the current one is constant. Applications to the generation of the combinations of n things taken k at a time, the compositions of integers, and the permutations of a multiset are discussed.
Main-memory index structures with fixed-size partial keys
Authors: Philip Bohannon, Peter Mcllroy, Rajeev Rastogi
Venue: Proceedings of the 2001 ACM SIGMOD international conference on Management of data (2001)

The performance of main-memory index structures is increasingly determined by the number of CPU cache misses incurred when traversing the index. When keys are stored indirectly, as is standard in main-memory databases, the cost of key retrieval in terms of cache misses can dominate the cost of an index traversal. Yet it is inefficient in both time and space to store even moderate sized keys directly in index nodes. In this paper, we investigate the performance of tree structures suitable for OLTP workloads in the face of expensive cache misses and non-trivial key sizes. We propose two index structures, pkT-trees and pkB-trees, which significantly reduce cache misses by storing partial-key information in the index. We show that a small, fixed amount of key information allows most cache misses to be avoided, allowing for a simple node structure and efficient implementation. Finally, we study the performance and cache behavior of partial-key trees by comparing them with other main-memory tree structures for a wide variety of key sizes and key value distributions.
Approximation algorithms for extensible bin packing
Authors: E. G. Coffman,  Jr., George S. Lueker
Venue: Proceedings of the twelfth annual ACM-SIAM symposium on Discrete algorithms (2001)

In a variation of bin packing called extensible bin packing, the number of bins to use is specified as part of the input, and bins may be extended to hold more than the usual unit capacity. The cost of a bin is one if it is not extended, and the size if it is extended. The goal is to pack a set of items of given sizes with minimum cost. Adapting ideas in [7, 8, ?], we give a fully polynomial asymptotic approximation scheme (FPTAAS) for extensible bin packing. We note that under a different scaling the problem could not admit an FPTAAS unless P = NP.