J. K. Reid

Co-array Fortran for parallel programming

Co-Array Fortran, formerly known as F--, is a small extension of Fortran 95 for parallel processing. A Co-Array Fortran program is interpreted as if it were replicated a number of times and all copies were executed asynchronously. Each copy has its own set of data objects and is termed an image. The array syntax of Fortran 95 is extended with additional trailing subscripts in square brackets to give a clear and straightforward representation of any access to data that is spread across images.References without square brackets are to local data, so code that can run independently is uncluttered. Only where there are square brackets, or where there is a procedure call and the procedure contains square brackets, is communication between images involved.There are intrinsic procedures to synchronize images, return the number of images, and return the index of the current image.We introduce the extension; give examples to illustrate how clear, powerful, and flexible it can be; and provide a technical definition.

A practicable steepest-edge simplex algorithm

It is shown that suitable recurrences may be used in order to implement in practice the steepest-edge simplex linear programming algorithm. In this algorithm each iteration is along an edge of the polytope of feasible solutions on which the objective function decreases most rapidly with respect to distance in the space of all the variables. Results of computer comparisons on medium-scale problems indicate that the resulting algorithm requires less iterations but about the same overall time as the algorithm of Harris [8], which may be regarded as approximating the steepest-edge algorithm. Both show a worthwhile advantage over the standard algorithm.

Fortran 90 explained

Whither fortran? language elements expressions and assignments control statements program units and procedures array features specification statements intrinsic procedures data transfer operations on external files depracated features.

An Implementation of Tarjan's Algorithm for the Block Triangularization of a Matrix

An implementation of Tarj ans algorithm for symmetrically permuting a given matrix to block tmangular form is described. The discussion includes a flowchart of the algorithm, a complexity analysis, and a comparison with the earlier widely used algorithm of Sargent and Westerberg. T~ming results are presented from several experiments using the code developed by the authors.

The Multifrontal Solution of Unsymmetric Sets of Linear Equations

We show that general sparse sets of linear equations whose pattern is symmetric (or nearly so) can be solved efficiently by a multifrontal technique. The main advantages are that the analysis time is small compared to the factorization time and that analysis can be performed in a predictable amount of storage. Additionally, there is scope for extra performance during factorization and solution on a vector or parallel machine. We show performance figures for examples run on the IBM 3081K and CRAY-1 computers.

A SPARSITY-EXPLOITING VARIANT OF THE BARTELS-GOLUB DECOMPOSITION FOR LINEAR PROGRAMMING BASES

We describe a sparsity-exploiting variant of the Bartels—Golub decomposition for linear programming bases. It includes interchanges that, whenever this is possible, avoid the use of any eliminations (with consequent fill-ins) when revising the factorization at an iteration. Test results on some medium scale problems are presented and comparisons made with the algorithm of Forrest and Tomlin.

Algorithm 891: A Fortran virtual memory system

Fortran_Virtual_Memory is a Fortran 95 package that provides facilities for reading from and writing to direct-access files. A buffer is used to avoid actual input/output operations whenever possible. The data may be spread over many files and for very large data sets these may be held on more than one device. We describe the design of Fortran_Virtual_Memory and comment on its use within an out-of-core sparse direct solver.

Some Design Features of a Sparse Matrix Code

has been used either as a stand-alone subroutine or within larger programming packages in many centers throughout the world. Although most users have been very pleased with the performance of these subroutines they have criticized them because (i) they are not easily portable since they use facilities peculiar to the IBM 360/370 series (although some improvements have been made since the original version), (ii) the data interface is not very convenient for the user, particularly when providing a matrix with nonzero pattern identical to one already treated, (iii) the initial decomposition phase is slow when the factorized form has more than a very small average number of nonzeros per row, and (iv) some improvement can be made to the speed of the final solution phase. Since the summer of 1975, the authors have been discussing ways of overcoming these problems and otherwise improving the performance and flexibility of the code; our purpose here is to explain the decisions we have reached. Perhaps our easiest decision was to use standard Fortran for the new code, checking it with

The Use of Conjugate Gradients for Systems of Linear Equations Possessing “Property A”

It is shown that for systems possessing Young’s “Property A” [7] the work in applying the conjugate gradients algorithm [3] may be approximately halved and a vector of storage may be saved by using a technique analogous to that of Golub and Varga [2] for Chebyshev semi-iteration. We illustrate by numerical results on two test problems, and comment on the advantages of the algorithm over successive overrelaxation and Chebyshev semi-iteration.

The design of MA48: a code for the direct solution of sparse unsymmetric linear systems of equations

We describe the design of a new code for the direct solution of sparse unsymmetric linear systems of equations. The new code utilizes a novel restructuring of the symbolic and numerical phases, which increases speed and saves storage without sacrifice of numerical stability. Other features include switching to full-matrix processing in all phases of the computation enabling the use of all three levels of BLAS, treatment of rectangular or rank-deficient matrices, partial factorization, and integrated facilities for iterative refinement and error estimation.