APL syntax and symbols

Last updated

The programming language APL is distinctive in being symbolic rather than lexical: its primitives are denoted by symbols, not words. These symbols were originally devised as a mathematical notation to describe algorithms. [1] APL programmers often assign informal names when discussing functions and operators (for example, "product" for ×/) but the core functions and operators provided by the language are denoted by non-textual symbols.

Contents

Monadic and dyadic functions

Most symbols denote functions or operators. A monadic function takes as its argument the result of evaluating everything to its right. (Moderated in the usual way by parentheses.) A dyadic function has another argument, the first item of data on its left. Many symbols denote both monadic and dyadic functions, interpreted according to use. For example, ⌊3.2 gives 3, the largest integer not above the argument, and 3⌊2 gives 2, the lower of the two arguments.

Functions and operators

APL uses the term operator in Heaviside’s sense as a moderator of a function as opposed to some other programming language's use of the same term as something that operates on data, ref. relational operator and operators generally. Other programming languages also sometimes use this term interchangeably with function, however both terms are used in APL more precisely. [2] [3] [4] [5] [6] Early definitions of APL symbols were very specific about how symbols were categorized. [7] For example, the operator reduce is denoted by a forward slash and reduces an array along one axis by interposing its function operand. An example of reduce:

      ×/2 3 4 24 
<< Equivalent results in APL >>
<< Reduce operator / used at left
      2×3×4 24 

In the above case, the reduce or slash operator moderates the multiply function. The expression ×/2 3 4 evaluates to a scalar (1 element only) result through reducing an array by multiplication. The above case is simplified, imagine multiplying (adding, subtracting or dividing) more than just a few numbers together. (From a vector, ×/ returns the product of all its elements.)


      1 0 1\45 67 45 0 67 
<< Opposite results in APL >>
<< Expand dyadic function \ used at left
Replicate dyadic function / used at right >>
      1 0 1/45 0 67 45 67 

The above dyadic functions examples [left and right examples] (using the same / symbol, right example) demonstrate how boolean values (0s and 1s) can be used as left arguments for the \ expand and / replicatefunctions to produce exactly opposite results. On the left side, the 2-element vector {45 67} is expanded where boolean 0s occur to result in a 3-element vector {45 0 67} — note how APL inserted a 0 into the vector. Conversely, the exact opposite occurs on the right side — where a 3-element vector becomes just 2-elements; boolean 0s delete items using the dyadic / slash function. APL symbols also operate on lists (vector) of items using data types other than just numeric, for example a 2-element vector of character strings {"Apples" "Oranges"} could be substituted for numeric vector {45 67} above.

Syntax rules

In APL the precedence hierarchy for functions or operators is strictly positional: expressions are evaluated right-to-left. APL does not follow the usual operator precedence of other programming languages; for example, × does not bind its operands any more "tightly" than +. Instead of operator precedence, APL defines a notion of scope.

The scope of a function determines its arguments. Functions have long right scope: that is, they take as right arguments everything to their right. A dyadic function has short left scope: it takes as its left arguments the first piece of data to its left. For example, (leftmost column below is actual program code from an APL user session, indented = actual user input, not-indented = result returned by APL interpreter):


An operator may have function or data operands and evaluate to a dyadic or monadic function. Operators have long left scope. An operator takes as its left operand the longest function to its left. For example:

The left operand for the over-each operator ¨ is the index ⍳ function. The derived function⍳¨ is used monadically and takes as its right operand the vector 3 3. The left scope of each is terminated by the reduce operator, denoted by the forward slash. Its left operand is the function expression to its left: the outer product of the equals function. The result of ∘.=/ is a monadic function. With a function's usual long right scope, it takes as its right argument the result of ⍳¨3 3. Thus



Monadic functions

Name(s)NotationMeaningUnicode code point
Roll?BOne integer selected randomly from the first B integersU+003F?
Ceiling ⌈BLeast integer greater than or equal to BU+2308
Floor ⌊BGreatest integer less than or equal to BU+230A
Shape, Rho ⍴BNumber of components in each dimension of BU+2374
Not, Tilde ∼BLogical: 1 is 0, 0 is 1U+223C
Absolute value ∣BMagnitude of BU+2223
Index generator, Iota ⍳BVector of the first B integersU+2373
Exponential ⋆Be to the B powerU+22C6
Negation −BChanges sign of BU+2212
Conjugate +BThe complex conjugate of B (real numbers are returned unchanged)U+002B+
Signum ×B¯1 if B<0; 0 if B=0; 1 if B>0U+00D7×
Reciprocal ÷B1 divided by BU+00F7÷
Ravel, Catenate, Laminate,BReshapes B into a vectorU+002C,
Matrix inverse, Monadic Quad Divide⌹BInverse of matrix BU+2339
Pi times○BMultiply by πU+25CB
Logarithm ⍟BNatural logarithm of BU+235F
Reversal⌽BReverse elements of B along last axisU+233D
Reversal⊖BReverse elements of B along first axisU+2296
Grade up⍋BIndices of B which will arrange B in ascending orderU+234B
Grade down⍒BIndices of B which will arrange B in descending orderU+2352
Execute ⍎BExecute an APL expressionU+234E
Monadic format⍕BA character representation of BU+2355
Monadic transpose ⍉BReverse the axes of BU+2349
Factorial !BProduct of integers 1 to BU+0021!
Depth ≡BNesting depth: 1 for un-nested arrayU+2261
Table⍪BMakes B into a table, a 2-dimensional array.U+236A

Dyadic functions

Name(s)NotationMeaningUnicode
code point
Add A+BSum of A and BU+002B+
Subtract A−BA minus BU+2212
Multiply A×BA multiplied by BU+00D7×
Divide A÷BA divided by BU+00F7÷
Exponentiation A⋆BA raised to the B powerU+22C6
CircleA○BTrigonometric functions of B selected by A
A=1: sin(B)    A=5: sinh(B) A=2: cos(B)    A=6: cosh(B) A=3: tan(B)    A=7: tanh(B)

Negatives produce the inverse of the respective functions

U+25CB
DealA?BA distinct integers selected randomly from the first B integersU+003F?
Membership, EpsilonA∈B1 for elements of A present in B; 0 where not.U+2208
Find, Epsilon UnderbarA⍷B1 for starting point of multi-item array A present in B; 0 where not.U+2377
Maximum, CeilingA⌈BThe greater value of A or BU+2308
Minimum, FloorA⌊BThe smaller value of A or BU+230A
Reshape, Dyadic Rho A⍴BArray of shape A with data BU+2374
TakeA↑BSelect the first (or last) A elements of B according to ×AU+2191
DropA↓BRemove the first (or last) A elements of B according to ×AU+2193
DecodeA⊥BValue of a polynomial whose coefficients are B at AU+22A5
EncodeA⊤BBase-A representation of the value of BU+22A4
Residue A∣BB modulo AU+2223
CatenationA,BElements of B appended to the elements of AU+002C,
Expansion, Dyadic BackslashA\BInsert zeros (or blanks) in B corresponding to zeros in AU+005C\
Compression, Dyadic SlashA/BSelect elements in B corresponding to ones in AU+002F/
Index of, Dyadic Iota A⍳BThe location (index) of B in A; 1+⍴A if not foundU+2373
Matrix divide, Dyadic Quad DivideA⌹BSolution to system of linear equations, multiple regression Ax = BU+2339
RotationA⌽BThe elements of B are rotated A positionsU+233D
RotationA⊖BThe elements of B are rotated A positions along the first axisU+2296
Logarithm A⍟BLogarithm of B to base AU+235F
Dyadic formatA⍕BFormat B into a character matrix according to AU+2355
General transposeA⍉BThe axes of B are ordered by AU+2349
CombinationsA!BNumber of combinations of B taken A at a timeU+0021!
Diaeresis, Dieresis, Double-DotA¨BOver each, or perform each separately; B = on these; A = operation to perform or using (e.g., iota)U+00A8¨
Less thanA<BComparison: 1 if true, 0 if falseU+003C<
Less than or equalA≤BComparison: 1 if true, 0 if falseU+2264
Equal A=BComparison: 1 if true, 0 if falseU+003D=
Greater than or equalA≥BComparison: 1 if true, 0 if falseU+2265
Greater thanA>BComparison: 1 if true, 0 if falseU+003E>
Not equalA≠BComparison: 1 if true, 0 if falseU+2260
Or A∨BBoolean Logic: 0 (False) if bothA and B = 0, 1 otherwise. Alt: 1 (True) if AorB = 1 (True)U+2228
And A∧BBoolean Logic: 1 (True) if bothAandB = 1, 0 (False) otherwiseU+2227
Nor A⍱BBoolean Logic: 1 if both A and B are 0, otherwise 0. Alt: ~∨ = not OrU+2371
Nand A⍲BBoolean Logic: 0 if both A and B are 1, otherwise 1. Alt: ~∧ = not AndU+2372
LeftA⊣BAU+22A3
RightA⊢BBU+22A2
MatchA≡B0 if A does not match B exactly with respect to value, shape, and nesting; otherwise 1.U+2261
LaminateA⍪BConcatenate along first axisU+236A

Operators and axis indicator

Name(s)SymbolExampleMeaning (of example)Unicode code point sequence
Reduce (last axis), Slash/+/BSum across BU+002F/
Reduce (first axis)+⌿BSum down BU+233F
Scan (last axis), Backslash\+\BRunning sum across BU+005C\
Scan (first axis)+⍀BRunning sum down BU+2340
Inner product.A+.×B Matrix product of A and BU+002E.
Outer product∘.A∘.×B Outer product of A and BU+2218, U+002E.

Notes: The reduce and scan operators expect a dyadic function on their left, forming a monadic composite function applied to the vector on its right.

The product operator "." expects a dyadic function on both its left and right, forming a dyadic composite function applied to the vectors on its left and right. If the function to the left of the dot is "∘" (signifying null) then the composite function is an outer product, otherwise it is an inner product. An inner product intended for conventional matrix multiplication uses the + and × functions, replacing these with other dyadic functions can result in useful alternative operations.

Some functions can be followed by an axis indicator in (square) brackets, i.e., this appears between a function and an array and should not be confused with array subscripts written after an array. For example, given the ⌽ (reversal) function and a two-dimensional array, the function by default operates along the last axis but this can be changed using an axis indicator:


As a particular case, if the dyadic catenate"," function is followed by an axis indicator (or axis modifier to a symbol/function), it can be used to laminate (interpose) two arrays depending on whether the axis indicator is less than or greater than the index origin [8] (index origin = 1 in illustration below):

Nested arrays

Arrays are structures which have elements grouped linearly as vectors or in table form as matrices—and higher dimensions (3D or cubed, 4D or cubed over time, etc.). Arrays containing both characters and numbers are termed mixed arrays. [9] Array structures containing elements which are also arrays are called nested arrays. [10]

Creating a nested array
User session with APL interpreterExplanation
X45⍴⍳20X1234567891011121314151617181920X[2;2]7⎕IO1X[1;1]1


X set = to matrix with 4 rows by 5 columns, consisting of 20 consecutive integers.

Element X[2;2] in row 2 - column 2 currently is an integer = 7.

Initial index origin⎕IO value = 1.

Thus, the first element in matrix X or X[1;1] = 1.

X[2;2]"Text"X[3;4](22⍴⍳4)X123456Text89101112131215341617181920
Element in X[row 2; col 2] is changed (from 7) to a nested vector "Text" using the enclose ⊂ function.


Element in X[row 3; col 4], formerly integer 14, now becomes a mini enclosed or ⊂ nested 2x2 matrix of 4 consecutive integers.

Since X contains numbers, text and nested elements, it is both a mixed and a nested array.

Visual representation of the nested array APL2NestedArray.png
Visual representation of the nested array

Flow control

A user may define custom functions which, like variables, are identified by name rather than by a non-textual symbol. The function header defines whether a custom function is niladic (no arguments), monadic (one right argument) or dyadic (left and right arguments), the local name of the result (to the left of the ← assign arrow), and whether it has any local variables (each separated by semicolon ';').

User functions
Niladic function PI or π(pi)Monadic function CIRCLEAREADyadic function SEGMENTAREA, with local variables
RESULTPIRESULT1
AREACIRCLEAREARADIUSAREAPI×RADIUS2
AREADEGREESSEGMENTAREARADIUS;FRACTION;CAFRACTIONDEGREES÷360CACIRCLEAREARADIUSAREAFRACTION×CA

Whether functions with the same identifier but different adicity are distinct is implementation-defined. If allowed, then a function CURVEAREA could be defined twice to replace both monadic CIRCLEAREA and dyadic SEGMENTAREA above, with the monadic or dyadic function being selected by the context in which it was referenced.

Custom dyadic functions may usually be applied to parameters with the same conventions as built-in functions, i.e., arrays should either have the same number of elements or one of them should have a single element which is extended. There are exceptions to this, for example a function to convert pre-decimal UK currency to dollars would expect to take a parameter with precisely three elements representing pounds, shillings and pence. [11]

Inside a program or a custom function, control may be conditionally transferred to a statement identified by a line number or explicit label; if the target is 0 (zero) this terminates the program or returns to a function's caller. The most common form uses the APL compression function, as in the template (condition)/target which has the effect of evaluating the condition to 0 (false) or 1 (true) and then using that to mask the target (if the condition is false it is ignored, if true it is left alone so control is transferred).

Hence function SEGMENTAREA may be modified to abort (just below), returning zero if the parameters (DEGREES and RADIUS below) are of different sign:

AREADEGREESSEGMENTAREARADIUS;FRACTION;CA;SIGN⍝ local variables denoted by semicolon(;)FRACTIONDEGREES÷360CACIRCLEAREARADIUS⍝ this APL code statement calls user function CIRCLEAREA, defined up above.SIGN(×DEGREES)≠×RADIUS⍝ << APL logic TEST/determine whether DEGREES and RADIUS do NOT (≠ used) have same SIGN 1-yes different(≠), 0-no(same sign)AREA0⍝ default value of AREA set = zeroSIGN/0⍝ branching(here, exiting) occurs when SIGN=1 while SIGN=0 does NOT branch to 0.  Branching to 0 exits function.AREAFRACTION×CA

The above function SEGMENTAREA works as expected if the parameters are scalars or single-element arrays, but not if they are multiple-element arrays since the condition ends up being based on a single element of the SIGN array - on the other hand, the user function could be modified to correctly handle vectorized arguments. Operation can sometimes be unpredictable since APL defines that computers with vector-processing capabilities should parallelise and may reorder array operations as far as possible - thus, test and debuguser functions particularly if they will be used with vector or even matrix arguments. This affects not only explicit application of a custom function to arrays, but also its use anywhere that a dyadic function may reasonably be used such as in generation of a table of results:

90180270¯90∘.SEGMENTAREA1¯24000000000000

A more concise way and sometimes better way - to formulate a function is to avoid explicit transfers of control, instead using expressions which evaluate correctly in all or the expected conditions. Sometimes it is correct to let a function fail when one or both input arguments are incorrect - precisely to let user know that one or both arguments used were incorrect. The following is more concise than the above SEGMENTAREA function. The below importantly correctly handles vectorized arguments:

AREADEGREESSEGMENTAREARADIUS;FRACTION;CA;SIGNFRACTIONDEGREES÷360CACIRCLEAREARADIUSSIGN(×DEGREES)≠×RADIUSAREAFRACTION×CA×~SIGN⍝ this APL statement is more complex, as a one-liner - but it solves vectorized arguments: a tradeoff - complexity vs. branching90180270¯90∘.SEGMENTAREA1¯240.785398163012.56637061.57079633025.13274122.35619449037.69911180¯3.141592650

Avoiding explicit transfers of control also called branching, if not reviewed or carefully controlled - can promote use of excessively complex one liners, veritably "misunderstood and complex idioms" and a "write-only" style, which has done little to endear APL to influential commentators such as Edsger Dijkstra. [12] Conversely however APL idioms can be fun, educational and useful - if used with helpful comments ⍝, for example including source and intended meaning and function of the idiom(s). Here is an APL idioms list, an IBM APL2 idioms list here [13] and Finnish APL idiom library here.

Miscellaneous

Miscellaneous symbols
Name(s)SymbolExampleMeaning (of example)Unicode code point
High minus [14] ¯¯3Denotes a negative numberU+00AF¯
Lamp, Comment⍝This is a commentEverything to the right of ⍝ denotes a commentU+235D
RightArrow, Branch, GoTo→This_Label→This_Label sends APL execution to This_Label:U+2192
Assign, LeftArrow, Set toB←AB←A sets values and shape of B to match AU+2190

Most APL implementations support a number of system variables and functions, usually preceded by the ⎕ (quad) and/or ")" (hook=close parenthesis) character. Note that the quad character is not the same as the Unicode missing character symbol. Particularly important and widely implemented is the ⎕IO (Index Origin) variable, since while the original IBM APL based its arrays on 1 some newer variants base them on zero:

User session with APL interpreterDescription
X12X123456789101112⎕IO1X[1]1

X set = to vector of 12 consecutive integers.

Initial index origin⎕IO value = 1. Thus, the first position in vector X or X[1] = 1 per vector of iota values {1 2 3 4 5 ...}.

⎕IO0X[1]2X[0]1
Index Origin ⎕IO now changed to 0. Thus, the 'first index position' in vector X changes from 1 to 0. Consequently, X[1] then references or points to 2 from {1 2 3 4 5 ...} and X[0] now references 1.
⎕WA41226371072
Quad WA or ⎕WA, another dynamic system variable, shows how much Work Area remains unused or 41,226 megabytes or about 41 gigabytes of unused additional total free work area available for the APL workspace and program to process using. If this number gets low or approaches zero - the computer may need more random-access memory (RAM), hard disk drive space or some combination of the two to increase virtual memory.
)VARSX
)VARS a system function in APL, [15] )VARS shows user variable names existing in the current workspace.

There are also system functions available to users for saving the current workspace e.g., )SAVE and terminating the APL environment, e.g., )OFF - sometimes called hook commands or functions due to the use of a leading right parenthesis or hook. [16] There is some standardization of these quad and hook functions.

Fonts

The Unicode Basic Multilingual Plane includes the APL symbols in the Miscellaneous Technical block, [17] which are thus usually rendered accurately from the larger Unicode fonts installed with most modern operating systems. These fonts are rarely designed by typographers familiar with APL glyphs. So, while accurate, the glyphs may look unfamiliar to APL programmers or be difficult to distinguish from one another.

Some Unicode fonts have been designed to display APL well: APLX Upright, APL385 Unicode, and SimPL.

Before Unicode, APL interpreters were supplied with fonts in which APL characters were mapped to less commonly used positions in the ASCII character sets, usually in the upper 128 code points. These mappings (and their national variations) were sometimes unique to each APL vendor's interpreter, which made the display of APL programs on the Web, in text files and manuals - frequently problematic.

APL2 keyboard function to symbol mapping

APL2 Keyboard APL2-nappaimisto.png
APL2 Keyboard

Note the APL On/Off Key - topmost-rightmost key, just below. Also note the keyboard had some 55 unique (68 listed per tables above, including comparative symbols but several symbols appear in both monadic and dyadic tables) APL symbol keys (55 APL functions (operators) are listed in IBM's 5110 APL Reference Manual), thus with the use of alt, shift and ctrl keys - it would theoretically have allowed a maximum of some 59 (keys) *4 (with 2-key pressing) *3 (with tri-key pressing, e.g., ctrl-alt-del) or some 472 different maximum key combinations, approaching the 512 EBCDIC character max (256 chars times 2 codes for each keys-combination). Again, in theory the keyboard pictured here would have allowed for about 472 different APL symbols/functions to be keyboard-input, actively used. In practice, early versions were only using something roughly equivalent to 55 APL special symbols (excluding letters, numbers, punctuation, etc. keys). Thus, early APL was then only using about 11% (55/472) of a symbolic language's at-that-time utilization potential, based on keyboard # keys limits, again excluding numbers, letters, punctuation, etc. In another sense keyboard symbols utilization was closer to 100%, highly efficient, since EBCDIC only allowed 256 distinct chars, and ASCII only 128.

Solving puzzles

APL has proved to be extremely useful in solving mathematical puzzles, several of which are described below.

Pascal's triangle

Take Pascal's triangle, which is a triangular array of numbers in which those at the ends of the rows are 1 and each of the other numbers is the sum of the nearest two numbers in the row just above it (the apex, 1, being at the top). The following is an APL one-liner function to visually depict Pascal's triangle:

Pascal{0~¨⍨a⌽⊃⌽∊¨0,¨¨a!¨a⌽⍳}⍝ Create one-line user function called PascalPascal7⍝ Run function Pascal for seven rows and show the results below:1121331464151010516152015617213535217

Prime numbers, contra proof via factors

Determine the number of prime numbers (prime # is a natural number greater than 1 that has no positive divisors other than 1 and itself) up to some number N. Ken Iverson is credited with the following one-liner APL solution to the problem:

⎕CR'PrimeNumbers'⍝ Show APL user-function PrimeNumbersPrimesPrimeNumbersN⍝ Function takes one right arg N (e.g., show prime numbers for 1 ... int N)Primes(2=+0=(N)∘.|⍳N)/N⍝ The Ken Iverson one-linerPrimeNumbers100⍝ Show all prime numbers from 1 to 1002357111317192329313741434753596167717379838997PrimeNumbers10025⍝ There are twenty-five prime numbers in the range up to 100.

Examining the converse or opposite of a mathematical solution is frequently needed ( integer factors of a number ): Prove for the subset of integers from 1 through 15 that they are non-prime by listing their decomposition factors. What are their non-one factors (#'s divisible by, except 1)?

⎕CR'ProveNonPrime'ZProveNonPrimeR⍝Show all factors of an integer R - except 1 and the number itself,⍝ i.e., prove Non-Prime. String 'prime' is returned for a Prime integer.Z(0=(R)|R)/R⍝ Determine all factors for integer R, store into ZZ(~(Z1,R))/Z⍝ Delete 1 and the number as factors for the number from Z.(0=⍴Z)/ProveNonPrimeIsPrime⍝ If result has zero shape, it has no other factors and is therefore primeZR,(" factors(except 1) "),(Z),⎕TCNL⍝ Show the number R, its factors(except 1,itself), and a new line char0⍝ Done with function if non-primeProveNonPrimeIsPrime:ZR,(" prime"),⎕TCNL⍝ function branches here if number was primeProveNonPrime¨15⍝ Prove non primes for each(¨) of the integers from 1 through 15 (iota 15)1prime2prime3prime4factors(except1)25prime6factors(except1)237prime8factors(except1)249factors(except1)310factors(except1)2511prime12factors(except1)234613prime14factors(except1)2715factors(except1)35

Fibonacci sequence

Generate a Fibonacci number sequence, where each subsequent number in the sequence is the sum of the prior two:

⎕CR'Fibonacci'⍝ Display function FibonacciFibonacciNumFibonacciNth;IOwas⍝ Funct header, funct name=Fibonacci, monadic funct with 1 right hand arg Nth;local var IOwas, and a returned num.⍝Generate a Fibonacci sequenced number where Nth is the position # of the Fibonacci number in the sequence.  << function descriptionIOwas⎕IO⎕IO0FibonacciNum01↓↑+.×/Nth/221110⎕IOIOwas⍝ In order for this function to work correctly ⎕IO must be set to zero.Fibonacci¨14⍝ This APL statement says: Generate the Fibonacci sequence over each(¨) integer number(iota or ⍳) for the integers 1..14.01123581321345589144233⍝ Generated sequence, i.e., the Fibonacci sequence of numbers generated by APL's interpreter.

Further reading

See also

Related Research Articles

<span class="mw-page-title-main">APL (programming language)</span> Functional programming language for arrays

APL is a programming language developed in the 1960s by Kenneth E. Iverson. Its central datatype is the multidimensional array. It uses a large range of special graphic symbols to represent most functions and operators, leading to very concise code. It has been an important influence on the development of concept modeling, spreadsheets, functional programming, and computer math packages. It has also inspired several other programming languages.

<span class="mw-page-title-main">Binary operation</span> Mathematical operation with two operands

In mathematics, a binary operation or dyadic operation is a rule for combining two elements to produce another element. More formally, a binary operation is an operation of arity two.

<span class="mw-page-title-main">Multiplication</span> Arithmetical operation

Multiplication is one of the four elementary mathematical operations of arithmetic, with the other ones being addition, subtraction, and division. The result of a multiplication operation is called a product.

<span class="mw-page-title-main">Arithmetic shift</span> Shift operator in computer programming

In computer programming, an arithmetic shift is a shift operator, sometimes termed a signed shift. The two basic types are the arithmetic left shift and the arithmetic right shift. For binary numbers it is a bitwise operation that shifts all of the bits of its operand; every bit in the operand is simply moved a given number of bit positions, and the vacant bit-positions are filled in. Instead of being filled with all 0s, as in logical shift, when shifting to the right, the leftmost bit is replicated to fill in all the vacant positions.

<span class="mw-page-title-main">J (programming language)</span> Programming language

The J programming language, developed in the early 1990s by Kenneth E. Iverson and Roger Hui, is an array programming language based primarily on APL.

A mathematical symbol is a figure or a combination of figures that is used to represent a mathematical object, an action on mathematical objects, a relation between mathematical objects, or for structuring the other symbols that occur in a formula. As formulas are entirely constituted with symbols of various types, many symbols are needed for expressing all mathematics.

The plus sign+ and the minus sign are mathematical symbols used to represent the notions of positive and negative, respectively. In addition, + represents the operation of addition, which results in a sum, while represents subtraction, resulting in a difference. Their use has been extended to many other meanings, more or less analogous. Plus and minus are Latin terms meaning "more" and "less", respectively.

The multiplication sign, also known as the times sign or the dimension sign, is the symbol ×, used in mathematics to denote the multiplication operation and its resulting product. While similar to a lowercase X, the form is properly a four-fold rotationally symmetric saltire.

<span class="mw-page-title-main">Kenneth E. Iverson</span> Canadian computer scientist (1920–2004)

Kenneth Eugene Iverson was a Canadian computer scientist noted for the development of the programming language APL. He was honored with the Turing Award in 1979 "for his pioneering effort in programming languages and mathematical notation resulting in what the computing field now knows as APL; for his contributions to the implementation of interactive systems, to educational uses of APL, and to programming language theory and practice".

In computer programming, operators are constructs defined within programming languages which behave generally like functions, but which differ syntactically or semantically.

K is a proprietary array processing programming language developed by Arthur Whitney and commercialized by Kx Systems. The language serves as the foundation for kdb+, an in-memory, column-based database, and other related financial products. The language, originally developed in 1993, is a variant of APL and contains elements of Scheme. Advocates of the language emphasize its speed, facility in handling arrays, and expressive syntax.

The computer programming languages C and Pascal have similar times of origin, influences, and purposes. Both were used to design their own compilers early in their lifetimes. The original Pascal definition appeared in 1969 and a first compiler in 1970. The first version of C appeared in 1972.

Rank is a generalization of looping as used in scalar (non-array-oriented) programming languages. It is also a generalization of mapcar in the language Lisp and map in modern functional programming languages, and a generalization of scalar extension, inner (matrix) product, and outer product in APL\360. The canonical implementation of rank may be the language J, but it is also available in Dyalog APL, the International Organization for Standardization (ISO) technical standard on Extended APL, and NARS2000.

<span class="mw-page-title-main">JavaScript syntax</span> Set of rules defining correctly structured programs

The syntax of JavaScript is the set of rules that define a correctly structured JavaScript program.

<span class="mw-page-title-main">Operation (mathematics)</span> Addition, multiplication, division, ...

In mathematics, an operation is a function which takes zero or more input values to a well-defined output value. The number of operands is the arity of the operation.

Tacit programming, also called point-free style, is a programming paradigm in which function definitions do not identify the arguments on which they operate. Instead the definitions merely compose other functions, among which are combinators that manipulate the arguments. Tacit programming is of theoretical interest, because the strict use of composition results in programs that are well adapted for equational reasoning. It is also the natural style of certain programming languages, including APL and its derivatives, and concatenative languages such as Forth. The lack of argument naming gives point-free style a reputation of being unnecessarily obscure, hence the epithet "pointless style".

This article describes the features in the programming language Haskell.

ELI is an interactive array programming language system based on the programming language APL. It has most of the functions of the International Organization for Standardization (ISO) APL standard ISO/IEC 13751:2001, and also list for non-homogeneous or non-rectangular data, complex numbers, symbols, temporal data, and control structures. A scripting file facility is available to organize programs in a fashion similar to using #include in C, which also provides convenient data input/output. ELI has dictionaries, tables, and a basic set of SQL-like statements. For performance, it has a compiler restricted to flat array programs.

<span class="mw-page-title-main">John M. Scholes</span> British computer scientist (1948-2019)

John Morley Scholes (1948–2019) was a British computer scientist. In his professional career he was devoted to the development of the programming language APL. He was the designer and implementer of direct functions.

A direct function is an alternative way to define a function and operator in the programming language APL. A direct operator can also be called a dop. They were invented by John Scholes in 1996. They are a unique combination of array programming, higher-order function, and functional programming, and are a major distinguishing advance of early 21st century APL over prior versions.

References

  1. Iverson, Kenneth E. (1962-01-01). "A programming language". Proceedings of the May 1-3, 1962, spring joint computer conference on - AIEE-IRE '62 (Spring). New York, NY, USA: ACM. pp. 345–351. doi: 10.1145/1460833.1460872 . S2CID   11777029.
  2. Baronet, Dan. "Sharp APL Operators". archive.vector.org.uk. Vector - Journal of the British APL Association. Retrieved 13 January 2015.
  3. MicroAPL. "Primitive Operators". www.microapl.co.uk. MicroAPL. Retrieved 13 January 2015.
  4. MicroAPL. "Operators". www.microapl.co.uk. MicroAPL. Retrieved 13 January 2015.
  5. Progopedia. "APL". progopedia.com. Progopedia. Retrieved 13 January 2015.
  6. Dyalog. "D-functions and operators loosely grouped into categories". dfns.dyalog.com. Dyalog. Retrieved 13 January 2015.
  7. IBM. "IBM 5100 APL Reference Manual" (PDF). bitsavers.trailing-edge.com. IBM. Archived from the original (PDF) on 14 January 2015. Retrieved 14 January 2015.
  8. Brown, Jim (1978). "In defense of index origin 0". ACM SIGAPL APL Quote Quad. 9 (2): 7. doi: 10.1145/586050.586053 . S2CID   40187000.
  9. MicroAPL. "APLX Language Manual" (PDF). www.microapl.co.uk. MicroAPL - Version 5 .0 June 2009. p. 22. Retrieved 31 January 2015.
  10. Benkard, J. Philip (1992). "Nested arrays and operators: Some issues in depth". Proceedings of the international conference on APL - APL '92. Vol. 23. pp. 7–21. doi: 10.1145/144045.144065 . ISBN   978-0897914772. S2CID   7760410.{{cite book}}: |journal= ignored (help)
  11. Berry, Paul "APL\360 Primer Student Text", IBM Research, Thomas J. Watson Research Center, 1969.
  12. "Treatise" (PDF). www.cs.utexas.edu. Retrieved 2019-09-10.
  13. Cason, Stan (13 May 2006). "APL2 Idioms Library". www-01.ibm.com. IBM. Retrieved 1 February 2015.
  14. APL's "high minus" applies to the single number that follows, while the monadic minus function changes the sign of the entire array to its right.
  15. "The Workspace - System Functions". Microapl.co.uk. p. (toward bottom of the web page). Retrieved 2018-11-05.
  16. "APL language reference" (PDF). Retrieved 2018-11-05.
  17. Unicode chart "Miscellaneous Technical (including APL)" (PDF).

Generic online tutorials

Syntax rules