ARDA: expert system for reliability data analysis

The paper explores the design and implementation of ARDA, an Expert System to analyse Reliability Data. Initially the viability of the knowledge domain is explored. The philosophy of design of the system is discussed. Details of the implementation are described. There is discussion of extension of system to other statistical analyses and of using alternative inferential bases.

[Full Text in PDF Format, 348 KB]

Array morphology

Array morphology is the study of the form, structure, and evolution of arrays. An array annotation for a program written in an applicative array language is an abstract syntax tree for the program, amended with information about the arrays created by that program. Array notations are useful in the production of efficient compiled code for applicative array programs. Array morphology is shown to be an effective compiler writer’s tool. Examples of an array annotator in action are presented, showing its value in array morphology, Array morphology is shown to provide methods for static detection of certain classes of programming errors.

Assertions are a generalization of declarations that offer significant benefits to application writers as well as compiler writers. Although assertions are executable code, they can often be evaluated at compilation time. Assertions, and therefore declarations, may be represented as conjunctions, and are, therefore, conforming extensions to ISO Standard APL. A domain conjunction is offered as an example of how assertions might be defined in APL or J.

[Full Text in PDF Format, 993 KB]

The role of APL and J in high-performance computation

Although multicomputers are becoming feasible for solving large problems, they are difficult to program: Extraction of parallelism from scalar languages is possible, but limited. Parallelism in algorithm design is difficult for those who think in von Neumann terms. Portability of programs and programming skills can only be achieved by hiding the underlying machine architecture from the user, yet this may impact performance on a specific host. APL, J, and other applicative array languages with adequately rich semantics can do much to solve these problems. The paper discusses the value of abstraction and semantic richness, performance issues, portability, potential degree of parallelism, data distribution, process creation, communication and synchronization, frequency of program faults, and clarity of expression. The BLAS are used as a basis for comparison with traditional supercomputing languages.

[Full Text in PDF Format, 1579 KB]

Approaching classical algorithms in APL2

Classical algorithms and data structures as made popular by D.E. Knuth’s "The Art of Computer Programming have been largely ignored so far by APL2-programmers. This scepsis was understandable to a certain degree in the era of APL, but has lost its justification with the rise of APL2 and similar APL-successors. First the essence of classical algorithms as well as the principal ways of data structuring and accessing are reexamined. Then it is shown how pseudocode or implementations of classical algorithms can be transfered one-to-one into APL2 almost automatically and often with an acceptable resulting performance. But, in general, the better way consists in maintaining only the general design principle behind a classical algorithm and combining it with the elegant and ei%cient specific possibilities of APL2. Both approaches are explained and illustrated by means of a typical classical algorithm from picture processing.

[Full Text in PDF Format, 611 KB]

Extending the APL character set

APL, is often presented as a notation that is independent of national language because of its symbolic nature. Paridoxically its unique character set has led APL to being treated as if it were itself a national language. This has meant, in many practical situations that the APL character set is incompatiblc with national language character sets.

IBM's APL2 attempted to avoid these problems by defining a set of extended (31 bit) characters, and this has indeed been helpful in handling Asian languages such Kanji. But the character mappings adopted have not been adequated to support all European and Middle Eastern language characters, nor have they been consistent across platforms.

With the advent of international standards for character assigment, there is an opportunity to create APL systems that handle the character sets of the world in an efficient and elegant manner. While at first the solution appears to require only a recitation of code point assigmnents, an analysis of the problem leads to intersteing and disturbing questions about a number of APL system functions, system variables, commands, and file facilities. This paper explores problems with internal conversions, external representations, migration, compatibility, and interplatform portability.

[Full Text in PDF Format, 492 KB]

SCARFS, an efficient polynomial zero-finder system

Programs in SCARFS makes a top-down search for zeros which are leaves in a polynomial tree, in which internal nodes represent clusters of high symmetry. Using new schemes for multiplicity estimation and iterate repositioning upon local rebounds by clusters, zeros are found one at a time with deflation in between. For arbitrary polynomials, a zero usually is found in fewer than 10 complex arithmetic iterations, showing significant gain in accuracy and speed over prior methods.

[Full Text in PDF Format, 605 KB]

The testing of an APL compiler

The testing of the APL-to-C compiler, COMPC, developed at the IBM TJ. Watson Research Center consists of two components: a testing suite of 140 APL programs collected from various sources covering a variety of fields, and a unit-testing procedure which tests each primitive function on all possible subcases arising from different combinations of storage types and shapes. The second component, unit-testing, is an interesting example of the productivity APL, can provide for software development. The unit-testing procedure is based on a workspace written in APL, and utilizes the []FX freature of APL, to dynamically create a test function from onc of several templates. The running of both testing components is automated through the use of control programs written in the REXX procedures language under the VM/CMS operating system,

[Full Text in PDF Format, 779 KB]

APL helps the deaf to hear again

This paper describes the role of APL as an efllcient and crucial tool in research and development of sophisticated electronic systems. It will show how APL was successfully used in the development of a cochlear implant device. Coehlear implants are bio-medical electronic systems allowing completely deaf persons to recover partial hearing capabilities. This kind of system has been around for some time. Unfortunately, performance and flexibility have improved at a slow pace. Also, a more in-depth scientific understanding and testing were required. We will begin with an overview of the system itself, followed by the important role of APL as a time-saver and flexible tool, present some details on the APL programs and conclude with future directions for this technology.

[Full Text in PDF Format, 578 KB]

Structuring functions with operators

Flow control for APL functions is limited to the simple GOTO facility supplied by the -> arrow. Numerous papers have suggested enhancements to APL which provide flow control structures. This paper investigates to the extent to which control structures can be implemented in APL solely by means of features that already exist in the language, specifically by the use of primitive or defined operators. The exercise offers both a means to improve the quality of APL code and also affords an insight into the use of operators and their limitations. The paper assumes the use of APL2 or other compatible dialects such as APL68000.

[Full Text in PDF Format, 592 KB]

Confessions of two APL educators learning J

This paper reports how we, two university teachers of APL, began to learn J. By presenting accounts of a series of small experiments, it reveals our understandings and misunderstandings along the way. It discusses things we especially liked and disliked about J as well as the resources available for learning it, and it indicates some implications of our experience for teaching J.

[Full Text in PDF Format, 990 KB]

A modern APL windows user interface with DOS downwards compatibility: the solution for two years onwards

Windows 3.1 represents the biggest revolution to APL technology since the advent of full screen techniques. This creates a new challenge to APLers migrating their applications from mainframe or PC DOS environments into Windows 3.1. This paper describes an ease means to adapt existing and new applications to exploit Windows Graphical User Interfaces (GUI), By using the techniques described below one can utilize most GUI features without needing to comprehend the massive amount of detail typical to Windows programmmg. Additionally, any application will also be backwards compatible to the DOS character based screen interface.

[Full Text in PDF Format, 798 KB]

A parallel topological feature map in APL

One can distinguish two different approaches of neural networks the supervised networks and the self organizing or unsupervised neural networks. The first type of neural nets is supplied with an ideal result regarding the input. During the learning procedure, the neural net adjusts weighting factors of the links between neurons so that the input feature vectors map to the ideal output. Those nets are usedl for example in robotics, where the ideal result is well known: it is the position the robot should be placed in. For the cases where no ideal result is known, the second type of neural nets, the so called self-learning Topological Feature Map (TFM) is appropriate, This paper will introduce such a neural net based on the idea of Kohonen’s TFM. The original algorithm was extreme] y sequential and therefore not suitable for an APL implementation. The parallelization of the algorithm led to important improvements in speed and convergence to the global optimum.

[Full Text in PDF Format, 457 KB]

Talking with an APL via DDE: teaching an old dog new tricks

Shared variables and auxiliary processors are well-known techniques for connecting alien applications to APL. The use of APL in the PC windowing multitasking environment of MS Windows, which incorporates a messaging model for interprocess communications, requires some new approaches to the implementation of shared variable and auxiliary processor support. This paper presents a shared variable interface to MS Windows graphics written in Microsoft C and a simple charting package called TinyPlot written in Dyalog APL for Windows (Dyalog APL/W). The purpose of this paper is to demonstrate and investigate the Dyalog APLIW shared variable and auxiliary processor facilities, and to offer observations and conclusions about the benefits, limitations, and potential of the Dynamic Data Exchange interface generally.

[Full Text in PDF Format, 766 KB]

APROL: a hybrid language

This paper describes the design of a hybrid language which combines the features of an array processing language and lisp dialect in a consistent and useful manner. This language, APROL (Array Processing Lisp) is derived from the J dialect of APL and the Scheme dialect of Lisp. The base syntactic structure is taken from Scheme, while the array processing features are based on the J programming language. A prototype implementation has been made and some experiences with this implementation are described. This implementation uses J as an imbedded array processing engine in a Scheme intrepreter/compiler. The language as specified provides a set of data types and manipulation tools which is more diverse than found in either Scheme or J. APROL allows the programmer to apply array processing functions to lists of arrays in the Scheme style and list processing functions to arrays of lists in typical J style. The result is a language which not only brings array processing capabilities to Scheme, but also significantly extends the functionality of the Scheme language.

[Full Text in PDF Format, 1381 KB]

Extending the two-partner shared variable protocol to n partners

APL as a language has always provided a high level of abstraction to its users. Only in the field of communication have APL channels - called shared variables - been restricted to at most two partners. As most distrilmted applications demand more than two interact-ing programs, APL users had to apply their own techniques like client-server, to develop applications that share information among more than two partners. This paper presents a proposal to move the administration of shared rnernory from application to language level: An extension to the well known shared variable protocol to share memory among more than two partners. Two applications of this distributed shared memory system are presented: A combinatorial optimization problem that is distributed among the machines of a workstation network and an application for students that learn APL in a working group are based upon a prototype implementation of the proposed protocol.

[Full Text in PDF Format, 865 KB]

Building the APL atlas of natural shapes

It was previously shown [1] that APL conrained the most powerful idiom {not-equal}\ that could be used, directly in the language all computers know: binary algebra, to build models as well for physics as for biology and computer science. Several papers on the subject were published or submitted reside the "APL world" as well as outside (Bibliography in [2]). The purpose of the present paper is to show how a classical model, built to generate fractal shapes in plane geometry (2-D) can be revisited and considerably extended, thanks to the properties of {not-equal}\ and of array-oriented binary algebra.

[Full Text in PDF Format, 1042 KB]

Modern algebra self-taught through APL

The study of modern algebra, especially that of finite algebra and its applications to error codes, was aided by the computer, The paper shows how a college student used APL for self-teaching this university-level subject. The approach of self-teaching is presented. It is shown how the learning process can be augmented through the use of APL. Various finite algebra problems and their APL solutions are presented, including error detecting codes and the search for irreducible and primitive polynomials.

[Full Text in PDF Format, 398 KB]

Using defined operators and function arrays to solve non-linear equations in APL2

There are many mathematical algorithms such as Newton’s method used to calculate solutions to non-linear equations. This paper will show how easy it is to implement these algorithms in APL2 with a minimum of code using the defined operator and careful design of its input functions, Although a very powerful and unique approach to solving non-liiear equations using APL was described recently [Ne89], the emphasis in this paper is on the method of developing an application using APL2 and the concepts of defined operators and function arrays. This requires that input functions be robustly designed to take arrays as arguments and to produce array results much like primitive scalar functions. In this manner one can minimize the number of calls to the input function and take advantage of AP 1.,2s ,array handling capabilities. Since operators are permitted at most two oper-ancls, it is critical to minimize the number of input functions. This requires the input function designer to think in terms of function arrays. Whale there has been some discussion of the theory [Be84] and implementation [J3e91 ] of function arrays, they can be created in APL2 with defined operators [Bk85]. In fact, function arrays can easily be defied in standard APL.

[Full Text in PDF Format, 317 KB]

An introduction to log-linear analysis and implementing the Newton-Raphson algorithm in APL2

This paper introduces the method of log-linear analysis for performing hypothesis testing on contingency tables. The reader will see a brief development of this topic beginning with Pearson’s classic chi-square test and examples of analyses on two and three dimensional tables. The idea of hierarchical models and backward elimination we discussed. Finally, the APL2 implementation of the Newton-Raphson algorithm is described. Newton-Raphson is an iterative procedure for finding the roots of a function. It is used in log-linear analysis to find the maximum-likelihood estimation of expected frequencies that cannot be calculated from expressions in closed form.

[Full Text in PDF Format, 278 KB]

Distributed computing in the workstation environment

Exploiting unused processor time in workstation environmmts can result, in large performance gains in user seems feasible. A parallel each operator is shown which implements client-server based distrilmted processing. a time-constraining algorithm is sped up by using idle workstations in a local area network as APL servers.

[Full Text in PDF Format, 557 KB]

Transfinite nesting in array-theoretic figures, changes, rigs, and arms. Part I

Nesting and stemming (infinite successive singling) of arrays of nestings and stemmings result in forms. Forms of Oth-, lst-, 2nd-, or 3rd-order, array-theoretic, totally defined functions are again such functions, called, respectively, figures, changes, rigs, and arms. One arms a rig before rigging a change before changing a figure. Part I lays the foundation for a new approach to a theory of arrays. This Part considers the analogy between array-theoretic and Euclidean figures, analyzes form separately from substance, introduces Nth-order functions, presents the beginnings of a syntax for the theory, and constructs a formal system to deduce the first few consequences of the first two primitive operations.

[Full Text in PDF Format, 1906 KB]

APL programming without tears: -> it is time for a change

To overcome the unreadability of traditional APL-code Knuth’s idea of literate programming is adapted to APL. The APL2WEB system of structured documentation is introduced as a new way of APL-programming. An example is given to highlight the merits of this combination.

[Full Text in PDF Format, 511 KB]

Efficient maximum likelihood estimation of linear models with APL

Maximum likelihood estimators used in statistics and econometrics have desirable properties, however, due to the complexity of their solution maximum likelihood techniques are not widely used. This paper examines an APL implementation of one of the most efficient algorithms used to estimate the parameters of the univariate ARMA process. The straight-forward use of APL is found to be unacceptable and so a systematic search for optimization is made. This search results in au approximate solution for the ML estimator, the use of []NA and FORTRAN, and special matrix techniques to increase the efficiency of the algorithm. The matrix techniques used are implementations of sparse, banded, and block diagonal data structures. Additional marnx techniques involve incremental updating of matrices. The effect of tiese optimization is to bring the computational cost from an O(N*3) problem to an O(N*1) problem. This translates into a significant reduction in computer requirements. For example, to estimate a three parameter ARMA model with 5000 observations, memory requirements fall from approximately 95 megabytes to 300 kilobytes. Computer time falls from about 6.4 years to under 1 minute.

[Full Text in PDF Format, 817 KB]

Roles of APL in satellite surveillance

Roles of APL in satellite surveillance

[Full Text in PDF Format, 894 KB]

Extending APL2 to include program control structures

APL2, and APL before it, have always been criticised for not embodying formal program flow control structures. It is proposed that a set of reserved words be added to the APL2 language. This set could include "if", "else", "while", etc. This extension should enhance performance and improve the readability of programs. This improved readability could lead to more maintainable code.

[Full Text in PDF Format, 397 KB]

Solving two or three polynomials in two or three variables

An algorithm is described that allows two polynomials in two variables to be reduced to a single polynomial in one variable. and then back solved to get all sfits of solutions. The algorithm works faster than most other algorithms within its range of utility (providing sets of solutions as large as 70), and can be extended to cover some sets of 3 polynomials in 3 variables (those where one of the polynomials has only two of the variables). While subject to the known st abiht y problems of polynomial root-finding this algorithm can also be extended to provide fo~ reducing to the single variable polynomial with symbols, thus permitting proof of results, and potential removal of extraneous roots. Such manipulation can then materially shorten the numerical process if the problem is to be applied to a number of different cases.

[Full Text in PDF Format, 456 KB]

Adaptive learning networks in APL2

The paper considers Adaptive Learning Networks (ALN) as a tool to solve the problems of modeling, prediction, diagnostics and pattern recognition in complex systems. This method is similar to the neural network technique. The main difference is the self-organization of network structure on the basis of generation and estimation of various nodes, connections and weights. A set of functions presented in the paper shows that ALNs are easily realizedl in APL2. User-defined operators are used as a very convenient tool for ALN programming. The paper discusses the application of implemented software to the problem of Burnout Heat Flux Prediction in nuclear reactors. It is shown that ALN technique allows the prediction of burnout heat flux with approximately three times better accuracy than other commonly used methods.

[Full Text in PDF Format, 845 KB]

Identification of parallelism in neural networks by simulation with language J.

Neural networks, trained by backpropagation, are designed and described in the language J, an APL derivative with powerful function encapsulation features. Both the languages J [4,6,7] and APL [5] help to identify and isolate the parallelism that is inherent in network training algorithms. Non-criticai details of data input and derived output processes are de-emphasized by relegating those functions to callable stand-alone modules. Such input and output modules can be isolated and customized individually for managing communication with arbitrary, external storage systems. The central objective of this research is the design and precise description of a neural network training kernel. Such kernel designs are valuable for producing efficient reusable computer codes and facilitating the transfer of neural network technology from developers to users.

[Full Text in PDF Format, 575 KB]

Rolling dice: some notes on J and teaching probability

When APL was introduced in the 1960s, the choice of a programming language was usually very simple: one used either APL or Fortran. Now, almost thirty years later, choosing a language is much more difficult, APL must now compete not only with Fortran in one of its several incarnations (the latest being Fortran 90 with Fortran 2000 already being discussed), but with a number of other conventional programming languages such as Pascal, C, Modttla-2 and many readily available versions of BASIC, and also with an increasing number of spreadsheet, statistical and integrated packages. What exactly is the place of APL, and in particular its modem dialect J, in the programming world of the 1990s? One answer has been given by Kenneth Iverson in a recent account of the development of APL [1]: As stated at the outset, the initial motive for developing APL was to provide a tool for writing and teaching. Although APL has been exploited mostly in commercial programming, I continue to believe that its most important use remains to be exploited: as a simple, precise, executable notation for the teaching of a wide range of subjects. If APL, and J, are considered in this way, they then complement, rather than compete with, today’s programming languages and software.

In this paper we shall give a few examples to show how J might be used in a course in elementary probability. In order to give some unity to the paper, all of the examples are concerned with rolling dice; many have been suggested by a recent rereading of Warren Weaver’s delightful little book Lady Luck: The Theory of Probability [8]. As this conference is being held in Toronto, Ontario, described in the Call for Papers as “exciting, vibrant, and cosmopolitan”, it is undoubtedly unnecessary to describe a die although Weaver does precisely this in case, as he says, his book “falls into completely innocent hands”. However, we shall remark that atthough the most customary form of die is a six-sided cube, any of the five regular polyhedra may be used so there may be dice with four, six, eight, twelve and twenty faces, Many of the examples discussed in the paper will be for tetrahedrrd dice wh.h four faces in order to save space when displaying the values of expressions, although the J verbs that are presented are valid for dice with an arbitrary number of faces,

[Full Text in PDF Format, 347 KB]

Co-operative programming with Windows DDE

In the past, APL applications have come mostly in two kinds: one-off investigative developments, and major ‘vertically integrated’ applications. The first kind are usually characterised by a small volume of powerful APL code, precisely targeted towards exploring an interesting business idea. The second kind are typically wrapped around with a great blanket of ‘user’ code, which is all about the entry, validation, and presentation of data.

With the advent of MS Windows (and the inevitable move of the PC community towards Windows applications) we can begin to exploit the inherent power of Word and Excel as providers of much of this user code. This paper begins the exploration, with just two simple ideas: an Excel-based report formatter, and an APL button-bar to add a ‘real’ array language to Excel.

[Full Text in PDF Format, 678 KB]

JVOX

JVOX: A VERBAL USER INTERFACE FOR J

JVOX is an experimental verbal user interface for learning and working with J. Not long ago, one of us was flipping through the Dictionary of J trying to find out how to spell some already familiar concepts. A question arose, Couldn’t one just say J out loud and have the computer provide the correct spelling?

The answer is a resounding yes, Since then, a prototype has been implemented on an Apple

Macintosh computer. Initial experiments have been successful, and a few preliminary extensions suggest that there is a bright future for a verbal user interface to J.

[Full Text in PDF Format, 711 KB]

Point-wise calculus

The work of Richard Neidinger implementing automatic differentiation in APL as a vector arithmetic is reformulated and extended. For functions of a single variable, an arithmetic is developed for function samples, nested vectors whose components hold the values, at any number of gjven sample points, of a function and its derivatives up to any specified order. It is argued that, for teaching purposes, this sampling provides a more intuitive introduction to mathematical functions and the rules of calculus than do algebraic formulae and that for certain calculations (such as the computation of polynomial approximations of high degree) the formulation provides superior algorithms for computation, As such, it offers an alternative approach to the teaching of elementary college mathematics.

[Full Text in PDF Format, 580 KB]

From trees into boxes

This paper is a progress report on work undertaken to include tree data structures by means of the boxed data type available in J. Methods for displaying these boxed arrays as trees are shown. This work is part of a larger effort to provide a comprehensive set of facilities in J for working with tree structures. The facilities described were at first modelled in J and subsequently translated into C, in order to provide a J interpreter which has trees as mtive facilities. Thus this work also exemplifies the way in which one can tailor the J interpreter to special needs.

[Full Text in PDF Format, 787 KB]

Bayesian methods in APL

The aim of this paper is two-fold. First it explores the ideas of Bayesian Statistical Inference from the point of view of statistical computation. As such the paper is large] y self-contained, enabling those more familiar with APL than Statistics to understand the basic statistical methodology and appreciate its strengths. Secondly the paper reports on recent collaborative work in providing a computational framework in APL for extending Generalized Linear Models to their Bayesian counterparts. This work relies heavily on methods for numeric integration combined with the iteratively re-weighted least squares procedure at the heart of Generalized Linear Models as incorporated into ASLGREG, the first volume produced in ASL (the APL Statistics Library) [1], It is particularly appropriate that this paper should be submitted to APL ’93 as one of the authors (TWS) k a practicing statistician at Queen’s University, Kingston Ontario where Ken Iverson was a student!

[Full Text in PDF Format, 693 KB]

The workspace manager: a change control system for APL

This paper describes the Workspace Manager (WSM), a tool that helps to support and add discipline to APL system development and maintenance efforts.

The WSM acts as a repository of APL objects (variables, fimctions, and operators). Programmers use WSM tools to find where objects are used, edit objects, save changed objects, and request that objects be installed into (or erased from) production workspaces.

Periodically, the WSM installs new releases of production workspaces by merging new and changed objects into existing workspaces.

Audit trails are maintained for all of these activities, malchg it possible to review the change history of an object, compare different versions of an object, compare different releases of a workspace, revert to an old release of a workspace, and so on.

[Full Text in PDF Format, 599 KB]

Understanding ANOVA the APL way

Abstract Statistics text books expound the collection of techniques known as analysis of variance by using mathematical formulae. The term analysis of variance is something of a misnomer, since any analysis follows a primary exercise of partitioning sums of squares, which is entirely a matter of computation and data reorganization of the sort which APL is particularly adept at. The crux of the analysis stage then consists of making choicces between what is often a bewilderingly large range of subtly different sums of squares partitions. The primitive function enclose with axis maps naturally into the data manipulations involved in sums of sqares partitions for arrays. To the casual reader the latter are obsucred rater clarified by the use of mathematical formulae alone. This paper explores the relationships between APL functions and ANOVA, and goes on to illustrate how these can be used in the context of a designed experiment.

[Full Text in PDF Format, 554 KB]

Structured APL: a proposal for block structured control flow in APL

APL, although a very powerful language, has failed to gain wide acceptance in part due to its lack of control structures. ii proposal is made for introducing structure in APL objects by adding to the items that can be located on the left of the colon (:). These markers show the beginning and ends of blocks of code and allow for selection, iteration, and termination. The set of control structures is showm to be robust by showing their use in the creation of traditional control structures. A method of conversion to ISO APL is also presented. This paper briefly discusses proposals that have been made in the past along vith an evaluation of their merits and shortcomings. The paper ends with a discussion of related issues, including elimination of branching, introduction of definition blocks, and lexical scoping in APL. Several areas for continuing vork are given.

[Full Text in PDF Format, 1005 KB]

Recent work on the Toronto toolkit

The Toolkit is a collection of 150 APL “utility” functions developed by the Toronto APL SIG (Special Interest Group). It has been widely distributed in the public domain.

[Full Text in PDF Format, 58 KB]