This paper deals with the use of APL to solve matrix theory problems with elements that are members of an integral domain. Two types of integral domains are used to illustrate the methods developed in this paper, inte...
详细信息
ISBN:
(纸本)0897914775
This paper deals with the use of APL to solve matrix theory problems with elements that are members of an integral domain. Two types of integral domains are used to illustrate the methods developed in this paper, integers (Z) and polynomials with real coefficients (Re[X]). However, the method of approach can be easily generalized to include other integral domains. APL2, due to its generalized data representations and rich functional semantics, was chosen to implement the solution to this problem. For each integral domain presented, a method of data representation is developed, and implementations of the necessary `primitive' functions (Addition, Multiplication, Division, and Comparison) are given. Finally, this newly developed system of functions and data representation is used to solve several of the most common Matrix Algebra problems. A simple recursive determinant and an implementation of Euclid's Greatest Common Divisor Algorithm are presented. Then, with these building blocks, a general algorithm for finding Smith's Canonical form and an algorithm to find the Invariant Factors are presented.
The proceedings contain 23 papers. The special focus in this conference is on Object-Oriented programming. The topics include: On unifying relational and object-oriented database systems;import is not inheritance why ...
ISBN:
(纸本)9783540556688
The proceedings contain 23 papers. The special focus in this conference is on Object-Oriented programming. The topics include: On unifying relational and object-oriented database systems;import is not inheritance why we need both: modules and classes;object-oriented multi-methods in cecil;aggregation in a behavior oriented object model;reasoning and refinement in object-oriented specification languages;combining object-oriented and logic paradigms: a modal logic programming approach;an incremental class reorganization approach;system design by composing structures of interacting objects;unifying the design and implementation of user interfaces through the object paradigm;nesting actions through asynchronous message passing;inheritance of synchronization constraints in concurrent object-oriented programminglanguages;an eiffel environment to program distributed memory parallel computers;using object-oriented programming techniques for implementing ISDN supplementary services;an object model for engineering design;an object-oriented class library for scalable parallel heuristic search;integrating constraints with an object-oriented language;specifying reusable components using contracts;a type system for object-oriented programming based on abstract and concrete classes;making type inference practical;an object-oriented language-database integration model: the composition-filters approach;supporting physical independence in an object database server and developing a class hierarchy for object-oriented transaction processing.
The proceedings contain 26 papers. The topics discussed include: Ada and high performance computing - reality or myth?;the software development plan: a key to achieve SEI capability maturity model compliance;Ada and m...
ISBN:
(纸本)0897914872
The proceedings contain 26 papers. The topics discussed include: Ada and high performance computing - reality or myth?;the software development plan: a key to achieve SEI capability maturity model compliance;Ada and management information systems;reuse library interoperability: bringing the concept into reality;object oriented requirements analysis for a model Ada runtime system;application at statistical process control to the software process;developer-assisted automation for Ada design generation;techniques for semi-automated implementation of state-oriented, real-time formal specifications in Ada;software engineering environment framework evaluation method: three examples;a role for iterators as a tool for software reuse;information systems modeling: an object oriented development method;managing software technology for corporate information management;management of the design and implementation of a large-scale Ada CSC1 using an automated scheduling tool;use of the software capability evaluation in the FAA's microwave landing system procurement;object oriented requirements analysis vs. structured analysis as a front end for object oriented design;and an experiment with financial incentives for a small software development team.
This paper describes EQUALS, a fast parallel implementation of a lazy functional language on a commercially available shared-memory parallel machine, the Sequent Symmetry. In contrast to previous implementations, we d...
ISBN:
(纸本)9780897914819
This paper describes EQUALS, a fast parallel implementation of a lazy functional language on a commercially available shared-memory parallel machine, the Sequent Symmetry. In contrast to previous implementations, we detect parallelism automatically by propagating exhaustive (normal form) demand. Another important difference between EQUALS and previous implementations is the use of reference counting for memory management instead of garbage collection. Our implementation shows that reference counting leads to very good scalability, low memory requirements and improved locality. We compare our results with sequntial SML/NJ as well as parallel (v, G-machine and GAML implementations.
HoME is a version of Smalltalk which can be efficiently executed on a multiprocessor and can be executed in parallel by combining a Smalltalk process with a Mach thread and executing the process on the thread. HoME is...
ISBN:
(纸本)9780897914758
HoME is a version of Smalltalk which can be efficiently executed on a multiprocessor and can be executed in parallel by combining a Smalltalk process with a Mach thread and executing the process on the thread. HoME is nearly the same as ordinary Smalltalk except that multiple processes may execute in parallel. Thus, almost all applications running on ordinary Smalltalk can be executed on HoME without changes in their *** was designed and implemented based on the following fundamental policies: (1) theoretically, an infinite number of processes can become active; (2) the moment a process is scheduled, it becomes active; (3) no process switching occurs; (4) HoME is equivalent to ordinary Smalltalk except for the previous three *** performance of the current implementation of HoME running on OMRON LUNA-88K, which had four processors, was measured by benchmarks which execute in parallel with multiple processes. In all benchmarks, the results showed that HoME's performance is much better than HPS on the same workstation.
This paper reports on the results of a survey of user interface programming. The survey was widely distributed, and we received 74 responses. The results show that in today's applications, an average of 48% of the...
详细信息
ISBN:
(纸本)9780897915137
This paper reports on the results of a survey of user interface programming. The survey was widely distributed, and we received 74 responses. The results show that in today's applications, an average of 48% of the code is devoted to the user interface portion. The average time spent on the user interface portion is 45% during the design phase, 50% during the implementation phase, and 37% during the maintenance phase, 34% of the systems were implemented using a toolkit, 27% used a UIMS, 14% used an interface builder, and 26% used no tools. The projects using only toolkits spent the largest percentage of the time and code on the user interface (around 60%) compared to around 45% for those with no tools. This appears to be because the toolkit systems had more sophisticated user interfaces. The projects using UIMSs or interface builders spent the least percent of time and code on the user interface (around 41%) suggesting that these tools are effective. In general, people were happy with the tools they used, especially the graphical interface builders. The most common problems people reported when developing a user interface included getting users' requirements, writing help text, achieving consistency, learning how to use the tools, getting acceptable performance, and communicating among various parts of the program.
The proceedings contain 28 papers. The topics discussed include: efficient and exact data dependence analysis;practical dependence testing;a data locality optimizing algorithm;CCG: a prototype coagulating code generat...
ISBN:
(纸本)0897914287
The proceedings contain 28 papers. The topics discussed include: efficient and exact data dependence analysis;practical dependence testing;a data locality optimizing algorithm;CCG: a prototype coagulating code generator;predicting program behavior using real or estimated profiles;procedure merging with instruction caches;strictness and binding-time analyses: two for the price of one;parameterized partial evaluation;the semantic approach to program slicing;automatic generation of global optimizers;size and access inference for data-parallel programs;and Fortran at ten gigaflops: the connection machine convolution compiler.
We consider the problem of supporting compacting garbage collection in the presence of modern compiler optimizations. Since our collector may move any heap object, it must accurately locate, follow, and update all poi...
ISBN:
(纸本)9780897914758
We consider the problem of supporting compacting garbage collection in the presence of modern compiler optimizations. Since our collector may move any heap object, it must accurately locate, follow, and update all pointers and values derived from pointers. To assist the collector, we extend the compiler to emit tables describing live pointers, and values derived from pointers, at each program location where collection may occur. Significant results include identification of a number of problems posed by optimizations, solutions to those problems, a working compiler, and experimental data concerning table sizes, table compression, and time overhead of decoding tables during collection. While gc support can affect the code produced, our sample programs show no significant changes, the table sizes are a modest fraction of the size of the optimized code, and stack tracing is a small fraction of total gc time. Since the compiler enhancements are also modest, we conclude that the approach is practical.
The authors report their design and implementation of a new self-scheduling parallel programminglanguage, SELSYN-C. Their approach to the challenge of parallel programminglanguagedesign and implementation is two-fo...
详细信息
The authors report their design and implementation of a new self-scheduling parallel programminglanguage, SELSYN-C. Their approach to the challenge of parallel programminglanguagedesign and implementation is two-fold: (1) the design of simple extensions to C that are both easy to use, and useful for effective compilation, and (2) the design of efficient and effective scheduling strategies that can be automatically supported by a compiler and associated run-time environment.< >
The design and implementation of Distributed Eiffel, a languagedesigned and implemented for distributed programming, on top of the Clouds operating system by extending the object-oriented language Eiffel are discusse...
详细信息
The design and implementation of Distributed Eiffel, a languagedesigned and implemented for distributed programming, on top of the Clouds operating system by extending the object-oriented language Eiffel are discussed. The language presents a programming paradigm based on objects of multiple granularity. While large-grained persistent objects serve as units of distribution, fine-grained objects are used to describe and manipulate entities within these units. The languagedesign makes it possible to implement both shared-memory and message-passing models of parallel programming within a single programming paradigm. The language provides features with which the programmer can declaratively fine-tune synchronization at any desired object granularity and maximize concurrency. With the primitives provided, it is possible to combine and control both data migration and computation migration effectively, at the language level. The design addresses such issues as parameter passing, asynchronous invocations and result claiming, and concurrency control.< >
暂无评论