ppxscal/embedding_network huggingface dataset:
A Radix-4 Modular Multiplication Hardware Algorithm for Modular Exponentiation
Authors: Naofumi Takagi
Venue: IEEE Transactions on Computers (1992)

A fast radix-4 modular multiplication hardware algorithm is proposed. It is efficient for modular exponentiation with a large modulus, used in public-key cryptosystems such as the RSA cryptosystem. The operands and the result of multiplication which are intermediate results in modular exponentiation are represented in a redundant representation. The computation proceeds in serial-parallel fashion. Each subtraction for the division for residue calculation is embedded in the repeated multiply-add. Each intermediate result is represented in a more redundant representation than that for the operands and the result, so that the number of the required addition/subtractions is reduced. All addition/subtraction are carried out without carry propagation. A serial-parallel modular multiplier based on the algorithm has a regular cellular array structure with a bit slice feature and is suitable for VLSI implementation.
A Nearest Hyperrectangle Learning Method
Authors: Steven Salzberg
Venue: Machine Learning (1991)

This paper presents a theory of learning called nested generalized exemplar (NGE) theory, in which learning is accomplished by storing objects in Euclidean n-space, En, as hyperrectangles. The hyperrectangles may be nested inside one another to arbitrary depth. In contrast to generalization processes that replace symbolic formulae by more general formulae, the NGE algorithm modifies hyperrectangles by growing and reshaping them in a well-defined fashion. The axes of these hyperrectangles are defined by the variables measured for each example. Each variable can have any range on the real line&semi; thus the theory is not restricted to symbolic or binary values.This paper describes some advantages and disadvantages of NGE theory, positions it as a form of exemplar-based learning, and compares it to other inductive learning theories. An implementation has been tested in three different domains, for which results are presented below: prediction of breast cancer, classification of iris flowers, and prediction of survival times for heart attack patients. The results in these domains support the claim that NGE theory can be used to create compact representations with excellent predictive accuracy.
Teaching a graduate expert systems course
Authors: Kwok-bun Yue
Venue: ACM SIGCSE Bulletin (1990)

Because expert systems technology is relatively new, there are only a few papers describing a graduate course on the subject. Most of the described courses were either seminar oriented or centered around a student project, but did not have a complete coverage of the major topics. This paper describes the teaching of a graduate expert system course that has a relatively complete coverage of the subject area. Other additional features of the course include incremental development of the student projects, emphasis on evaluations of tools and projects, as well as using more conventional problems for strengthening expert system shell programming techniques.
A textual object management system
Authors: Scott C. Deerwester, Keith Waclena, Michelle LaMar
Venue: Proceedings of the 15th annual international ACM SIGIR conference on Research and development in information retrieval (1992)

Computer programs that access significant amounts of text usually include code that manipulates the textual objects that comprise it. Such programs include electronic mail readers, typesetters and, in particular, full-text information retrieval systems. Such code is often unsatisfying in that access to textual objects is either efficient, or flexible, but not both. A programming language like Awk or Perl provides very general facilities for describing textual objects, but at the cost of rescanning the text for every textual object. At the other extreme, full-text information retrieval systems usually offer access to a very limited number of kinds of textual objects, but this access is very efficient. The system described in this paper is a programming tool for managing textual objects. It provides a great deal of flexibility, giving access to very complex document structure, with a large number of constituent kinds of textual objects. Further, it provides access to these objects very efficiently, both in terms of time and auxiliary space, by being very careful to access secondary storage only when absolutely necessary.
A Lower Bound for Structuring Element Decompositions
Authors: Craig H. Richardson, Ronald W. Schafer
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1991)

A theoretical lower bound on the number of points required in the decomposition of morphological structuring elements is described. It is shown that the decomposition of an arbitrary N-point structuring element will require at least (3 ln N/ln 3)points. Using this lower bound it is possible to find the optimal decompositions (in terms of the minimum number of unions or the minimum number of points) for all one-dimensional connected line segments. L-dimensional rectangles may be decomposed by optimally decomposing the L one-dimensional line segments that describe the rectangle.
Integrating the heterogeneous control properties of software modules
Authors: Elizabeth L. White, James M. Purtilo
Venue: ACM SIGSOFT Software Engineering Notes (1992)

A concurrent software application, whether running on a single machine or distributed across multiple machines, is composed of tasks that interact (communicate and sychronize) in order to achieve some goal. Developing such concurrent programs so they cooperate effectively is a complex task, requiring that progrmmers craft their modules&ndash;the components from which concurrent applications are built&mdash;to meet both functional requirements and communication requirements. Unfortunately the result of this effort is a module that is difficult to reason about and even more difficult to reuse. Making programmers treat too many diverse issues simultaneously leads to increased development costs and opportunities for error. This suggests the need for ways that a developer may specify control requirements separately from the implementation of functional requirements, but then have this information used automatically when building the component executables. The result is an environment where programmers have increased flexibility in composing software modules into concurrent applications, and in reusing those same modules. This paper describes our research toward a technology for control integration, where we have developed techniques for users to express control objectives for an application and a system that translates those specifications for use in packaging executables.
A semantics for ML concurrency primitives
Authors: Dave Berry, Robin Milner, David N. Turner
Venue: Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1992)

We present a set of concurrency primitives for Standard ML. We define these by giving the transitional semantics of a simple language. We prove that our semantics preserves the expected behaviour of sequential programs. We also show that we can define stores as processes, such that the representation has the same behaviour as a direct definition. These proofs are the first steps towards integrating our semantics with the full definition of Standard ML.
Soviet high-speed computers: the new generation
Authors: Peter Wolcott, Seymour E. Goodman
Venue: Proceedings of the 1990 ACM/IEEE conference on Supercomputing (1990)

In the past three years several new Soviet high performance computers have been announced and a number of earlier models have been approved for series production. These models represent the most innovative computer design work in the USSR. Some of the technical characteristics of these machines are reviewed. The perestroika reforms provide hope that traditional difficulties in production will be overcome. However, developments to date indicate that the reforms have not greatly helped, and in many cases have harmed, the high performance computing industry.
PX: Supporting Voice in Workstations
Authors: Ragui Kamel, Kamyar Emami, Robert Eckert
Venue: Computer (1990)

The Personal Exchange (PX) research project, which explores an architecture to provide personal workstation users with dexterity in manipulating voice, is discussed. PX concepts and an initial implementation of the architecture are described. Both the hardware (workstation, telephone, circuit server, and workstation adaptor) and software (call-processing toolkit, voice-storage toolkit, voice-processing toolkits, and PX voice editor) are examined.
Branch Strategies: Modeling and Optimization (Pipeline Processing)
Authors: Pradeep K. Dubey, Michael J. Flynn
Venue: IEEE Transactions on Computers (1991)

The authors provide a common platform for modeling different schemes for reducing the branch-delay penalty in pipelined processors as well as evaluating the associated increased instruction bandwidth. Their objective is twofold: to develop a model for different approaches to the branch problem and to help select an optimal strategy after taking into account additional i-traffic generation by branch strategies. The model presented provides a flexible tool for comparing different branch strategies in terms of the reduction it offers in average branch delay and also in terms of the associated cost of wasted instruction fetches. This additional criterion turns out to be a valuable consideration in choosing between two strategies that perform almost equally. More importantly, it provides a better insight into the expected overall system performance. Simple compiler-support-based low-implementation-cost strategies can be very effective under certain conditions. An active branch prediction scheme based on loop buffers can be as competitive as a branch-target-buffer based strategy.
Incidence and nearest-neighbor problems for lines in 3-space
Authors: Marco Pellegrini
Venue: Proceedings of the eighth annual symposium on Computational geometry (1992)

In the first part of the paper we solve the problem of detecting efficiently if a query simplex is collison-free among polyhedral obstacles. In order to solve this problem we develop new on-line data structures to detect intersections of query halfplanes with sets of lines and segments. In the second part we consider the nearest-neighbor problems. Given a set of n lines in 3-space, the shortest vertical segment between any pair of lines is found in randomized expected time O(n8/5+&egr;) for every &egr; > 0. The longest connecting vertical segment is found in time O(n4/3+&egr;). The shortest connecting segment is found in time O(n5/3+&egr;).
A study of time warp rollback mechanisms
Authors: Yi-Bing Lin, Edward D. Lazowska
Venue: ACM Transactions on Modeling and Computer Simulation (TOMACS) (1991)

The Time Warp &ldquo;optimistic&rdquo; approach is one of the most important parallel simulation protocols. Time Warp synchronizes processes via rollback. The original rollback mechanism called lazy cancellation has aroused great interest. This paper studies these rollback mechanisms. The general tradeoffs between aggressive and lazy cancellation are discussed, and by a conservitive-optimal simulation is defined for comparitive purposes. Within the framework of aggressive cancellation, we offer some observations and analyze the rollback behavior of tandom systems. The lazy cancellation mechanism iss examined using a metric called the sensitivity of output message. Both aggressive and lazy cancellation are shown to work well for a process with a small simulated load intensity. Finally, an analytical model is given to analyze message preemtion, an important factor that affects the performance of rollback mechanisms. Results indicate that message preemtion has a significant effect on performance when (1) the processor is highly utilized, (2) the execution times of messages have high varience, and (3) rollbacks occur frequently.
Automatic acquisition of subcategorization frames from tagged text
Authors: Michael R. Brent, Robert C. Berwick
Venue: Proceedings of the workshop on Speech and Natural Language (1991)

This paper describes an implemented program that takes a tagged text corpus and generates a partial list of the subcategorization frames in which each verb occurs. The completeness of the output list increases monotonically with the total occurrences of each verb in the training corpus. False positive rates are one to three percent. Five subcategorization frames are currently detected and we foresee no impediment to detecting many more. Ultimately, we expect to provide a large subcategorization dictionary to the NLP community and to train dictionaries for specific corpora.
Nuclear power plant diagnostics in APL
Authors: Alexander O. Skomorokhov
Venue: ACM SIGAPL APL Quote Quad (1991)

We are interested in the development of Nuclear Power Plant (NPP) diagnostic systems and other complex systems of data processing. There are some questions on the subject:How to build these systems easily?How to build them fast?How to build them at a low price?And how to build them to be user friendly?Today, from our point of view, in the area of Nuclear Power Plant diagnostics, there is only one answer to these questions: We must use APL.
Term position ranking: some new test results
Authors: E. Michael Keen
Venue: Proceedings of the 15th annual international ACM SIGIR conference on Research and development in information retrieval (1992)

Presents seven sets of laboratory results testing variables in term position ranking which produce a phrase effect by weighting the distance between proximate terms. Results of the 73 tests conducted by this project are included, covering variant term position algorithms, sentence boundaries, stopword counting, every pairs testing, field selection, and combinations of algorithm including collection frequency, record frequency and searcher weighted. The discussion includes the results of tests by Fagan and by Croft, the need for term stemming, proximity as a precision device, comparisons with Boolean, and the quality of test collections.
Logic synthesis for programmable gate arrays
Authors: Rajeev Murgai, Yoshihito Nishizaki, Narendra Shenoy, Robert K. Brayton, Alberto Sangiovanni-Vincentelli
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

The problem of combinational logic synthesis is addressed for two interesting and popular classes of programmable gate array architectures: table-look-up and multiplexor-based. The constraints imposed by some of these architectures require new algorithms for minimization of the number of basic blocks of the target architecture, taking into account the wiring resources.
Fundamentals of Deductive Program Synthesis
Authors: Zohar Manna, Richard Waldinger
Venue: IEEE Transactions on Software Engineering (1992)

An informal tutorial for program synthesis is presented, with an emphasis on deductive methods. According to this approach, to construct a program meeting a given specification, the authors prove the existence of an object meeting the specified conditions. The proof is restricted to be sufficiently constructive, in the sense that, in establishing the existence of the desired output, the proof is forced to indicate a computational method for finding it. That method becomes the basis for a program that can be extracted from the proof. The exposition is based on the deductive-tableau system, a theorem-proving framework particularly suitable for program synthesis. The system includes a nonclausal resolution rule, facilities for reasoning about equality, and a well-founded induction rule.
Tool for making programs more readable
Authors: Mouloud Arab
Venue: ACM SIGCSE Bulletin (1991)

Until recently, the researchers in the C.R.I.S.S Research Center dealing particularly with teaching beginners the writing of Pascal programs meet some problems concerning the presentation of the programs. The Pascal language is a structured one, the teachers wants to provide a model of the presentation of the Pascal program which facilites the correction and make the program readable by other programers. We propose an automatic formatting programs for responding to this aim. Results have been positive. The students produce organized programs and the presentation provided helps the students in the detection of bad constructs and the teachers in having a readable programs which are presented in the same way by the students.
On the expressive power of the relational calculus with arithmetic constraints (extended abstract)
Authors: Gabriel M. Kuper
Venue: Proceedings of the third international conference on database theory on Database theory (1990)

We investigate the expressive power of the relational calculus with arithmetic constraints. We show that any generic query in this language is equivalent to some query in the standard relational calculus. As a result, transitive closure and parity cannot be expressed even with arithmetic constraints.
An Algorithm for the Computation of Binary Logarithms
Authors: Demetrios K. Kostopoulos
Venue: IEEE Transactions on Computers (1991)

The author presents a simple algorithm for the computation of the base-2 logarithm of a given binary number. The concept can be easily extended to base-N. Unlike other methods, this is not a curve fitting of the base-2 logarithm of a given binary number. The algorithm constitutes a simple step-by-step, bit-by-bit, computation of the logarithm of binary numbers. It can be easily implemented in simple microcode, and offers precision that is proportional to the number of performed iterations. Thus, it asymptotically converges to the true logarithm of the given number.
Algorithms for scalable synchronization on shared-memory multiprocessors
Authors: John M. Mellor-Crummey, Michael L. Scott
Venue: ACM Transactions on Computer Systems (TOCS) (1991)

Busy-wait techniques are heavily used for mutual exclusion and barrier synchronization in shared-memory parallel programs. Unfortunately, typical implementations of busy-waiting tend to produce large amounts of memory and interconnect contention, introducing performance bottlenecks that become markedly more pronounced as applications scale. We argue that this problem is not fundamental, and that one can in fact construct busy-wait synchronization algorithms that induce no memory or interconnect contention. The key to these algorithms is for every processor to spin on separate locally-accessible flag variables, and for some other processor to terminate the spin with a single remote write operation at an appropriate time. Flag variables may be locally-accessible as a result of coherent caching, or by virtue of allocation in the local portion of physically distributed shared memory. We present a new scalable algorithm for spin locks that generates 0(1) remote references per lock acquisition, independent of the number of processors attempting to acquire the lock. Our algorithm provides reasonable latency in the absence of contention, requires only a constant amount of space per lock, and requires no hardware support other than a swap-with-memory instruction. We also present a new scalable barrier algorithm that generates 0(1) remote references per processor reaching the barrier, and observe that two previously-known barriers can likewise be cast in a form that spins only on locally-accessible flag variables. None of these barrier algorithms requires hardware support beyond the usual atomicity of memory reads and writes. We compare the performance of our scalable algorithms with other software approaches to busy-wait synchronization on both a Sequent Symmetry and a BBN Butterfly. Our principal conclusion is that contention due to synchronization need not be a problem in large-scale shared-memory multiprocessors. The existence of scalable algorithms greatly weakens the case for costly special-purpose hardware support for synchronization, and provides a case against so-called &ldquo;dance hall&rdquo; architectures, in which shared memory locations are equally far from all processors. &mdash;From the Authors' Abstract
Fragmenting Relations Horizontally Using a Knowledge-Based Approach
Authors: Dong-Guk Shin, Keki B. Irani
Venue: IEEE Transactions on Software Engineering (1991)

In distributed DBMSs, one major issue in developing a horizontal fragmentation technique is what criteria to use to guide the fragmentation. The authors propose to use, in addition to typical user queries, particular knowledge about the data itself. Use of this knowledge allows revision of typical user queries into more precise forms. The revised query expressions produce better estimations of user reference clusters to the database than the original query expressions. The estimated user reference clusters form a basis to partition relations horizontally. In the proposed approach, an ordinary many-sorted language is extended to represent the queries and knowledge compatibly. This knowledge is identified in terms of five axiom schemata. An inference procedure is developed to apply the knowledge to the queries deductively.
Camera Calibration: A Quick and Easy Way to Determine the Scale Factor
Authors: Michael A. Penna
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1991)

The author presents a quick and easy solution to the camera calibration problem of finding the scale factor that arises because of a difference between the scanning frequency of the camera sensor plane and the scanning frequency of the image capture board frame buffer. The method presented is based on the observation that the scale factor is related to the distortion in an image of a circle: this is a distortion that can easily be measured by considering the occluding boundary of a precisely fabricated sphere, such as a ball bearing. Implementation results are presented.
NES: the behavioral model for the formal semantics of a hardware design language UDL/I
Authors: Nagisa Ishiura, Hiroto Yasuura, Shuzo Yajima
Venue: Proceedings of the 27th ACM/IEEE Design Automation Conference (1991)

This paper describes a new behavioral model of hardware, named NES (Nondeterministic Event Sequence) model, which was developed for the purpose of defining formal semantics of the gate level and the register transfer level hardware description languages. The NES model is a generalization of the event driven simulation, and can be a basis of synthesis and verification as well as simulation. We introduce basic concepts, formal definition, and a description method of the NES model.
Extraction of Straight Lines in Aerial Images
Authors: V. Venkateswar, Rama Chellappa
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1992)

A straight-line extractor that produces line descriptions from aerial images is described. The input to the line extractor is in the form of an edge image, where the contrast and direction of each edge pixel is specified. The system scans the edge image left to right and top to bottom and assigns a line label for each scanned edge pixel, thereby generating a label image. At the end of this process, each edge pixel has a line label associated with it, and edge pixels that belong to the same line will be assigned the same line label. In addition, with each line label, a record that stores the end points, the average contrast, and the pixel support of the line is generated. The label image is used as a spatial index to further link fragmented lines. The authors also describe techniques for eliminating many of the physically insignificant lines, given that the domain of interpretation is aerial images dominated by man-made objects.