ppxscal/embedding_network huggingface dataset:
Smooth patching of refined triangulations
Authors: Jorg Peters
Venue: ACM Transactions on Graphics (TOG) (2001)

This paper presents a simple algorithm for associating a smooth, low-degree polynomial surface with triangulations whose extraordinary mesh nodes are separated by sufficiently many ordinary, 6-valent mesh nodes. Output surfaces are at least tangent continuous and are C2 sufficiently far away from extraordinary mesh nodes; they consist of three-sided B&eacute;zier patches of degree 4. In particular, the algorithm can be used to skin a mesh generated by a few steps of Loop's generalization of three-direction box-spline subdivision.
Multichannel pipeline implementation of the correcting matrix in the fast cosine transform algorithm
Authors: Yuriy Ermetov, Anatoly Melynyk
Venue: Proceedings of the symposium on Contemporary computing in Ukraine (2000)

In this paper methods of multichannel pipeline processors design for implementation of the fast cosine transform correcting matrix are considered. Three basic methods for the correcting matrix implementation are compared and a number of pipeline processors with their comparative estimation depending on performance, hardware amount and application are proposed. A new method of optimal hardware amount multichannel pipeline processors structure based on synthesis of three basic methods is proposed.
A storage allocation scheme for ALGOL 60
Authors: J. Jensen, P. Mondrup
Venue: Communications of the ACM (1961)

A storage allocation scheme for a machine with a 2048-instruction core store and a magnetic drum is described. The use of the drum for storing program blocks and/or data must be directed by the programmer through auxiliary information in the ALGOL program. The administrative routines controlling the storage at run time are described in full. A detailed example is given.
The Altran system for rational function manipulation &mdash; a survey
Authors: Andrew D. Hall,  Jr.
Venue: Communications of the ACM (1971)

Altran is a complete system for symbolic computation with rational functions in several variables with integer coefficients. It has been designed and implemented to handle large problems with ease and efficiency. Considerable effort has been spent to ensure a minimum amount of machine dependence in the implementation, thus permitting the system to be installed quickly and easily on a variety of computing machines. In this paper a brief description of the language, run time data structures, and implementation is given.
On computing sets of shortest paths in a graph
Authors: Edward Minieka
Venue: Communications of the ACM (1974)

Two algorithms are presented that construct the k shortest paths between every pair of vertices in a directed graph. These algorithms generalize the Floyd algorithm and the Dantzig algorithm for finding the shortest path between every pair of vertices in a directed graph.
Procedures for static compaction of test sequences for synchronous sequential circuits based on vector restoration
Authors: R. Guo, I. Pomeranz, S. M. Reddy
Venue: Proceedings of the conference on Design, automation and test in Europe (1998)

We propose several compaction procedures for synchronous sequential circuits based on test vector restoration. Under a vector restoration procedure, all or most of the test vectors are first omitted from the test sequence. Test vectors are then restored one at a time or in subsequences only as necessary to restore the fault coverage of the original sequence. Techniques to speed-up the restoration process are investigated. These include limiting the test vectors initially omitted from the test sequence, consideration of several faults in parallel during restoration, and the use of a parallel fault simulator.
3D or not 3D?: evaluating the effect of the third dimension in a document management system
Authors: Andy Cockburn, Bruce McKenzie
Venue: Proceedings of the SIGCHI conference on Human factors in computing systems (2001)

Several recent research systems have provided interactive three-dimensional (3D) visualisations for supporting everyday work such as file and document management. But what improvements do these 3D interfaces offer over their traditional 2D counterparts? This paper describes the comparative evaluation of two document management systems that differ only in the number of dimensions used for displaying and interacting with the data. The 3D system is heavily based on Robertson et al.'s Data Mountain, which supports users in storing, organising and retrieving &ldquo;thumbnail&rdquo; representations of documents such as bookmarked Web-pages. Results show that our subjects were faster at storing and retrieving pages in the display when using the 2D interface, but not significantly so. As expected, retrieval times significantly increased as the number of thumbnails increased. Despite the lack of significant differences between the 2D and 3D interfaces, subjective assessments showed a significant preference for the 3D interface.
An Improved Silicon Neuron
Authors: C. Rasche, R. Douglas
Venue: Analog Integrated Circuits and Signal Processing (2000)

We describe an improved spiking silicon neuron (SN) [6] that approximates the dynamics of ionic currents of a real nerve cell. The improved version has less circuitry and fewer parameters than previous circuits thereby improving the spiking characteristics. We describe the differential equations governing the revised circuits and use them to explain the spiking properties of the SN. We also describe how to tune the parameters efficiently to bring the neuron quickly into its correct operating regime. The new neurons are sufficiently robust for operation in large networks. We demonstrate their robustness by comparing the neuron&rsquo;s frequency-current curve between different chips for the same set of parameter values.
Graph-based code selection techniques for embedded processors
Authors: Rainer LEUPERS Leupers, Steven Bashford
Venue: ACM Transactions on Design Automation of Electronic Systems (TODAES) (2000)

Code selection is an important task in code generation for programmable processors, where the goal is to find an efficient mapping of machine-independent intermediate code to processor-specific machine instructions. Traditional approaches to code selection are based on tree parsing which enables fast and optimal code selection for intermediate code given as a set of data-flow trees. While this approach is generally useful in compilers for general-purpose processors, it may lead to poor code quality in the case of embedded processors. The reason is that the special architectural features of embedded processors require performing code selection on data-flow graphs, which are a more general representation of intermediate code. In this paper, we present data-flow graph-based code selection techniques for two architectural families of embedded processors: media processors with support for SIMD instructions and fixed-point DSPs with irregular data paths. Both techniques exploit the fact that, in the area of embedded systems, high code quality is a much more important goal than high compilation speed. We demonstrate that certain architectural features can only be utilized by graph-based code selection, while in other cases this approach leads to a significant increase in code quality as compared to tree-based code selection.
Programming early considered harmful
Authors: Lewis E. Hitchner
Venue: Proceedings of the thirty-second SIGCSE technical symposium on Computer Science Education (2001)

The premise of this panel is that most introductory Computer Science courses are too narrowly focused on teaching students a programming language. This is a controversy that has been debated for years, but in recent years seems to have been forgotten. The writers of Computing Curricula 1991 stated:"Many feel that the amount of attention traditionally paid to the syntax of a programming language in the first course is excessive, and ought to be replaced with a more balanced introduction to the discipline. For these reasons, PR: Introduction to a Programming Language is defined as a separate knowledge unit in Part II, but is not a required part of the common requirements. "[1]This panel will present a review of current, typical first year courses and evidence for the case against focusing those courses on the teaching of a programming language. Next, each panelist will present his or her philosophy for a first course, followed by details of the courses at their school that implement their view, and conclude with outcomes and evidence of success of the courses.The panel includes four experienced CS-1/CS-2 educators, two of whom are members of the Computing Curriculum 2001 Pedagogy Focus Group on Introductory Courses and Topics (including the chair), and two of whom are authors of introductory texts that do not focus on teaching a programming language.
The Japanese approach: a better way to manage programmers?
Authors: Paul S. Licker
Venue: Communications of the ACM (1983)

With a turnover rate among computer programmers of 25%-50% per year, it's time somebody came up with a better way to manage computer professionals. One approach that holds promise is to create a Japanese-style Theory Z atmosphere in the firm, stressing lifetime employment, non-specialized career paths, collective decision-making, and other holistic matters.
Designing for and interacting with CVEs
Authors: Adrian Bullock, Lennart Fahlén
Venue: ACM SIGGROUP Bulletin (2000)

As CVE technology matures there is a natural shift away from simply providing places or spaces for people to meet towards providing a useful, task-oriented environment that supports its participants in whatever it is they are doing. Notably, CVEs are collaborative environments, so in order to provide appropriate environments we need to understand what it is that makes collaboration possible. To do this we need to consider collaboration in both real world and virtual world setting, e.g. [1], and how the two interact with each other. After all we are not going to use either of these environments (real and virtual) exclusively, rather they should complement each other and we should be able to work with people as easily in either.Presently, the boundary between physical environments and digital space can be over complex and poorly designed. We often take a narrow perspective, seeing interaction as information processing, and interaction technology as simply a desktop computer. We need to broaden our view to consider the whole gamut of human activities, understanding how information systems are a medium of communication between people as much as a tool individual access to data. We can use the findings on collaboration to influence how we design and build future CVEs so they afford the best chance of supporting meaningful and useful interaction between participants.
Symmetric list processor
Authors: J. Weizenbaum
Venue: Communications of the ACM (1963)

A list processing system in which each list cell contains both a forward and a backward link as well as a datum is described. This system is intended for imbedding in higher level languages capable of calling functions and subroutines coded in machine language. The presentation is in the form of FORTRAN programs depending on only a limited set of &ldquo;primitive&rdquo; machine language subroutines which are also defined. Finally, a set of field, particularly character, manipulation primitives are given to round out the system.
Images as Embedded Maps and Minimal Surfaces: Movies, Color, Texture, and Volumetric Medical Images
Authors: R. Kimmel, R. Malladi, N. Sochen
Venue: International Journal of Computer Vision (2000)

We extend the geometric framework introduced in Sochen et al. (IEEE Trans. on Image Processing, 7(3):310&ndash;318, 1998) for image enhancement. We analyze and propose enhancement techniques that selectively smooth images while preserving either the multi-channel edges or the orientation-dependent texture features in them. Images are treated as manifolds in a feature-space. This geometrical interpretation lead to a general way for grey level, color, movies, volumetric medical data, and color-texture image enhancement.We first review our framework in which the Polyakov action from high-energy physics is used to develop a minimization procedure through a geometric flow for images. Here we show that the geometric flow, based on manifold volume minimization, yields a novel enhancement procedure for color images. We apply the geometric framework and the general Beltrami flow to feature-preserving denoising of images in various spaces.Next, we introduce a new method for color and texture enhancement. Motivated by Gabor's geometric image sharpening method (Gabor, Laboratory Investigation, 14(6):801&ndash;807, 1965), we present a geometric sharpening procedure for color images with texture. It is based on inverse diffusion across the multi-channel edge, and diffusion along the edge.
The Neural Solids; For optimization problems
Authors: Giansalvo Cirrincione, Maurizio Cirrincione
Venue: Neural Processing Letters (2001)

The neural solids are novel neural networks devised for solving optimization problems. They are dual to Hopfield networks, but with a quartic energy function. These solids are open architectures, in the sense that different choices of the basic elements and interfacings solve different optimization problems. The basic element is the neural resonator (triangle for the three dimensional case), composed of resonant neurons underlying a self-organizing learning. This module is able to solve elementary optimization problems such as the search for the nearest orthonormal matrix to a given one. Then, an example of a more complex solid, the neural decomposer, whose architecture is composed of neural resonators and their mutual connections, is given. This solid can solve more complex optimization problems such as the decomposition of the essential matrix, which is a very important technique in computer vision.
Multiple byte processing with full-word instructions
Authors: Leslie Lamport
Venue: Communications of the ACM (1975)

A method is described which allows parallel processing of packed data items using only ordinary full-word computer instructions, even though the processing requires operations whose execution is contingent upon the value of a datum. It provides a useful technique for processing small data items such as alphanumeric characters.
From trace generation to visualization: a performance framework for distributed parallel systems
Authors: C. Eric Wu, Anthony Bolmarcich, Marc Snir, David Wootton, Farid Parpia, Anthony Chan, Ewing Lusk, William Gropp
Venue: Proceedings of the 2000 ACM/IEEE conference on Supercomputing (CDROM) (2000)

In this paper we describe a trace analysis framework, from trace generation to visualization. It includes a unified tracing facility on IBM SP systems, a self-defining interval file format, an API for framework extensions, utilities for merging and statistics generation, and a visualization tool with preview and multiple time-space diagrams. The trace environment is extremely scalable, and combines MPI events with system activities in the same set of trace files, one for each SMP node. Since the amount of trace data may be very large, utilities are developed to convert and merge individual trace files into a self-defining interval trace file with multiple frame directories. The interval format allows the development of multiple time-space diagrams, such as thread-activity view, processor-activity view, etc., from the same interval file. A visualization tool, Jumpshot, is modified to visualize these views. A statistics utility is developed using the API along with its graphics viewer.
Practical virtual method call resolution for Java
Authors: Vijay Sundaresan, Laurie Hendren, Chrislain Razafimahefa, Raja Vallée-Rai, Patrick Lam, Etienne Gagnon, Charles Godin
Venue: Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (2000)

This paper addresses the problem of resolving virtual method and interface calls in Java bytecode. The main focus is on a new practical technique that can be used to analyze large applications. Our fundamental design goal was to develop a technique that can be solved with only one iteration, and thus scales linearly with the size of the program, while at the same time providing more accurate results than two popular existing linear techniques, class hierarchy analysis and rapid type analysis.We present two variations of our new technique, variable-type analysis and a coarser-grain version called declared-type analysis. Both of these analyses are inexpensive, easy to implement, and our experimental results show that they scale linearly in the size of the program.We have implemented our new analyses using the Soot frame-work, and we report on empirical results for seven benchmarks. We have used our techniques to build accurate call graphs for complete applications (including libraries) and we show that compared to a conservative call graph built using class hierarchy analysis, our new variable-type analysis can remove a significant number of nodes (methods) and call edges. Further, our results show that we can improve upon the compression obtained using rapid type analysis.We also provide dynamic measurements of monomorphic call sites, focusing on the benchmark code excluding libraries. We demonstrate that when considering only the benchmark code, both rapid type analysis and our new declared-type analysis do not add much precision over class hierarchy analysis. However, our finer-grained variable-type analysis does resolve significantly more call sites, particularly for programs with more complex uses of objects.
An Interval Logic for Real-Time System Specification
Authors: Riccardo Mattolini, Paolo Nesi
Venue: IEEE Transactions on Software Engineering (2001)

Formal techniques for the specification of real-time systems must be capable of describing system behavior as a set of relationships expressing the temporal constraints among events and actions, including properties of invariance, precedence, periodicity, liveness, and safety conditions. This paper describes a Temporal-Interval Logic with Compositional Operators (TILCO) designed expressly for the specification of real-time systems. TILCO is a generalization of classical temporal logics based on the operators eventually and henceforth; it allows both qualitative and quantitative specification of time relationships. TILCO is based on time intervals and can concisely express temporal constraints with time bounds, such as those needed to specify real-time systems. This approach can be used to verify the completeness and consistency of specifications, as well as to validate system behavior against its requirements and general properties. TILCO has been formalized by using the theorem prover Isabelle/HOL. TILCO specifications satisfying certain properties are executable by using a modified version of the Tableaux algorithm. This paper defines TILCO and its axiomatization, highlights the tools available for proving properties of specifications and for their execution, and provides an example of system specification and validation.
Merging with parallel processors
Authors: Fănică Gavril
Venue: Communications of the ACM (1975)

Consider two linearly ordered sets A, B, | A | = m, | B | = n, m &le; n, and p, p &le; m, parallel processors working synchronously. The paper presents an algorithm for merging A and B with the p parallel processors, which requires at most 2&lceil;log2(2m + 1)&rceil; + &lfloor;3m/p&rfloor; + [m/p][log2(n/m)] steps. If n = 2&bgr;m (&bgr; an integer), the algorithm requires at most 2[log2(m + 1)] + [m/p](2 + &bgr;) steps. In the case where m and n are of the same order of magnitude, i.e. n = km with k being a constant, the algorithm requires 2[log2(m + 1)] + [m/p](3 + k) steps. These performances compare very favorably with the previous best parallel merging algorithm, Batcher's algorithm, which requires n/p + ((m + n)/2p)log2m steps in the general case and km/p + ((k + 1)/2)(m/p)log2m in the special case where n = km.
Further remark on stably updating mean and standard deviation estimates
Authors: Lloyd S. Nelson
Venue: Communications of the ACM (1979)

A procedure for sequentially recomputing the mean and standard deviation of a weighted series of numbers as new values are added is given by Hanson [2]. To accommodate the most frequently occurring situation, Cotton [1] expressed Hanson's formulas in terms of unit weights. The result is accurate for updating the mean. However, for updating the standard deviation, Cotton chose to use Hanson's eq. (14), which Hanson rejected as being inaccurate when the new value is close to the mean.
MS read: user modeling in the web environment
Authors: Natasa Milió-Frayling, Ralph Sommerer
Venue: Proceedings of the 24th annual international ACM SIGIR conference on Research and development in information retrieval (2001)

MS Read is a prototype application implemented as an extension of the Web Browser that creates an evolving model of the users topic of interest. It uses that model to analyze documents that are accessed while searching and browsing the Web. In the presented version of MS Read the model is used to highlight topic related terminology in the documents. MS Read model of the user need is created by applying natural language processing to search queries captured within the Browser and to topic descriptions explicitly provided by the user while browsing and reading documents. It is semantically enhanced using linguistic and custom knowledge resources.
Dynamic memory allocation in computer simulation
Authors: Norman R. Nielsen
Venue: Communications of the ACM (1977)

e of 35 dynamic memory allocation algorithms when used to service simulation programs as represented by 18 test cases. Algorithm performance was measured in terms of processing time, memory usage, and external memory fragmentation. Algorithms maintaining separate free space lists for each size of memory block used tended to perform quite well compared with other algorithms. Simple algorithms operating on memory ordered lists (without any free list) performed surprisingly well. Algorithms employing power-of-two block sizes had favorable processing requirements but generally unfavorable memory usage. Algorithms employing LIFO, FIFO, or memory ordered free lists generally performed poorly compared with others.
Sorting nonredundant files&mdash;techniques used in the FACT compiler
Authors: John B. Glore
Venue: Communications of the ACM (1963)

Some typical file structures, including some called &ldquo;non-redundant,&rdquo; are examined, and the methods used in FACT to sort such files are discussed.
A variation on sorting by address calculation
Authors: Bush Jones
Venue: Communications of the ACM (1970)

The principles of address calculation and merging are combined to yield an efficient sorting technique. Detailed flowcharts of the most important program steps are included. The characteristics of the proposed sort are discussed.
A very high level programming language for data processing applications
Authors: Michael Hammer, W. Gerry Howe, Vincent J. Kruskal, Irving Wladawsky
Venue: Communications of the ACM (1977)

Application development today is too labor-intensive. In recent years, very high-level languages have been increasingly explored as a solution to this problem. The Business Definition Language (BDL) is such a language, one aimed at business data processing problems. The concepts in BDL mimic those which have evolved through the years in businesses using manual methods. This results in three different sublanguages or components: one for defining the business forms, one for describing the business organization, and one for writing calculations.