Large scale scientific computing necessitates finding a way to match the high level understanding of how a problem can be solved with the details of its computation in a processing environment organized as networks of processors. Effective utilization of parallel architectures can then be achieved by using formal methods to describe both computations and computational organizations within these networks. By returning to the mathematical treatment of a problem as a high level numerical algorithm we can express it as an algorithmic formalism that captures the inherent parallelism of the computation. We then give a meta description of an architecture followed by the use of transformational techniques to convert the high level description into a program that utilizes the architecture effectively. The hope is that one formalism can be used to describe both computations as well as architectures and that a methodology for automatically transforming computations can be developed. The formalism and methodology presented in the paper is a first step toward the ambitious goals described above. It uses a theory of arrays, the Psi calculus, as the formalism, and two levels of conversions—one for simplification and another for data mapping.

Nial is a programming language designed around a mathematical treatment of data as nested arrays. A goal of the research described is to integrate within Nial a functional style of programming based on the theory of arrays with the declarative capabilities of a logic programming environment. This is partially accomplished by storing logic clauses as arrays which can be manipulated using logic clauses. Arrays as terms are considered as part of the syntax of the clauses. The approach to logic programming is based on providing a flexible environment for experimenting with full clausal or Horn clause logic. A variety of predefined control strategies and the capability for user-defined control strategies have been provided. The expressive capabilities of combining logic and functional programming styles provides a suitable language for many application areas. The philosophy and design behind a combined logic/database model used to prototype a knowledge-based systems application are described.>

Abstract The Q'Nial interpreter combines ideas from APL and Lisp implementations to provide a rich programming environment that supports several paradigms of programming. The interpreter is structured to reflect the division of Nial semantics into levels corresponding to zero‐, first‐and second‐order objects. The paper describes the design of the interpreter, discusses constraints imposed by the desire to achieve portability and comments on what has been learned in building an interpreter in this style.

Most of the recent research on programming languages for education has been centered around the language Logo. In this paper we introduce another candidate language for learning environments, Nial, the nested interactive array language. Nial is a general‐purpose programming language based on a formal theory of mathematics called array theory. This paper introduces Nial as a language for learning programming and developing and using computer‐aided instruction tools. A comparison with Logo is provided to evaluate these two languages in terms of their strengths and weaknesses as programming environments for novice programmers. We also demonstrate that a programming environment can be both simple to leam at the novice level and extendible to a powerful and sophisticated language.

The meaning of "type" in an APL extended to contain nested arrays is discussed. It is shown that "type" is closely related to the variety of empty arrays of the same shape and to the possible fill values needed in the "expand" and "take" functions. Choices for fill functions are systematically presented. They are classified according to the possibility of maintaining important identities involving level-manipulating functions in the case of empty arguments, to their effect on other design choices still to be made (the restriction to homogeneous arrays and the definition of the nature of basic data), and to their ability to express "type" in a natural way.

The subroutine RPOLY is a Fortran program to find all the zeros of a real polynomial.The parameters are: OP double precision vector of coefficients in order of decreasing powers of the variable D E G R E E integer degree of the polynomial ZEROR, double precision vectors of real and imaginary parts of the zeros found ZEROI by the algorithm FAIL logical parameter which is true only if the leading coefficient is zero or if R P O L Y has found fewer than degree zeros; in the latter case the degree is reset to the number of zeros found.The routine as written solves polynomials of degree up to 100; however, this can be modified by systematic changing of the declarations in the routines.The program is based on the three-stage algorithm described in Jenkins and Traub [1].The algorithm generates a sequence of polynomials of degree one less than the degree of the given polynomial from which an approximation to a zero or a quadratic factor can be extracted.The first stage is linearly convergent and involves no shift of origin.It is used primarily to bias the decision making process in the second stage in favor of the zeros of small magnitude.The second stage is also linearly convergent and involves a double shift to a complex point and its conjugate.The shift point is chosen arbitrarily on a circle whose radius is less than the magnitude of all the zeros.In most cases, either the shift is closest to a real zero, or the pair of shift points are equidistant and closest to a pair of zeros.In the former case the second stage yields an approximation to the real zero and in the latter case

The state of the art in polynomial zerofinding algorithms and programs is briefly summarized, with emphasis on the principles for testing such programs.The authors view testing as requiring four stages: (1) testing program robustness, (2) testing for convergence difficulties, (3) testing for specific weakness of the algorithms, (4) assessment of program performance by statistical testing.It is emphasized that the statistical testing must be done with care.There are many ways to generate "random" polynomials, b r t two classes of random polynomials which have been widely used are of only limited usefulness in terms of evaluating reliability or performance because they produce polynomials with very similar characteristics.Classes of random polynomials which should be used are discussed.

Bernoulli methods are reviewed in terms of matrix eigenvalue techniques applied to the companion matrix of a polynomial.Inverse iteration gives rise to two implicit-shift algorithms when apphed to the companion matrix and to its transpose.The first is the algorithm of Jenkins and Traub; the second is a new form which is a direct extension of the Bernoulli recurrence.Equivalence theorems for the two algorithms are given and the computational aspects of the latter algorithm are discussed.