This is a collection of the Dyalog, FinnAPL, and APL2 idiom lists.

The lists differ a bit: The Dyalog entries are optimized in interpreter. The FinnAPL entries represent the traditional APL way of doing things – without nested arrays and other modern features. The APL2 entries do use nested arrays, but may not take advantage of Dyalog's newest additions, e.g. dfns, trains, and primitives like `⍣ ⌸ ⍤ ⍨ ∪ ∩ ≢`

etc. Note that all idioms, including those from APL2, assume `⎕ML←1`

, while `⊆`

is use to denote `{⎕ML←3 ⋄ ⍺⊂⍵}`

.

If you click on an APL expression it will be copied to the clipboard.

Description | Expression click to copy to clipboard | Requirements | Library |
---|---|---|---|

(Cyclic) compression of successive blanks. | (A∨1⌽A←CV≠' ')/CV | FinnAPL | |

(Real) solution of quadratic equation with coefficients NV. | (-NV[2]-¯1 1×((NV[2]*2)-×/4,NV[1 3])*.5)÷2×NV[1] | 3 ←→ ⍴NQ | FinnAPL |

0 corresponding to each item of XA. | {0}¨XA | Dyalog | |

0 irrespective of XA. | {0}XA | Dyalog | |

1 if XA does not have an empty first dimension, 0 otherwise (⎕ML<2). | 0≠⊃⍴XA | Dyalog | |

1 if XA has a depth of 0 or 1 (simple scalar, vector, etc.), 0 otherwise. | 1=≡,XA | Dyalog | |

1 if XA has a depth of 1 (simple array), 0 otherwise. | 1=≡XA | Dyalog | |

1 if XA has a depth of zero (simple scalar), 0 otherwise. | 0=≡XA | Dyalog | |

1 if XA has a rank of zero (scalar), 0 otherwise. | 0=⍴⍴XA | Dyalog | |

1 if XA has an empty first dimension, 0 otherwise (⎕ML<2). | 0=⊃⍴XA | Dyalog | |

1 if XA is empty, 0 otherwise. | 0∊⍴XA | Dyalog | |

1 if XA is not empty, 0 otherwise. | ~0∊⍴XA | Dyalog | |

1 if XV has a shape of zero, 0 otherwise. | 0=⍴XV | Dyalog | |

A Boolean mask indicating the leading blank spaces in each row of CA. | ∧\' '=CA | Dyalog | |

A magic square, side IS. | A⊖(A←(⍳IS)-⌈IS÷2)⌽(IS,IS)⍴⍳IS×IS | 1=2|IS | FinnAPL |

A nested vector comprising simple character vectors constructed from the rows of CA (which must be of depth 1) with all blank spaces removed. | ~∘' '¨↓CA | Dyalog | |

A nested vector comprising simple character vectors constructed from the rows of CA (which must be of depth 1) with trailing blank spaces removed. | {(+/∨\' '≠⌽⍵)↑¨↓⍵}CA | Dyalog | |

A nested vector comprising vectors that each correspond to a position in the original vectors of PV – the first vector contains the first item from each vector in PV, padded to be the same length as the largest vector, and so on (⎕ML<2). | ↓⍉↑PV | Dyalog | |

A nested vector comprising vectors that each correspond to a position in the original vectors of PV – the first vector contains the first item from each vector in PV, padded to be the same length as the largest vector, and so on (⎕ML≥2). | ↓⍉⊃PV | Dyalog | |

A simple vector comprising as many items as there are rows in XM2, where each item is the number of the first row in XM1 that matches each row in XM2. | XM1{(↓⍺)⍳↓⍵}XM2 | Dyalog | |

A way to combine trigonometric functions (sin NS1 cos NS2). | 1 2×.○NS1,NS2 | FinnAPL | |

Accurately sum a vector of floating numbers. | FS←+/F[⍒|F] | APL2 | |

Add subvectors of N from consecutive G dups. | N←+/¨(+\¯1↓1,G≠1⌽G)⊆N | APL2 | |

Add subvectors of N given B breaks in group. | N←+/¨(+\B)⊆N | APL2 | |

Add subvectors of N given L items per group. | N←+/¨(L/1+⍳⍴L)⊆N | APL2 | |

Add subvectors of N using ordered list MG. | N←+/¨(+\¯1↓1,∨/MG≠1⊖MG)⊆N | APL2 | |

Add vector N to each column of NM. | NM←NM+[1]N | 0=⎕IO | APL2 |

Add vector N to each column of NM. | NM←NM+[2]N | 1=⎕IO | APL2 |

Adding a new dimension after dimension IS1 IS2-fold. | (⍋⍋(IS1+1),⍳⍴⍴XA)⍉(IS2,⍴XA)⍴XA | FinnAPL | |

Adding an empty row into XM after row IS. | ((IS+1)≠⍳1+1⍴⍴XM)⍀XM | FinnAPL | |

Adding an empty row into XM after rows IV. | (~(⍳(⍴IV)+1⍴⍴XM)∊IV+⍳⍴IV)⍀XM | FinnAPL | |

Adding NV to each column of NA. | NA+⍉(⌽⍴NA)⍴NV | ≢NQ ←→ ≢NA | FinnAPL |

Adding NV to each column of NM. | 2 1 2⍉NV∘.+NM | FinnAPL | |

Adding NV to each column of NM. | 1 2 2⍉NM∘.+NV | FinnAPL | |

Adding NV to each row of NA. | NA+(⍴NA)⍴NV | (⍴NQ)=¯1↑⍴NA | FinnAPL |

Adding NV to each row of NM. | 1 1 2⍉NV∘.+NM | FinnAPL | |

Adding NV to each row of NM. | 1 2 1⍉NM∘.+NV | FinnAPL | |

Adding scalar NS to last element of NA. | NA+(-⍴NA)↑NS | FinnAPL | |

Ain't Dot Is. Test for even # of non-zeros. | BS←0≠.=N | APL2 | |

Aligning columns of matrix XM to diagonals. | (1-⍳¯1↑⍴XM)⌽XM | FinnAPL | |

Aligning diagonals of matrix XM to columns. | (¯1+⍳¯1↑⍴XM)⌽XM | FinnAPL | |

All axes of array A. | I←⍳⍴⍴A | APL2 | |

All axes of array XA. | ⍳⍴⍴XA | FinnAPL | |

All binary representations up to IS (truth table). | ((⌈2⍟1+IS)⍴2)⊤0,⍳IS | FinnAPL | |

All binary representations with IS bits (truth table). | (IS⍴2)⊤¯1+⍳2*IS | FinnAPL | |

All column indices of array A. | I←⍳⊃⌽⍴A | APL2 | |

All elements true (∧/) on each subvector of BV2 indicated by BV1. | (BV1/BV2)∧A/1⌽A←(BV2≤BV1)/BV1 | FinnAPL | |

All factors of IS. | I←(0=I|IS)/I←2+⍳⌊IS÷2 | 0=⎕IO | APL2 |

All factors of IS. | I←(0=I|IS)/I←1+⍳⌊IS÷2 | 1=⎕IO | APL2 |

All indices of vector V. | I←⍳⍴V | APL2 | |

All indices of vector XV. | ⍳⍴XV | FinnAPL | |

All ones after the first one. | B←∨\B | APL2 | |

All ones after the first zero. | B←≤\B | APL2 | |

All ones to the first zero. | B←∧\B | APL2 | |

All pairs of elements of ⍳IS1 and ⍳IS2. | ⎕IO+(IS1,IS2)⊤(⍳IS1×IS2)-⎕IO | FinnAPL | |

All pixels in a 5 by 10 window. | Z←(⍳5)∘.+¯11○⍳10 | APL2 | |

All possible pairs of 1 through IS. | M←(<⌿M)/M←(2,IS*2)⍴(,⍉M),,M←IS IS⍴1+⍳IS | 0=⎕IO | APL2 |

All possible pairs of 1 through IS. | M←(<⌿M)/M←(2,IS*2)⍴(,⍉M),,M←IS IS⍴⍳IS | 1=⎕IO | APL2 |

All primes up to IS. | (2=+⌿0=(⍳IS)∘.|⍳IS)/⍳IS | FinnAPL | |

All row indices of matrix M. | I←⍳≢M | APL2 | |

All valid one character APL2 names. | C←(¯1≠⎕NC,['']⎕AV)/⎕AV | APL2 | |

All zeros except the first one. | B←<\B | APL2 | |

All, both. | ∧/BA | FinnAPL | |

Alphabetical comparison with alphabets XV. | (XV⍳XA1)<XV⍳XA2 | FinnAPL | |

Alphabetizing CA; equal alphabets in same column of CM. | (¯1↑⍴CM)|(,CM)⍳CA | FinnAPL | |

Alternate beg/end tags. | M←↑∊¨⊂[1]M⊣(B/,M)←(+/B←,M='ø')⍴':HP1.' ':EHP1.' | 0=⎕IO | APL2 |

Alternate beg/end tags. | M←↑∊¨⊂[2]M⊣(B/,M)←(+/B←,M='ø')⍴':HP1.' ':EHP1.' | 1=⎕IO | APL2 |

Alternating product. | ÷/NA | FinnAPL | |

Alternating product of N. | NS←÷/N | APL2 | |

Alternating sequence of I ones and zeros. | B←I/(⍴I)⍴1 0 | APL2 | |

Alternating series (1 ¯1 2 ¯2 3 ¯3 …). | #NAME? | FinnAPL | |

Alternating series of length IS(1,-1,2,-2..). | N←-\⍳IS | APL2 | |

Alternating sum. | -/NA | FinnAPL | |

Alternating sum of magnitude of N. | NS←-/|N | APL2 | |

Alternating sum of N. | NS←-/N | APL2 | |

An expression giving itself. | 1⌽22⍴11⍴'''1⌽22⍴11⍴''' | FinnAPL | |

Annuity coefficient: IA periods at int FA. | A←FA÷⍉1-(1+FA)∘.×-IA | APL2 | |

Annuity coefficient: IA periods at interest rate NA %. | ((⍴A)⍴NA÷100)÷A←⍉1-(1+NA÷100)∘.*-IA | FinnAPL | |

Any element true (∨/) on each subvector of BV2 indicated by BV1. | (BV1/BV2)≥A/1⌽A←(BV2∨BV1)/BV1 | FinnAPL | |

Any, anyone. | ∨/BA | FinnAPL | |

Applying to columns action defined on rows. | ⍉ … ⍉XV | FinnAPL | |

Arccosine of NA in radians. | FA←¯2○NA | APL2 | |

Arcsine of NA in radians. | FA←¯1○NA | APL2 | |

Arctan NA2÷NA1. | ((NA1≠0)×¯3○NA2÷NA1+NA1=0)+○((NA1=0)×.5××NA2)+(NA1<0)×1-2×NA2<0 | FinnAPL | |

Arctangent of NA in radians. | FA←¯3○NA | APL2 | |

Are there less than N items in each dim? | B←N>⍴A | APL2 | |

Area of a polygon given X,Y endpoints. | NS←|.5×+/Y×(¯1⌽X)-1⌽X | APL2 | |

Area of a triangle given side length. | V←(×/(+/X÷2)-0,X)*.5 | 3=⍴X | APL2 |

Area of triangle with side lengths in NV (Heron's formula). | (×/(+/NV÷2)-0,NV)*.5 | 3 ←→ ⍴NQ | FinnAPL |

Arithmetic average (mean value). | (+/NV)÷⍴NV | FinnAPL | |

Arithmetic average (mean value) of NV1 weighted by NV2. | (NV2+.×NV1)÷⍴NV1 | FinnAPL | |

Arithmetic average (mean value), also for an empty array. | (+/,NA)÷1⌈⍴,NA | FinnAPL | |

Arithmetic precision of the system (in decimals). | ⌊|10⍟|1-3×÷3 | FinnAPL | |

Arithmetic progression from NS1 to NS2 with step NS3. | NS1+(NS3××NS2-NS1)×(⍳1+|⌊(NS2-NS1)÷NS3)-⎕IO | FinnAPL | |

Arithmetic progression of NS2 numbers from NS1 with step NS3. | NS1+NS3×(⍳NS2)-⎕IO | FinnAPL | |

Arithmetic progression vector. | N←X+NS×⍳IS | APL2 | |

Arithmetic progression vector. | N←X+NS×¯1+⍳IS | APL2 | |

Array and its negative ('plus minus'). | NA∘.×1 ¯1 | FinnAPL | |

Array and its negative ('plus minus'). | NA,[.5+⍴⍴NA]-NA | FinnAPL | |

Array with shape of XA and XV as its rows. | (⍴XA)⍴XV | FinnAPL | |

Ascending cardinal numbers (ranking, all different). | ⍋⍋NV | FinnAPL | |

Ascending cardinal numbers (ranking, shareable). | ⌊.5×(⍋⍋NV)+⌽⍋⍋⌽NV | FinnAPL | |

Ascending series of integers IS2…IS1 (for small IS2 and IS1). | (IS2-1)↓⍳IS1 | FinnAPL | |

ASCII sequence in HEX table. | C←16 16⍴⎕AV | APL2 | |

Assign value to A if not assigned. | ⍎(0=⎕NC 'A')/'A←1' | APL2 | |

Assign values of expressions in CM1 to variables named in CM2. | A←⍎,',','(','0','⍴',CM2,'←',CM1,')' | FinnAPL | |

Assigns MY-values to matrix of MX-names. | ⍎¨⊂[1]MX,'←',⍕MY | 0=⎕IO | APL2 |

Assigns MY-values to matrix of MX-names. | ⍎¨⊂[2]MX,'←',⍕MY | 1=⎕IO | APL2 |

Attach row numbers to a matrix. | M←(⍳≢M),M | APL2 | |

Average (mean value) of columns of matrix NM. | (+⌿NM)÷1↑(⍴NM),1 | FinnAPL | |

Average (mean value) of elements of NA along direction IS. | (+/[IS]NA)÷(⍴NA)[IS] | FinnAPL | |

Average (mean value) of rows of matrix NM. | (+/NM)÷¯1↑1,⍴NM | FinnAPL | |

Average (mean) of N. | AVG←(+/N)÷1⌈⍴N | APL2 | |

Avoiding division by zero error (gets value zero). | (0≠NA1)×NA2÷NA1+0=NA1 | FinnAPL | |

Avoiding parentheses by swapping arguments of FUNCTION F. | (1 F⍨ …) | FinnAPL | |

BA1 but not BA2. | BA1>BA2 | FinnAPL | |

BA1 implies BA2. | BA1≤BA2 | FinnAPL | |

Barchart of integer values (across the page). | ' ⎕'[⎕IO+IV∘.≥⍳⌈/IV] | FinnAPL | |

Barchart of integer values (down the page). | ' ⎕'[⎕IO+(⌽⍳⌈/IV)∘.≤IV] | FinnAPL | |

Barchart of NV with height NS (across the page). | ' ⎕'[⎕IO+NV∘.≥(⌈/NV)×(⍳NS)÷NS] | FinnAPL | |

Barchart of two integer series (across the page). | ' *○⍟'[⎕IO+2⊥IM∘.≥⍳⌈/,IM] | ≢IM ←→ 2 | FinnAPL |

Base 10 representation of a number. | IA←(¯1⌽⍳1+⍴⍴NA)⍉((1+⌊10⍟1⌈⌈/,NA)⍴10)⊤NA | APL2 | |

Base IS representation of a number. | IA←(¯1⌽⍳1+⍴⍴NA)⍉((1+⌊IS⍟1⌈⌈/,NA)⍴IS)⊤NA | APL2 | |

Best linear fit of points (NV1,NV2) (least squares). | NV2⌹NV1∘.*0 1 | FinnAPL | |

Beta function. | ÷NS2×(NS1-1)!NS2+NS1-1 | FinnAPL | |

Beta function. | N←÷Y×(X-1)!Y×X-1 | APL2 | |

Binary format of decimal number IS. | ⍕10⊥((1+⌈2⍟⌈/,IS)⍴2)⊤IS | FinnAPL | |

Binary matrix of (N,K) combinations. | M←⌽(K=+⌿M)/M←(N⍴2)⊤⍳1+2⊥N↑K⍴1 | APL2 | |

Binomial coefficients from 1-IS. | M←⍉(⍳1+IS)∘.!⍳1+IS | 0=⎕IO | APL2 |

Binomial coefficients from 1-IS. | M←⍉(0,⍳IS)∘.!0,⍳IS | 1=⎕IO | APL2 |

Binomial distribution of IS trials with probability NS. | (A!IS)×(NS*A)×(1-NS)*IS-A←-⎕IO-⍳IS+1 | FinnAPL | |

Binomial distribution of X trials at prob. Y. | N←(N!X)×(Y*N)×(1-Y)*X-N←⍳X+1 | 0=⎕IO | APL2 |

Binomial distribution of X trials at prob. Y. | N←(N!X)×(Y*N)×(1-Y)*X-N←¯1+⍳X+1 | 1=⎕IO | APL2 |

Blank rows. | ∧/' '=CM | FinnAPL | |

Boolean ending changes given # duped items. | B←(,(1-L),[.5]1)/1 | 0=⎕IO | APL2 |

Boolean ending changes given # duped items. | B←(,(1-L),[1.5]1)/1 | 1=⎕IO | APL2 |

Boolean ending changes given # duped items. | B←(1+⍳+/L)∊+\L | 0=⎕IO | APL2 |

Boolean ending changes given # duped items. | B←(⍳+/L)∊+\L | 1=⎕IO | APL2 |

Boolean expand length for headers. | B←2</0,(1+B)/B | APL2 | |

Boolean first item of each change in MG. | B←¯1↓1,∨/MG≠1⊖MG | APL2 | |

Boolean first ones in each group of ones. | B←2</0,B | APL2 | |

Boolean items in X that are not in Y. | B←~X∊Y | APL2 | |

Boolean L[i] gaps after each one. | B←(,1,[.5]-L)/1 | 0=⎕IO | APL2 |

Boolean L[i] gaps after each one. | B←(,1,[1.5]-L)/1 | 1=⎕IO | APL2 |

Boolean last item of each change in MG. | B←1↓(∨/MG≠¯1⊖MG),1 | APL2 | |

Boolean last ones in each group of ones. | B←2>/B,0 | APL2 | |

Boolean mask of CM containing VC. | BM←⊃∨/VC⍷¨⊂CM | APL2 | |

Boolean one at first occurrence of C in CA. | (,BA)←<\,BA←C⍷CA | APL2 | |

Boolean rows of CM containing C. | B←∨/C⍷CM | APL2 | |

Boolean rows of CM starting with C. | B←,1↑[0]C⍷CM | 0=⎕IO | APL2 |

Boolean rows of CM starting with C. | B←,1↑[1]C⍷CM | 1=⎕IO | APL2 |

Boolean rows of M all equal to scalar S. | B←M∧.=S | APL2 | |

Boolean rows of MVX containing MVY. | B←∨/MVX∧.(≡¨)⍉MVY | APL2 | |

Boolean rows of MX containing MY. | B←∨/MX∧.=⍉MY | APL2 | |

Boolean start changes given length vector L. | B←(,1,[.5]1-L)/1 | 0=⎕IO | APL2 |

Boolean start changes given length vector L. | B←(,1,[1.5]1-L)/1 | 1=⎕IO | APL2 |

Boolean start changes given length vector L. | B←(⍳+/L)∊+\0,L | 0=⎕IO | APL2 |

Boolean start changes given length vector L. | B←(⍳+/L)∊+\1,L | 1=⎕IO | APL2 |

Boolean start vector given position indices. | B←(≢M)↑(⍳⌈/P)∊P | APL2 | |

Boolean start vector to boolean end vector. | B←1⌽B | APL2 | |

Boolean starting changes given # duped items. | B←(⍳+/L)∊0,+\L | 0=⎕IO | APL2 |

Boolean starting changes given # duped items. | B←(⍳+/L)∊+\1,L | 1=⎕IO | APL2 |

Boolean test: All items in B equal? | BS←≠/0 1∊∊AB | APL2 | |

Boolean test: All items in B equal? | BS←AB≡1⌽AB | APL2 | |

Boolean test: All items in simple B equal? | BS←≠/0 1∊B | APL2 | |

Boolean test: Are all items in V equal? | BS←V∧.∊⊂⊃V | APL2 | |

Boolean test: Are all items in V equal? | BS←V≡1⌽V | APL2 | |

Boolean test: Are all items in V equal? | BS←V∧.=⊃V | 1=≡V | APL2 |

Boolean test: Are all items of V unique? | BS←(V⍳V)≡⍳⍴V | APL2 | |

Boolean test: Are all true? | BS←∧/B | APL2 | |

Boolean test: Are any true? | BS←∨/B | APL2 | |

Boolean test: Are none true? | BS←~∨/B | APL2 | |

Boolean test: Is A a nested array? | BS←1<|≡A | APL2 | |

Boolean test: Is A a scalar? | BS←0∊⍴⍴A | APL2 | |

Boolean test: Is A a simple array? | BS←1≥|≡A | APL2 | |

Boolean test: Is A a simple character array? | BS←A≡⍕A | APL2 | |

Boolean test: Is A a vector? | BS←1∊⍴⍴A | APL2 | |

Boolean test: Is A anti-symmetric? | BS←A≡-⍉A | APL2 | |

Boolean test: Is A empty? | BS←0∊⍴A | APL2 | |

Boolean test: Is A non-empty? | BS←0≠⍴,A | APL2 | |

Boolean test: Is A numeric? (if homogeneous). | BS←0=⊃0⍴A | APL2 | |

Boolean test: Is A simple numeric? | BS←(⊃0⍴⊂A)≡(⍴A)⍴0 | APL2 | |

Boolean test: Is A symmetric? | BS←A≡⍉A | APL2 | |

Boolean test: Is any element of N even? | BS←∨/~2|N | APL2 | |

Boolean test: Is AX identical to AY? | BS←AX≡AY | APL2 | |

Boolean test: Is B boolean? | BS←∧/∊B∊0 1 | APL2 | |

Boolean test: Is every element of N odd? | BS←∧/2|N | APL2 | |

Boolean test: Is every element of N positive? | BS←∧/N>0 | APL2 | |

Boolean test: Is every element of NA even? | BS←∧/∊~2|NA | APL2 | |

Boolean test: Is every element of NA integer? | BS←∧/∊NA=⌊NA | APL2 | |

Boolean test: Is first item largest? | BS←~×⊃⍒N | APL2 | |

Boolean test: Is first item largest? | BS←|/⍋N | APL2 | |

Boolean test: Is first item smallest? | BS←~×⊃⍋N | APL2 | |

Boolean test: Is first item smallest? | BS←|/⍒N | APL2 | |

Boolean test: Is IS prime? | BS←0=+/0=((2×IS≠2),2+2×⍳⌊.5×IS*.5)|IS | 0=⎕IO | APL2 |

Boolean test: Is IS prime? | BS←0=+/0=((2×IS≠2),1+2×⍳⌊.5×IS*.5)|IS | 1=⎕IO | APL2 |

Boolean test: Is N in ascending column order. | BS←∧⌿N=⌈⍀N | APL2 | |

Boolean test: Is N in ascending row order. | BS←∧/N=⌈\N | APL2 | |

Boolean test: Is N permutation of NX? | BS←N[⍋N]≡NX[⍋NX] | APL2 | |

Boolean test: Is N permutation vector? | BS←N[⍋N]≡1+⍳⍴N | 0=⎕IO | APL2 |

Boolean test: Is N permutation vector? | BS←N[⍋N]≡⍳⍴N | 1=⎕IO | APL2 |

Boolean test: Is V a valid APL name? | BS←¯1≠⎕NC V | APL2 | |

Boolean test: Is Y a subset of X? | BS←∧/,Y∊X | APL2 | |

Boolean test: Parity. | BS←≠/B | APL2 | |

Boolean vector of length IS with ones in locations IA. | (⍳IS)∊IA | FinnAPL | |

Boolean vector of length IS with zeroes in locations IA. | (~(⍳IS)∊IA) | FinnAPL | |

Branch to label on condition. | IS:→(100<NS←NS+1)/IS | APL2 | |

Branch to line in I of first true B. | →B/I | APL2 | |

Branch to line in position PS of I. | →PS⊃I | APL2 | |

Branch to offset IS from current line. | →⎕LC+IS | APL2 | |

Build array from boolean pattern. Insert S. | A←(' ',S)[BA] | 1=⎕IO | APL2 |

Build array from boolean pattern. Insert S. | A←(' ',S)[1+BA] | 0=⎕IO | APL2 |

Build array from boolean pattern. Insert V. | A←(' ',V)[BA×(⍴BA)⍴⍳⊃⌽⍴BA] | 1=⎕IO | APL2 |

Build array from boolean pattern. Insert V. | A←(' ',V)[1+BA×(⍴BA)⍴⍳⊃⌽⍴BA] | 0=⎕IO | APL2 |

Build array from boolean pattern. Reduce A. | A←↑⊃,/¨(⊂[1]BM)⊂¨⊂V | 0=⎕IO | APL2 |

Build array from boolean pattern. Reduce A. | A←↑⊃,/¨(⊂[2]BM)⊂¨⊂V | 1=⎕IO | APL2 |

Cartesian product: all pairs of AX, AY. | AV←AX∘.,AY | APL2 | |

Cascade NS-fold fill between two polygons. | VZ←(⊂ZX)+(⊂ZY-ZX)×(⍳NS+1)÷NS | 0=⎕IO | APL2 |

Cascade NS-fold fill between two polygons. | VZ←(⊂ZX)+(⊂ZY-ZX)×(0,⍳NS)÷NS | 1=⎕IO | APL2 |

Case structure according to key vector XV. | →IV[XV⍳XS] | FinnAPL | |

Case structure using levels with limits NV. | →(NS≥NV)/IV | FinnAPL | |

Case structure with an encoded branch destination. | →IV[1+2⊥BV] | FinnAPL | |

Case structure with integer switch. | →IS⌽IV | FinnAPL | |

Case structure with logical switch (preferring from start). | →BV/IV | FinnAPL | |

Catenating IS elements XA after every element of XV. | ,XV,((⍴XV),IS)⍴XA | FinnAPL | |

Catenating IS elements XS after indices IV in vector XV. | A←IS×⍴,IV ⋄ (XV,A⍴XS)[⍋(⍳⍴XV),A⍴IV] | FinnAPL | |

Catenating IS elements XS before every element of XV. | ,(((⍴XV),IS)⍴XS),XV | FinnAPL | |

Catenating IS elements XS before indices IV in vector XV. | A←IS×⍴,IV ⋄ ((A⍴XS),XV)[⍋(A⍴IV),⍳⍴XV] | FinnAPL | |

Centering C in field width NS. | C←(-⌊.5×0⌈NS-⍴C)⌽NS↑C | APL2 | |

Centering character array CA with only right edge ragged. | (-⌊0.5×+/∧\' '=⌽CA)⌽CA | FinnAPL | |

Centering character array CA with ragged edges. | (A-⌊0.5×(A←+/∧\⌽A)++/∧\A←' '=⌽CA)⌽CA | FinnAPL | |

Centering left justified CM. | CM←(-⌊.5×+/∧\⌽CM=' ')⌽CM | APL2 | |

Centering non-justified CM. | CM←(⌈.5×⊃-/+/¨∧\¨B(⌽B←CM=' '))⌽CM | APL2 | |

Centering right justified CM. | CM←(⌈.5×+/∧\CM=' ')⌽CM | APL2 | |

Centering text line CV into a field of width IS. | IS↑((⌊-/.5×IS,⍴CV)⍴' '),CV | FinnAPL | |

Centering text line CV into a field of width IS. | (-⌊.5×IS+⍴CV)↑CV | FinnAPL | |

Change A to scalar if it is simple. | ⍎(1=≡A)/'A←⊂A' | APL2 | |

Change A, only if it is scalar, to vector. | A←1/A | APL2 | |

Change scalars to vectors at depths 0-2. | A←1/¨A | APL2 | |

Change sign on condition B. | N←N×¯1*B | APL2 | |

Change X if new value given. | X←⊃(' '∨.≠V)↓X V←⍞ | APL2 | |

Changing an index origin dependent argument to act as ⎕IO=0. | ⎕IO+IA | FinnAPL | |

Changing an index origin dependent argument to act as ⎕IO=1. | (⎕IO-1)+IA | FinnAPL | |

Changing an index origin dependent result to be as ⎕IO=0. | -⎕IO-IA | FinnAPL | |

Changing an index origin dependent result to be as ⎕IO=1. | (~⎕IO)+IA | FinnAPL | |

Changing connection matrix IM (¯1 → 1) to a node matrix. | (1 ¯1∘.=⍉IM)+.×⍳≢⎕←IM | FinnAPL | |

Changing connectivity list CM to a connectivity matrix. | A←(×/B←0 0+⌈/,CM)⍴0 ⋄ A[⎕IO+B[1]⊥-⎕IO-CM]←1 ⋄ B⍴A | FinnAPL | |

Changing connectivity matrix CM to a connectivity list. | (,CM)/1+A⊤¯1+⍳×/A←⍴CM | FinnAPL | |

Changing index of an unfound element to zero. | (1+⍴XV)|XV⍳XA | FinnAPL | |

Changing index of an unfound element to zero (not effective). | (XA∊XV)×XV⍳XA | FinnAPL | |

Changing lengths IV of subvectors of XV to ending indicators. | (⍳⍴XV)∊(+\IV)-~⎕IO | FinnAPL | |

Changing lengths IV of subvectors of XV to starting indicators. | (⍳⍴XV)∊+\⎕IO,IV | FinnAPL | |

Changing lengths IV of subvectors to ending indicators. | (⍳+/IV)∊(+\IV)-~⎕IO | FinnAPL | |

Changing lengths IV of subvectors to starting indicators. | A←(+/IV)⍴0 ⋄ A[+\¯1↓⎕IO,IV]←1 ⋄ A | FinnAPL | |

Changing lengths IV of subvectors to starting indicators. | (⍳+/IV)∊+\⎕IO,IV | FinnAPL | |

Changing node matrix IM (starts,ends) to a connection matrix. | -/(⍳⌈/,IM)∘.=⍉IM | FinnAPL | |

Changing numeric code NA into corresponding name in NV. | CM[NV⍳NA;] | FinnAPL | |

Changing starting indicators BV of subvectors to lengths. | A-¯1↓0,A←(1⌽BV)/⍳⍴BV | FinnAPL | |

Changing XA if a new input value is given. | XA←⍎,((2↑'XA'),' ',[.5]A)[⎕IO+~' '∧.=A←⍞;] | FinnAPL | |

Check for input in range 1…XA. | (A←⎕)∊⍳XA | FinnAPL | |

Chipmunk. Selective picking from array. | A←PA⊃¨⊂A | APL2 | |

Choosing a string according to boolean value BS. | (BS/CV1),(~BS)/CV2 | FinnAPL | |

Choosing according to signum. | XV[2+×NA] | FinnAPL | |

Choosing IA1 objects out of ⍳IA2 with replacement (roll). | ?IA1⍴IA2 | FinnAPL | |

Choosing IS2 objects out of ⍳IS1 without replacement (deal). | IS2?IS1 | FinnAPL | |

Choosing sorting direction during execution. | ⍋NV×(¯1 1)[IS] | FinnAPL | |

Choosing sorting direction I +A, 0U, or -D. | NM←NM[⍋NM×I;] | APL2 | |

Classic version only: The character numbers (atomic vector index) corresponding to the characters in CA. | ⎕AV⍳CA | Dyalog | |

Classification of elements NV into IS classes of equal size. | +/(A×IS÷⌈/A←NV-⌊/NV)∘.≥¯1+⍳IS | FinnAPL | |

Classification of NV1 to classes starting with NV2. | A[(B/C)-⍴NV2]←B/+\~B←(⍴NV2)<C←⍋NV2,NV1+A←0×NV1 ⋄ A | NQ2<.≥1⌽NQ2 | FinnAPL |

Coefficients of exponential (curve) fit of points (NV1,NV2). | A←(⍟NV2)⌹NV1∘.*0 1 ⋄ A[1]←*A[1] ⋄ A | FinnAPL | |

Coefficients of the binomial. | N←(⍳1+IS)!IS | 0=⎕IO | APL2 |

Coefficients of the binomial. | N←(0,⍳IS)!IS | 1=⎕IO | APL2 |

Column averages of NM. | CAVE←(+⌿NM)÷1⌈≢NM | APL2 | |

Column averages of NM. (non-zero). | CAVG←(+⌿NM)÷1⌈+⌿0≠NM | APL2 | |

Column sum of a matrix. | +⌿NM | FinnAPL | |

Column table. Vectors to columns of matrix. | M←⍉↑VV | APL2 | |

Columnize rows of data separated by blanks. | CM←⍕↑(C≠' ')⊂¨C←⊂[1]CM | 0=⎕IO | APL2 |

Columnize rows of data separated by blanks. | CM←⍕↑(C≠' ')⊂¨C←⊂[2]CM | 1=⎕IO | APL2 |

Col-wise percentage per column. | N←100×NM÷[1]+⌿NM | 0=⎕IO | APL2 |

Col-wise percentage per column. | N←100×NM÷[2]+⌿NM | 1=⎕IO | APL2 |

Combinations of N things taken K ways. | C←K!N | APL2 | |

Combine 2 arrays along their last dimension. | A←↑,/AX,⊂AY | APL2 | |

Comparing vector XV with rows of array XA. | XA∧.=XV | FinnAPL | |

Comparison of successive rows. | ∧/XM=1⊖XM | FinnAPL | |

Comparison table. | IV∘.≥⍳⌈/IV,0 | FinnAPL | |

Complementary angle (arccos sin NS). | ○/¯2 1,NS | FinnAPL | |

Compound interest for principals NA2 at rates NA3 % in times NA1. | NA2∘.×(1+NA3÷100)∘.*NA1 | FinnAPL | |

Compound interest: IA prds, FA int, NA prn. | A←NA∘.×(1+FA)∘.*IA | APL2 | |

Conditional branch depending on sign of IS. | →IV[2+×IS] | FinnAPL | |

Conditional branch out of program. | →0⌊⍳BS | FinnAPL | |

Conditional branch out of program. | →0×⍳BS | FinnAPL | |

Conditional branch out of programs. | ⍎BS/'→' | FinnAPL | |

Conditional branch to line IS. | →IS⌈⍳BS | IS>0 | FinnAPL |

Conditional change of elements of NA to one according to BA. | NA*~BA | FinnAPL | |

Conditional drop of IV elements from array XA. | (IV×BV)↓XA | FinnAPL | |

Conditional drop of last element of XV. | (-BS)↓XV | FinnAPL | |

Conditional elementwise change of sign. | NA×(1 ¯1)[1+BA] | 1=⎕IO | FinnAPL |

Conditional elementwise change of sign. | NA×¯1*BA | 0=⎕IO ⋄ ⍴NA ←→ ⍴BA | FinnAPL |

Conditional execution. | ⍎BS/'EXPRESSION' | FinnAPL | |

Conditional execution. | ⍎BS↓'⍝ …' | FinnAPL | |

Conditional execution of monadic function. | fn¨BS/⊂A | APL2 | |

Conditional in text. | ((~BS)/'IN'),'CORRECT' | FinnAPL | |

Consecutive integers from IS1 to IS2 (arithmetic progression). | (IS1-⎕IO)+⍳1+IS2-IS1 | FinnAPL | |

Continued fraction. | 1+÷2+÷3+÷4+÷5+÷6+÷ … | FinnAPL | |

Continuing from line IS (if NS>0) or exit. | →IS××NS | FinnAPL | |

Contour levels NV at points with altitudes NS. | NV[+⌿NV∘.≤NS] | FinnAPL | |

Conversion from characters to numeric codes. | ⎕AV⍳XA | FinnAPL | |

Conversion from decimal to hexadecimal. | ⍉'0123456789ABCDEF'[⎕IO+((⌈⌈/16⍟,IA)⍴16)⊤IA] | IA∊⍳255 | FinnAPL |

Conversion from degrees to radians. | NA×○÷180 | FinnAPL | |

Conversion from hexadecimal to decimal. | 16⊥-⎕IO-'0123456789ABCDEF'⍳⍉CA | FinnAPL | |

Conversion from radians to degrees. | NA×180÷○1 | FinnAPL | |

Conversion of alphanumeric string into numeric. | 10⊥¯1+⎕D⍳CV | FinnAPL | |

Conversion of characters to hexadecimal representation (⎕AV). | ,' ',⍉'0123456789ABCDEF'[⎕IO+16 16⊤-⎕IO-⎕AV⍳CV] | FinnAPL | |

Conversion of each row to a number (default zero). | (CM∨.≠' ')\1↓⍎'0 ',,CM,' ' | FinnAPL | |

Conversion of indices IM of array XA to indices of raveled XA. | ⎕IO+(⍴XA)⊥IM-⎕IO | FinnAPL | |

Conversion of set of positive integers IV to a mask. | (⍳⌈/IV)∊IV | FinnAPL | |

Convert binary to character. | C←⎕UCS 2⊥¨((⌈.125×⍳⍴B)⊂B | APL2 | |

Convert binary to integer. | IS←2⊥B | APL2 | |

Convert character matrix to numeric vector. | N←1↓⍎'0',',',CM | APL2 | |

Convert character or numeric data into numeric. | ⍎⍕XV | FinnAPL | |

Convert character to binary. | B←,⍉(8⍴2)⊤⎕UCS C | APL2 | |

Convert character to hex. | H←(⎕D,⎕A)[,⍉16 16⊤⎕UCS C] | 0=⎕IO | APL2 |

Convert character to hex. | H←(⎕D,⎕A)[1+,⍉16 16⊤⎕UCS C] | 1=⎕IO | APL2 |

Convert character to numeric. | I←10⊥⎕D⍳C | APL2 | |

Convert character to numeric. | I←10⊥¯1+⎕D⍳C | APL2 | |

Convert character to Unicode/ASCII positions. | I←⎕UCS C | APL2 | |

Convert character vector to vector of digits. | I←⍎¨C | APL2 | |

Convert double words to integer. | I←(256⊥⍉I)-(256*4)×128≤,1↑[1]I←⎕UCS C | 0=⎕IO | APL2 |

Convert double words to integer. | I←(256⊥⍉I)-(256*4)×128≤,1↑[2]I←⎕UCS C | 1=⎕IO | APL2 |

Convert from AX, AY coordinates to radians. | NA←12○AX+¯11○AY | APL2 | |

Convert from degrees to radians. | NA←NA×○÷180 | APL2 | |

Convert from NA pairs to radians. | NA←12○0J1⊥⊖NA | 2=≢NA | APL2 |

Convert from radians to degrees. | NA←NA×180÷○1 | APL2 | |

Convert halfword to float. | M←(256⊥1↓[0]N)×(×128-M)×16*¯63⌈¯70+128|M←1↑[0]N | 0=⎕IO | APL2 |

Convert halfword to float. | M←(256⊥1↓[1]N)×(×128-M)×16*¯63⌈¯70+128|M←1↑[1]N | 1=⎕IO | APL2 |

Convert hex to binary char. | C←∊4↑¨('FEC80124936DA5B7'⍳H)⌽¨⊂'1111000010011010' | 0=⎕IO | APL2 |

Convert hex to binary char. | C←∊4↑¨('FEC80124936DA5B7'⍳H)⌽¨⊂'0111100001001101' | 1=⎕IO | APL2 |

Convert integer to binary. | BM←⍉((1+⌊2⍟1⌈⌈/I)⍴2)⊤I | APL2 | |

Convert integers to double words. | C←⎕UCS⍉(4⍴256)⊤I+(256*4)×I<0 | APL2 | |

Convert non-empty CA to NA - rank ≥1. | NA←↑⍎¨⊂[¯1+⍴⍴CA]',',CA | 0=⎕IO | APL2 |

Convert non-empty CA to NA - rank ≥1. | NA←↑⍎¨⊂[⍴⍴CA]',',CA | 1=⎕IO | APL2 |

Convert non-empty CM to numeric vector. | NM←↑⍎¨⊂[1]',',CM | 0=⎕IO | APL2 |

Convert non-empty CM to numeric vector. | NM←↑⍎¨⊂[2]',',CM | 1=⎕IO | APL2 |

Convert rows of digits to base 10. | I←10⊥⍉M | APL2 | |

Convert to numeric, throw out characters. | I←1↓⍎'0 ',(C∊' ',⎕D)/C | APL2 | |

Coordinates of A corresponding to offsets P. | PM←⍉(⍴A)⊤P | APL2 | |

Coordinates of A corresponting to offsets P. | PM←1+⍉(⍴A)⊤P-1 | APL2 | |

Copies. Create IS copies of C. | C←(IS×⍴C)⍴C | APL2 | |

Corner element of a (non-empty) array. | 1⍴XA | FinnAPL | |

Cosine of NA in radians. | FA←2○NA | APL2 | |

Count of leading ones. | B←+/∧\B | APL2 | |

Count of the number of Ys in each row of AX. | A←AX+.∊Y | APL2 | |

Counting pairwise matches (equal elements) in two vectors. | XV1+.=XV2 | FinnAPL | |

Create a histogram from numeric vector. | CM←↑(⌊N)⍴¨'*' | APL2 | |

Create col header CM for NS wide text. | CM←1 0⍕10 10⊤⍳NS | APL2 | |

Cumulative maxima (⌈\) of subvectors of NV indicated by BV. | NV[A⍳⌈\A←⍋A[⍋(+\BV)[A←⍋NV]]] | FinnAPL | |

Cumulative minima (⌊\) of subvectors of NV indicated by BV. | NV[A⍳⌈\A←⍋A[⍋(+\BV)[A←⍒NV]]] | FinnAPL | |

Cumulative sum. | #NAME? | FinnAPL | |

Cumulative sums (+\) over subvectors of NV indicated by BV. | #NAME? | FinnAPL | |

Cumulative sums. | N←+\N | APL2 | |

Current European date - DD/MM/YYYY. | C←'56/06/0005'⍕⎕TS[⌽⍳3] | APL2 | |

Current European date and time. | C←'56/06/0005 06:06:05'⍕⎕TS[(⌽⍳3),3+⍳3] | APL2 | |

Current time - HH:MM:SS. | C←'06:06:05'⍕3↑3↓⎕TS | APL2 | |

Current US date - MM/DD/YYYY. | C←'56/06/0005'⍕⎕TS[1⌽⍳3] | APL2 | |

Current US date and time. | C←'56/06/0005 06:06:05'⍕⎕TS[(1⌽⍳3),3+⍳3] | APL2 | |

CV without any leading blank spaces. | {(∨\' '≠⍵)/⍵}CV | Dyalog | |

CV without any leading blank spaces. | {(+/∧\' '=⍵)↓⍵}CV | Dyalog | |

Date IS (YYYYMM) given IS months from "0". | IS←1+0 100⊥0 12⊤IS-1 | APL2 | |

Decimal to hex. | H←(⎕D,⎕A)[,⍉((1+⌊16⍟1⌈⌈/,N)⍴16)⊤N] | 0=⎕IO | APL2 |

Decimal to hex. | H←(⎕D,⎕A)[1+,⍉((1+⌊16⍟1⌈⌈/,N)⍴16)⊤N] | 1=⎕IO | APL2 |

Decoding numeric code ABBCCC into a matrix. | 10 100 1000⊤IA | FinnAPL | |

Decommenting a matrix representation of a function (⎕CR). | (∨/A)⌿(⍴CM)⍴(,A)\(,A←∧\('⍝'≠CM)∨≠\CM='''')/,CM | FinnAPL | |

Decommenting the ⎕CR of a function. | ((~,∧\('⍝'≠CM)∨≠\CM='''')/,CM)←' ' | APL2 | |

Decrease rank of A by 1. | AV←⊂[¯1+(0≠⍴⍴A)/⍴⍴A]A | 0=⎕IO | APL2 |

Decrease rank of A by 1. | AV←⊂[(0≠⍴⍴A)/⍴⍴A]A | 1=⎕IO | APL2 |

Decrease rank of A by 1. Rank 2 or higher. | A←,[2↑⍳⍴⍴A]A | APL2 | |

Definite integral of XV(X) in range NV with NS steps ('X'∊XV). | A+.×⍎XV,0⍴X←NV[1]+(A←--/NV÷NS)×0,⍳NS | ⍴NQ ←→ 2 | FinnAPL |

Demote floating point representations to integers. | ⌊IA | FinnAPL | |

Demote non-boolean representations to booleans. | 0∨BA | FinnAPL | |

Depth of parentheses. | +\('('=CV)-¯1↓0,')'=CV | FinnAPL | |

Depth of parenthesis. | I←+\(C='(')-¯1↓0,C=')' | APL2 | |

Derivate of polynomial NV. | ¯1↓NV×⌽¯1+⍳⍴NV | FinnAPL | |

Descending cardinal numbers (ranking, all different). | ⍋⍒NV | FinnAPL | |

Diagonal matrix with elements of NV. | 0 ¯1↓(-⍳⍴NV)⌽((2⍴⍴NV)⍴0),NV | FinnAPL | |

Diagonal ravel. | (,XA)[⍋+⌿(⍴XA)⊤(⍳⍴,XA)-⎕IO] | FinnAPL | |

Difference of sets. Elements of X not in Y. | V←X~Y | APL2 | |

Differences of successive elements of NA along direction IS. | NA-(-IS=⍳⍴⍴NA)↓0,[IS]NA | FinnAPL | |

Digits of IS separately. | ((1+⌊10⍟IS)⍴10)⊤IS | FinnAPL | |

Direct matrix product. | 1 3 2 4⍉NM1∘.×NM2 | FinnAPL | |

Display vector of vectors vertically. | ,['']VV | APL2 | |

Distribution of NA into intervals between NV. | +/((¯1↓NV)∘.≤NA)∧(1↓NV)∘.>NA | FinnAPL | |

Divisibility table. | 0=(⍳⌈/IV)∘.|IV | FinnAPL | |

Division to IS classes with width NS2, minimum NS1. | +/(⍳IS)∘.=⌈(NA-NS1)÷NS2 | FinnAPL | |

Division. Avoid DOMAIN ERROR for N÷0. | NA←AX÷AY+AY=0 | APL2 | |

Division. Force DOMAIN ERROR for 0÷0. | NA←AX×÷AY | APL2 | |

Divisors of IS. | (0=A|IS)/A←⍳IS | FinnAPL | |

Does each row contain only items from C? | B←CM∧.∊C | APL2 | |

Does vector V have less than NS items? | BO←NS>⍴V | APL2 | |

Doubles each occurrence of X within V. | V←(1+V∊X)/V | APL2 | |

Doubles quotes in an expression. | C←'''',((1+C='''')/C),'''' | APL2 | |

Doubling quotes (for execution). | (CV,'''')[(⎕IO+⍴CV)⌊⍋(⍳⍴CV),(''''=CV)/⍳⍴CV] | FinnAPL | |

Drop of IS first columns from matrix XM. | (0,IS)↓XM | FinnAPL | |

Drop of IS first rows from matrix XM. | (2↑IS)↓XM | FinnAPL | |

Drop of IS first rows from matrix XM. | (IS,0)↓XM | FinnAPL | |

Duplicate items in vector V, L times. | V←L/V | APL2 | |

Duplicate vector V, LS times. | M←LS⌿,[¯.5]V | 0=⎕IO | APL2 |

Duplicate vector V, LS times. | M←LS⌿,[.5]V | 1=⎕IO | APL2 |

Duplicate vector V, LS times. | V←(LS×⍴V)⍴V | APL2 | |

Duplicating element of XV belonging to BV,1↑XV until next found. | XV[1⌈⌈\BV×⍳⍴BV] | FinnAPL | |

Duplicating vector XV IS times. | (IS×⍴XV)⍴XV | FinnAPL | |

Editing CV1 with CV2 '-wise. | ((~(⍴A↑CV1)↑'/'=CV2)/A↑CV1),(1↓A↓CV2),(A←+/∧\CV2≠',')↓CV1 | FinnAPL | |

Elements of NV divisible by Y. | (0=Y|NV)/NV | FinnAPL | |

Elements of XV not in XA (difference of sets). | (~XV∊XA)/XV | FinnAPL | |

Empty matrix. | 0⌿XM | FinnAPL | |

Empty numeric vector. | ⍬ | FinnAPL | |

Encoding current date. | 100⊥100|3↑⎕TS | FinnAPL | |

Ending points for IS1 fields of width IS2. | (IS1×IS2)⍴(-IS2)↑1 | FinnAPL | |

Ending points for XV in indices pointed by IV. | 1⌽(⍳⍴XV)∊IV | FinnAPL | |

Ending points of groups of equal elements (non-empty XV). | ((1↓XV)≠¯1↓XV),1 | FinnAPL | |

Enlist - top down. Remove highest nesting. | A←,↑AA | APL2 | |

Entering from terminal data exceeding input (printing) width. | NA←0 2 1 2 5 8 0 4 5,⎕ | FinnAPL | |

Euler's idiom (accurate when NA is a multiple of 0J0.5). | *○NA | Dyalog | |

Eval. asc. ord. N-coeff poly. at points NA. | N←(,['']NA)⊥⌽N | APL2 | |

Eval. dec. ord. N-coeff poly. at points NA. | N←(,['']NA)⊥N | APL2 | |

Evaluating a three row determinant. | NS←-/+/¨×⌿¨(1 ¯1×⊂0 1 2)⌽¨⊂M | APL2 | |

Evaluating a two row determinant. | NS←-/×⌿0 1⌽M | APL2 | |

Evaluating a two-row determinant. | -/×/0 1⊖NM | FinnAPL | |

Evaluating a two-row determinant. | -/×⌿0 1⌽NM | FinnAPL | |

Evaluation of several expressions; results form a vector. | ⍎,',','(',',',XA,')' | FinnAPL | |

Exclusive or. | BA1≠BA2 | FinnAPL | |

Execute each with prototype of CSV. | V←1↓⍎¨CSV,VV | APL2 | |

Execute statement PS in VV of statements. | A←⍎PS⊃VV | APL2 | |

Execute which works on empty vector. | V←1↓⍎'0 ',V | APL2 | |

Executing costly monadic function F on repetitive arguments. | (F A/XV)[+\A←(XV⍳XV)=⍳⍴XV] | FinnAPL | |

Execution of expression NV with default value Y. | ⍎((NV∧.=' ')/'Y'),NV | FinnAPL | |

EXIT. Leave all levels of program. | → | APL2 | |

Expand N, but change fill item to NS. | N←(NS×~B)+B\N | APL2 | |

Expand N, but change fill item to one. | N←(~B)+B\N | APL2 | |

Expand V given length vector L. | V←(,L∘.≥⍳⌈/L)\V | APL2 | |

Expansion vector with zero after indices IV. | (⍴NV)≥⍋(⍳⍴NV),IV | FinnAPL | |

Expansion vector with zero after indices IV. | ~(⍳(⍴IV)+⍴XV)∊IV+⍳⍴IV | FinnAPL | |

Extending a distance table to next leg. | NM←NM⌊.+NM | FinnAPL | |

Extending a transitive binary relation. | BM←BM∨.∧BM | FinnAPL | |

Field lengths of vector XV; IV ←→ ending indices. | IV-¯1↓0,IV←(~⎕IO)+(((1↓XV)≠¯1↓XV),1)/⍳⍴XV | FinnAPL | |

Field width ≤NS of fractional part of number. | IA←+⌿NA≠⌊NA←(10*⍳NS)∘.×NA | 0=⎕IO | APL2 |

Field width ≤NS of fractional part of number. | IA←+⌿NA≠⌊NA←(10*-1-⍳NS)∘.×NA | 1=⎕IO | APL2 |

Field width for integral part of number. | IA←1+⌊10⍟1⌈NA | APL2 | |

Fifo stock NV decremented with NS units. | A-¯1↓0,A←0⌈(+\NV)-NS | FinnAPL | |

Filling XV with last element of XV to length IS. | IS↑XV,IS⍴¯1↑XV | FinnAPL | |

Find description of VY from VX index to VVX. | VVY←(VVX,' ')[VX⍳VY] | APL2 | |

Find functions that contain string C. | CM←(1∊¨(⊂C)⍷¨⎕CR¨⊂[1]CM)⌿CM←⎕NL 3 | 0=⎕IO | APL2 |

Find functions that contain string C. | CM←(1∊¨(⊂C)⍷¨⎕CR¨⊂[2]CM)⌿CM←⎕NL 3 | 1=⎕IO | APL2 |

Find the exponent of NA such that NA*FA = A. | FA←NA⍟A | APL2 | |

Finds the rows of CM containing C. | CM←(∨/C⍷CM)⌿CM | APL2 | |

Finds the rows of CM that start with C. | CM←(,1↑[1]C⍷CM)⌿CM | 0=⎕IO | APL2 |

Finds the rows of CM that start with C. | CM←(,1↑[2]C⍷CM)⌿CM | 1=⎕IO | APL2 |

Finds word number NS in C. | C←NS⊃(C≠' ')⊆C | APL2 | |

First column as a matrix. | XM[;,1] | FinnAPL | |

First column as a vector. | XM[;1] | FinnAPL | |

First group of ones. | BA∧∧\BA=∨\BA | FinnAPL | |

First IS figurative numbers. | I←+\+\1+⍳IS | 0=⎕IO | APL2 |

First IS figurative numbers. | I←+\+\⍳IS | 1=⎕IO | APL2 |

First IS triangular numbers. | I←+\1+⍳IS | 0=⎕IO | APL2 |

First IS triangular numbers. | I←+\⍳IS | 1=⎕IO | APL2 |

First occurrence of string XV in matrix XM. | (XM∧.=XV)⍳1 | ¯1↑⍴XM ←→ ⍴XV | FinnAPL |

First occurrence of string XV1 in string XV2. | (∧⌿(¯1+⍳⍴XV1)⌽XV1∘.=XV2)⍳1 | FinnAPL | |

First one (<\) in each subvector of BV2 indicated by BV1. | (BV2∧BV1)∨(BV2∨BV1)\A>¯1↓0,A←(BV2∨BV1)/BV2 | FinnAPL | |

First one (turn off all ones after first one). | <\BA | FinnAPL | |

First ones in groups of ones. | BA>((-⍴⍴BA)↑¯1)↓0,BA | FinnAPL | |

First ones in groups of ones. | BV>¯1↓0,BV | FinnAPL | |

First part of numeric code ABBB. | ⌊IA÷1000 | FinnAPL | |

First word in CV. | (¯1+CV⍳' ')↑CV | FinnAPL | |

Force 0÷0 into DOMAIN ERROR in division. | NA2×÷NA1 | FinnAPL | |

Force each item to same shape by overtake. | AV←(⌈/⍴¨AV)↑¨AV | APL2 | |

Force each item to same shape by reshape. | AA←(⌈/(-⌈/⍴¨⍴¨AA)↑¨⍴¨AA)⍴¨AA | APL2 | |

Force N numbers to range 0≤N≤NS. | N←0⌈NS⌊N | APL2 | |

Force to 0 any N greater than NS. | N←N×N≤NS | APL2 | |

Force to 0 any N less than NS. | N←N×NS≤N | APL2 | |

For-loop ending construct. | →IS2⌈⍳IS3≥IS1←IS1+1 | FinnAPL | |

Format and right justify columns of report. | CM←1↓[0]⍕0,[0]AA | 0=⎕IO | APL2 |

Format and right justify columns of report. | CM←1↓[1]⍕0,[1]AA | 1=⎕IO | APL2 |

Format and right justify NS wide columns. | CM←1↓[0](NS,0)⍕0,[0]AA | 0=⎕IO | APL2 |

Format and right justify NS wide columns. | CM←1↓[1](NS,0)⍕0,[1]AA | 1=⎕IO | APL2 |

Formatting a numerical vector to run down the page. | ⍕NV∘.+,0 | FinnAPL | |

Formatting NA with IV2 decimals in fields of width IV1. | (,IV1,[1.1]IV2)⍕NA | FinnAPL | |

Formatting with zero values replaced with blanks. | (⍴A)⍴B\(B←,('0'≠A)∨' '≠¯1⌽A)/,A←' ',⍕XA | FinnAPL | |

Forming a IS-row matrix with all rows alike (XV). | (IS,⍴XV)⍴XV | FinnAPL | |

Forming a transitive closure. | →⎕LC⌈⍳∨/,(BM←BM∨BM∨.∧BM)≠+BM | FinnAPL | |

Forming a two-column matrix. | XV1,[1.1]XV2 | FinnAPL | |

Forming a two-row matrix. | XV1,[.1]XV2 | FinnAPL | |

Forming an initially empty array to be expanded. | 0 80⍴0 | FinnAPL | |

Forming first row of a matrix to be expanded. | 1 80⍴80↑XV | FinnAPL | |

Fractional part. | 1|NA | FinnAPL | |

Fractional part of number with sign. | FA←(×NA)|NA | APL2 | |

Fractional part of number. | FA←1|NA | APL2 | |

Fractional part with sign. | (×NA)|NA | FinnAPL | |

Framing. | '_',[1]('|',CM,'|'),[1]'¯' | FinnAPL | |

Framing CM in a box. | CM←'|',('¯',[0]CM,[0]'_'),'|' | 0=⎕IO | APL2 |

Framing CM in a box. | CM←'|',('¯',[1]CM,[1]'_'),'|' | 1=⎕IO | APL2 |

Frequency of X in Y. | N←+/X∘.=Y | APL2 | |

From complex to magnitude and radians. | A←10 12∘.○ZA | 2=≢A | APL2 |

From magnitude AX and degrees AY to complex. | ZA←AX×¯12○○AY÷180 | APL2 | |

From magnitude AX and radians AY to complex. | ZA←AX×¯12○AY | APL2 | |

From nested to simple char image. | CM←⍕⊂1/AA | APL2 | |

Future value of cash flows NA at int FS. | A←(1+FS)⊥NA | APL2 | |

Future value of cash flows NV at interest rate NS %. | (1+NS÷100)⊥NV | FinnAPL | |

Gamma function. | !NS-1 | FinnAPL | |

Gamma function. | N←!N-1 | APL2 | |

Get (N+1)th item in vector V. | S←⊃N↓V | APL2 | |

Get angle (deg) of real AX and imaginary AY. | NA←(180÷○1)×12○AX+¯11○AY | APL2 | |

Get angle (rad) of real AX and imaginary AY. | NA←12○AX+¯11○AY | APL2 | |

Get angle in degrees of A. | NA←(180÷○1)×12○0J1⊥⊖A | APL2 | |

Get angle in radians of A. | NA←12○0J1⊥⊖A | 2=≢A (x,y) pairs | APL2 |

Get magnitude of A. | NA←|0J1⊥⊖A | 2=≢A (x,y) pairs | APL2 |

Get magnitude of AX, AY coordinates. | NA←|AX+¯11○AY | APL2 | |

Get magnitude of NA pairs. | NA←|0J1⊥⊖NA | 2=≢NA | APL2 |

Get magnitude of real AX and imaginary AY. | NA←|AX+¯11○AY | 2=≢A (x,y) pairs | APL2 |

Ghost Buster. Inc rank by one on last dim. | A←,['']A | APL2 | |

Giving a character default value for input. | 1↑⍞,CS | FinnAPL | |

Giving a numeric default value for input. | 1⍴(⍎⍞,',⍬'),NS | FinnAPL | |

Grade down (⍒) for sorting subvectors of NV having lengths IV. | A[⍋(+\(⍳⍴NV)∊+\⎕IO,IV)[A←⍒NV]] | ⍴NQ ←→ +/IV | FinnAPL |

Grade down (⍒) for sorting subvectors of NV indicated by BV. | A[⍋(+\BV)[A←⍒NV]] | FinnAPL | |

Grade up (⍋) for sorting subvectors of NV having lengths IV. | A[⍋(+\(⍳⍴NV)∊+\⎕IO,IV)[A←⍋NV]] | ⍴NQ ←→ +/IV | FinnAPL |

Grade up (⍋) for sorting subvectors of NV indicated by BV. | A[⍋(+\BV)[A←⍋NV]] | FinnAPL | |

Grade up according to key XV1. | ⍋XV1⍳XV2 | FinnAPL | |

Graph of XV(NV) at points NV ('NV'∊XV). | ' *'[⎕IO+(⌽(¯1+⌊/A)+⍳1+(⌈/A)-⌊/A)∘.=A←⌊.5+⍎XV] | FinnAPL | |

Gray code or reflected binary. Inverse of ≠\. | B←2≠/0,B | APL2 | |

Greatest common divisor of elements of IV. | ⌈/(∧/0=A∘.|IV)/A←⍳⌊/IV | FinnAPL | |

Greatest common divisor of vector I. | IS←⌈/(∧/0=V∘.|I)/V←1+⍳⌊/I | 0=⎕IO | APL2 |

Greatest common divisor of vector I. | IS←⌈/(∧/0=V∘.|I)/V←⍳⌊/I | 1=⎕IO | APL2 |

Groups of ones in BA2 pointed to by BA1 (or trailing parts). | BA2∧A=⌈\BA1×A←+\BA2>¯1↓0,BA2 | FinnAPL | |

Groups of ones in BV2 pointed to by BV1. | BV2∧A∊(BV1∧BV2)/A←+\BV2>¯1↓0,BV2 | FinnAPL | |

Handling array XA temporarily as a vector. | (⍴XA)⍴ … ,XA | FinnAPL | |

Helps locating column positions 1…IS. | 1 0⍕10 10⊤1-⎕IO-⍳IS | FinnAPL | |

Hex to Dec. | I←16⊥¨(⌈.5×(2|⍴H)+1+⍳⍴H)⊆(⎕D,⎕A)⍳H | 0=⎕IO | APL2 |

Hex to Dec. | I←16⊥¨(⌈.5×(2|⍴H)+⍳⍴H)⊆16|(⎕D,⎕A)⍳H | 1=⎕IO | APL2 |

Hex/Char. | C←⎕UCS 16⊥¨(⌈.5×(2|⍴H)+1+⍳⍴H)⊆(⎕D,⎕A)⍳H | 0=⎕IO | APL2 |

Hex/Char. | C←⎕UCS 16⊥¨(⌈.5×(2|⍴H)+⍳⍴H)⊆16|(⎕D,⎕A)⍳H | 1=⎕IO | APL2 |

Hilbert matrix of order IS. | ÷¯1+(⍳IS)∘.+⍳IS | FinnAPL | |

Hilbert matrix of order IS. | M←÷1+(⍳IS)∘.+⍳IS | 0=⎕IO | APL2 |

Hilbert matrix of order IS. | M←÷¯1+(⍳IS)∘.+⍳IS | 1=⎕IO | APL2 |

Histogram (distribution barchart; down the page). | ' ⎕'[⎕IO+(⌽⍳⌈/A)∘.≤A←+/(⍳1+(⌈/IV)-⌊/IV)∘.=IV] | FinnAPL | |

Hyperbolic Arccosine of NA in radians. | FA←¯6○NA | APL2 | |

Hyperbolic Arcsine of NA in radians. | FA←¯5○NA | APL2 | |

Hyperbolic Arctangent of NA in radians. | FA←¯7○NA | APL2 | |

Hyperbolic Cosine of NA in radians. | FA←6○NA | APL2 | |

Hyperbolic Sine of NA in radians. | FA←5○NA | APL2 | |

Hyperbolic Tangent of NA in radians. | FA←7○NA | APL2 | |

I random boolean numbers. | BA←?I⍴2 | 0=⎕IO | APL2 |

I random boolean numbers. | BA←¯1+?I⍴2 | 1=⎕IO | APL2 |

Identity matrix of shape of matrix NM. | (⍴NM)⍴1,0×NM | FinnAPL | |

Identity matrix: IS by IS. | M←IS IS⍴1,IS⍴0 | APL2 | |

Identity matrix: IS by IS. | M←⊃⌹/0⍴⊂IS⍴0 | APL2 | |

Identity matrix: IS by IS. | M←(⍳IS)∘.=⍳IS | APL2 | |

Identity of two sets. | ∧/(XV1∊XV2),XV2∊XV1 | FinnAPL | |

IF NOT. Branch if condition B false. | →IS×1~B | APL2 | |

If Then/Else. | A←⍎⊃BS↓'else part' 'then part' | APL2 | |

IF. Branch on condition B. | →IS+0~B | APL2 | |

Increase rank by one after dim IS. | A←,[IS+.5]A | APL2 | |

Increase rank by one on the first dim. | A←,[¯.5]A | 0=⎕IO | APL2 |

Increase rank by one on the first dim. | A←,[.5]A | 1=⎕IO | APL2 |

Increase rank of AX to rank of AY. | A←((-⍴⍴AY)↑((⍴⍴AY)⍴1),⍴AX)⍴AX | APL2 | |

Increasing absolute value without change of sign. | (×NA1)×NA2+|NA1 | FinnAPL | |

Increasing rank of XA2 to rank of XA1. | ((((⍴⍴XA1)-⍴⍴XA2)⍴1),⍴XA2)⍴XA2 | FinnAPL | |

Increasing the dimension of XV to multiple of IS. | XV,(IS|-⍴XV)↑0/XV | FinnAPL | |

Incrementing cyclic counter NA with upper limit NS. | 1+NS⊤NA | FinnAPL | |

Index Generator with step IS. From X to Y. | N←X+IS×⍳0⌈(IS≠0)+⌊(Y-X)÷IS | 0=⎕IO | APL2 |

Index Generator with step IS. From X to Y. | N←X+IS×¯1+⍳0⌈(IS≠0)+⌊|(Y-X)÷IS | 1=⎕IO | APL2 |

Index Generator. Range from X to Y. | N←X+(×N)×⍳1+⌊|N←Y-X | 0=⎕IO | APL2 |

Index Generator. Range from X to Y. | N←X+0,(×N)×⍳⌊|N←Y-X | 1=⎕IO | APL2 |

Index of (first) maximum element of NV. | NV⍳⌈/NV | FinnAPL | |

Index of (first) minimum element of NV. | 1↑⍋NV | FinnAPL | |

Index of (first) minimum element of NV. | NV⍳⌊/NV | FinnAPL | |

Index of first differing element in vectors XV1 and XV2. | (XV2≠XV1)⍳1 | FinnAPL | |

Index of first maximum element of NV. | 1↑⍒NV | FinnAPL | |

Index of first non-blank, counted from the rear. | (' '=CV)⊥1 | FinnAPL | |

Index of first occurrence of elements of CV2. | ⌊/CV1⍳CV2 | FinnAPL | |

Index of first occurrence of XA in XV (circularly) after IS. | ⎕IO+(⍴XV)|IS+(IS⌽XV)⍳XA | FinnAPL | |

Index of first occurrences of rows of XA as rows of XM. | ⎕IO++⌿∧⍀XM∨.≠⍉XA | FinnAPL | |

Index of first one after index IS in BV. | IS+(IS↓BV)⍳1 | FinnAPL | |

Index of first satisfied condition in BV. | BV⍳1 | FinnAPL | |

Index of key XA in key vector XV. | XV⍳XA | FinnAPL | |

Index of last maximum element of NV. | ¯1↑⍋NV | FinnAPL | |

Index of last occurrence of XA in XV (⎕IO-1 if not found). | ((¯1 1)[2×⎕IO]+⍴XV)-(⌽XV)⍳XA | FinnAPL | |

Index of last occurrence of XA in XV (0 if not found). | (1+⍴XV)-(⌽XV)⍳XA | FinnAPL | |

Index of last occurrence of XA in XV, counted from the rear. | (⌽XV)⍳XA | FinnAPL | |

Index of the elements of NV1 in NV2. | (((1,A)/B)⌊1+⍴NV2)[(⍴NV2)↓(+\1,A←(1↓A)≠¯1↓A←A[B])[⍋B←⍋A←NV2,NV1]] | FinnAPL | |

Index of the largest item. | IS←⊃⍒N | APL2 | |

Index of the largest item. | IO←N⍳⌈/N | APL2 | |

Index of the smallest item. | IS←⊃⍋N | APL2 | |

Index of the smallest item. | IO←N⍳⌊/N | APL2 | |

Index origin (⎕IO) as a vector. | ⍳1 | FinnAPL | |

Index pairs of saddle points. | ⎕IO+(⍴NM)⊤-⎕IO-(,(NM=(⍴NM)⍴⌈⌿NM)∧NM=⍉(⌽⍴NM)⍴⌊/NM)/⍳×/⍴NM | FinnAPL | |

Indexing independent of index origin. | XV[⎕IO+IA] | FinnAPL | |

Indexing scattered elements. | (,XA)[⎕IO+(⍴XA)⊥IM-⎕IO] | FinnAPL | |

Indexing when rank is not known beforehand. | ⍎'XA[',((¯1+⍴⍴XA)⍴';'),'IA]' | FinnAPL | |

Indexing with boolean value BA (plotting a curve). | ' *'[⎕IO+BA] | FinnAPL | |

Indicating equal elements of XV as a logical matrix. | ⍉XV∘.=(1 1⍉<\XV∘.=XV)/XV | FinnAPL | |

Indicator of first occurrence of each unique element of XV. | (XV⍳XV)=⍳⍴XV | FinnAPL | |

Indices of all occurrences of elements of XA in XV. | (XV∊XA)/⍳⍴XV | FinnAPL | |

Indices of all occurrences of XS in XV. | (XS=XV)/⍳⍴XV | FinnAPL | |

Indices of elements of XM2 in corr. rows of XM1 (XM1[i;]⍳XM2[i;]). | 1++/∧\1 2 1 3⍉XM2∘.≠XM1 | FinnAPL | |

Indices of elements XA2 in array XA1. | ⎕IO+(⍴XA1)⊤(-⎕IO)+(,XA1∊XA2)/⍳⍴,XA1 | FinnAPL | |

Indices of first blanks in rows of array CA. | ⎕IO++/∧\' '≠CA | FinnAPL | |

Indices of last non-blanks in rows. | (' '≠CA)⌈.×⍳¯1↑⍴CA | FinnAPL | |

Indices of ones in logical vector BV. | (+/BV)↑⍒BV | FinnAPL | |

Indices of ones in logical vector BV. | (+\BV)⍳⍳+/BV | FinnAPL | |

Indices of ones in logical vector BV. | BV/⍳⍴BV | FinnAPL | |

Indices of subvectors of length IS starting at IV+1. | IV∘.+⍳IS | FinnAPL | |

Initialize a matrix with no rows. | M←0 IS⍴'' | APL2 | |

Initialize variables to the empty vector. | N←B←I←F←Z←⍬ | APL2 | |

Input continuation. | V←1 2 3 4 5 6 7 8 9 0,⎕ | APL2 | |

Input of row IS of text matrix CM. | CM[IS;]←(≢CM)↑⍞ | FinnAPL | |

Insert NS items S after each item of V. | V←∊V,¨⊂NS⍴S | APL2 | |

Insert NS items S before each item of V. | V←∊(⊂NS⍴S),¨V | APL2 | |

Insert the first item of C where C is in CM. | CM←↑∊¨⊂[1]CM⊣((,CM∊C)/,CM)←↑C | 0=⎕IO | APL2 |

Insert the first item of C where C is in CM. | CM←↑∊¨⊂[2]CM⊣((,CM∊C)/,CM)←↑C | 1=⎕IO | APL2 |

Insert vector for IV[i] elements before i:th element. | (⍳+/A)∊+\A←1+IV | FinnAPL | |

Insert vector for IV[i] zeroes after i:th subvector. | (⍳(⍴BV)++/IV)∊+\1+¯1↓0,(1⌽BV)\IV | FinnAPL | |

Insert X after positions P in V. | V←(V,X)[⍋(⍳⍴V),P] | (⍴P)=⍴X | APL2 |

Inserting IS *'s into vector CV after indices IV. | (CV,'*')[(⎕IO+⍴CV)⌊⍋(⍳⍴CV),(IS×⍴IV)⍴IV] | FinnAPL | |

Inserting vector XV into matrix XM after row IS. | XM[⍳IS;],[1]((1↓⍴XM)↑XV),[1](2↑IS)↓XM | FinnAPL | |

Inserting vector XV to the end of matrix XM. | (A↑XM),[⍳1](1↓A←(⍴XM)⌈0,⍴XV)↑XV | FinnAPL | |

Inserting XS after each element of XV. | ,XV,[1.1]XS | FinnAPL | |

Inserting XV1 into XV2 after index IS. | (IS↑XV2),XV1,IS↓XV2 | FinnAPL | |

Integer and fractional parts of positive numbers. | 0 1⊤NA | FinnAPL | |

Integer representation of logical vectors. | 2⊥BA | FinnAPL | |

INTEGER. Truncate to whole number. | IA←(×NA)×⌊|NA | APL2 | |

Integral+fractional part of positive number. | FA←0 1⊤NA | APL2 | |

Interpolated value of series (NV1,NV2) at NS. | NS⊥NV2⌹NV1∘.*⌽-⎕IO-⍳⍴NV1 | FinnAPL | |

Interpretation of roman numbers. | +/A×¯1*A<1⌽A←0,(1000 500 100 50 10 5 1)['MDCLXVI'⍳XA] | FinnAPL | |

Intersection of sets, ⍞. | (XV∊XA)/XV | FinnAPL | |

Intersection of two sets of numbers. | V←(X∊Y)/X | APL2 | |

Intersection of two sets of numbers. | V←Y~Y~X | APL2 | |

Inverse of +\. Difference of adjacent pairs. | N←¯2-/0,N | APL2 | |

Inverting a permutation. | ⍋IV | FinnAPL | |

Inverting a permutation. | IV⍳⍳⍴IV | FinnAPL | |

Inverting a permutation. | A←⍳⍴IV ⋄ A[IV]←A ⋄ A | FinnAPL | |

Inverting a permutation. | I←⍋N | APL2 | |

Is CX lexically greater than CY? | BS←>/⍋⎕UCS↑CX CY | APL2 | |

Is CX lexically greater than or equal to CY? | BS←</⍒⎕UCS↑CX CY | APL2 | |

Is CX lexically less than CY? | BS←>/⍒⎕UCS↑CX CY | APL2 | |

Is CX lexically less than or equal to CY? | BS←</⍋⎕UCS↑CX CY | APL2 | |

IS degree polynomial fit given X,Y values. | C←Y⌹X∘.*⍳IS+1 | 0=⎕IO | APL2 |

IS degree polynomial fit given X,Y values. | C←Y⌹X∘.*(⍳IS+1)-1 | 1=⎕IO | APL2 |

IS first figurate numbers. | #NAME? | FinnAPL | |

IS first triangular numbers. | #NAME? | FinnAPL | |

Is IS (YYYY) a leap year? | B←0≠.=400 100 4∘.|IS | APL2 | |

IS largest elements of NV in order of occurrence. | ((⍋⍒NV)∊⍳IS)/NV | FinnAPL | |

IS months from "0" given IS (YYYYMM) date. | IS←0 12⊥0 100⊤IS | APL2 | |

Is N an integer in range [XY) XY ←→ lo,hi. | B←</(N<⌈N),N∘.<XY | APL2 | |

Is N in range (XY) XY ←→ lo,hi. | B←((⊃XY)<N)∧N<⊃⌽XY | APL2 | |

Is N in range (XY] XY ←→ lo,hi. | B←>/N∘.>XY | APL2 | |

Is N in range [XY) XY ←→ lo,hi. | B←</N∘.<XY | APL2 | |

Is N in range [XY] XY ←→ lo,hi. | B←((⊃XY)≤N)∧N≤⊃⌽XY | APL2 | |

IS place-base NS rep. of a fraction. | NA←(¯1⌽⍳1+⍴⍴FA)⍉⌊(IS⍴NS)⊤(NS*IS)×1|FA | APL2 | |

IS smallest elements of NV in order of occurrence. | ((⍋⍋NV)∊⍳IS)/NV | FinnAPL | |

IS:th subvector of XV (subvectors indicated by BV). | (IS=+\BV)/XV | FinnAPL | |

IS:th subvector of XV (subvectors separated by XV[1]). | 1↓(IS=+\XV=1↑XV)/XV | FinnAPL | |

IS×IS identity matrix. | (⍳IS)∘.=⍳IS | FinnAPL | |

IS×IS identity matrix. | (IS,IS)⍴1,IS⍴0 | FinnAPL | |

IS×IS lower triangular matrix. | (⍳IS)∘.≥⍳IS | FinnAPL | |

IS×IS upper triangular matrix. | (⍳IS)∘.≤⍳IS | FinnAPL | |

ISBN check digit generator from C. | IS←|¯11|+/+\10↑⍎¨C | C∧.∊⎕D | APL2 |

IS-degree polynomial (curve) fit of points (NV1,NV2). | ⌽NV2⌹NV1∘.*0,⍳IS | FinnAPL | |

Isometric scaling by 2.1. | ZA←ZA×2.1 | APL2 | |

ISth subvector of V given boolean B. | V←IS⊃(+\B)⊆V | APL2 | |

ISth subvector of V given length L. | V←IS⊃(L/⍳⍴L)⊆V | APL2 | |

Item equals. Find item V in array A. | BA←A≡¨⊂V | APL2 | |

Ith starting indicators BV1. | (+\BV1)∊BV2/⍳⍴BV2 | FinnAPL | |

IV is the ranking of NA in same order. | IV←⍋⍋NA | APL2 | |

IV is the ranking of NA in same order.(fast). | IV[I]←IV←⍳⍴I←⍋NA | APL2 | |

IV2-shaped array of random numbers within ( IV1[1],IV1[2] ]. | IV1[1]+?IV2⍴--/IV1 | FinnAPL | |

Join XA real and YA imaginary to complex. | ZA←AX+¯11○AY | APL2 | |

Joining a set of variables into one variable. | VV←N B I F Z | APL2 | |

Joining array of arrays - horizontally. | A←↑,/AA | APL2 | |

Joining array of arrays - vertically. | M←↑,[0]/AA | 0=⎕IO | APL2 |

Joining array of arrays - vertically. | A←↑,[1]/AA | 1=⎕IO | APL2 |

Joining conforming matrices - horizontally. | M←⊃,/MW MX MY | APL2 | |

Joining corresponding items in vectrices. | AV←⊃,¨/VA | APL2 | |

Joining current date. | IS←0 100 100⊥3↑⎕TS | APL2 | |

Joining matrices - vertically. | M←↑⊃,/⊂[1]¨MW MX MY | 0=⎕IO | APL2 |

Joining matrices - vertically. | M←↑⊃,/⊂[2]¨MW MX MY | 1=⎕IO | APL2 |

Joining pairs of ones. | BA∨≠\BA | FinnAPL | |

Joining sentences. | XV,0⍴XA | FinnAPL | |

Julian date (YYYYDDD). | IS←(1000×Y)+D+(M⊃0 0,+\30+1 ¯2,∊5 4⍴¨⊂1 0)+(M>2)∧0=4|Y | 1=⎕IO | APL2 |

Julian date (YYYYDDD). | IS←(1000×Y)+D+(M⊃0,+\30+1 ¯2,∊5 4⍴¨⊂1 0)+(M>2)∧0=4|Y | 0=⎕IO | APL2 |

Julian day (DDD) given Y M D. | IS←D+(M⊃0 0,+\30+1 ¯2,∊5 4⍴¨⊂1 0)+(M>2)∧0=4|Y | 1=⎕IO | APL2 |

Julian day (DDD) given Y M D. | IS←D+(M⊃0,+\30+1 ¯2,∊5 4⍴¨⊂1 0)+(M>2)∧0=4|Y | 0=⎕IO | APL2 |

Justifying left. | (+/∧\' '=CA)⌽CA | FinnAPL | |

Justifying left fields of XV (lengths IV) to length IS. | (,IV∘.>(⍳IS)-⎕IO)\XV | FinnAPL | |

Justifying right. | (1-(' '=CA)⊥1)⌽CA | FinnAPL | |

Justifying right. | (-+/∧\⌽' '=CA)⌽CA | FinnAPL | |

Justifying right fields of XV (lengths IV) to length IS. | (,IV∘.>⌽(⍳IS)-⎕IO)\XV | FinnAPL | |

Justifying text CV to right edge of field of width IS. | (-IS)↑CV | FinnAPL | |

Juxtapositioning planes of rank 3 array XQ. | (×⌿2 2⍴1,⍴XQ)⍴2 1 3⍉XQ | FinnAPL | |

Keep even words in a phrase. | C←(≠\C=' ')/C | APL2 | |

Keep everything from ⊃C to ⊃1↓C in V. | V←(V⍳⊃1↓C)↑V←(1+V⍳⊃C)↓V | 0=⎕IO | APL2 |

Keep everything from ⊃C to ⊃1↓C in V. | V←(¯1+V⍳⊃1↓C)↑V←(V⍳⊃C)↓V | 1=⎕IO | APL2 |

Keep everything in range [0,NS). | N←(>/N∘.>0 NS)/N | APL2 | |

Keep everything up to the 1st return. | C←(∧\C≠⎕UCS 10)/C | APL2 | |

Keep odd words in a phrase. | C←(≠\¯1↓1,C=' ')/C | APL2 | |

Keep PFK within range 1-12. | PFK←12+¯12|PFK | APL2 | |

Koch island new generation. | Z←¯3↓,Z-[0]((2-/Z÷3),0)∘.×0 1,(1+1D60),2 | 0=⎕IO | APL2 |

Koch island new generation. | Z←¯3↓,Z-[1]((2-/Z÷3),0)∘.×0 1,(1+1D60),2 | 1=⎕IO | APL2 |

Kronecker delta of IA1 and IA2 (element of identity matrix). | IA2=IA1 | FinnAPL | |

L sequences of IS ones and zeros. | B←IS/L⍴1 0 | APL2 | |

Largest possible number. | FS←⌊/⍬ | APL2 | |

Last element of numeric vector NV as a scalar. | 0⊥NV | FinnAPL | |

Last ones in groups of ones. | BV>1↓BV,0 | FinnAPL | |

Last part of numeric code ABBB. | 1000|IA | FinnAPL | |

Last row of matrix XA as a vector. | 0⊥XA | FinnAPL | |

Leading ones (∧\) in each subvector of BV2 indicated by BV1. | ~≠\(BV2≤BV1)\A≠¯1↓0,A←~(BV2≤BV1)/BV2 | FinnAPL | |

Leading ones (turn off all ones after first zero). | ∧\BA | FinnAPL | |

Leading zeroes for IV in fields of width IS. | 0 1↓(2↑IS+1)⍕IV∘.+,10*IS | IV≥0 | FinnAPL |

Least squares linear fit given X,Y values. | V←N+.×Y⌹N←X∘.*0 1 | APL2 | |

Left justify C in field width NS. | C←(-NS)↑C | APL2 | |

Left justify matrix CM. | CM←(+/∧\CM=' ')⌽CM | APL2 | |

Leftmost neighboring elements. | ((-⍴⍴NA)↑¯1)↓0,NA | FinnAPL | |

Leftmost neighboring elements cyclically. | ¯1⌽XA | FinnAPL | |

Length of polygon. | S←+/|2-/Z | APL2 | |

Length vector given boolean vector B. | L←(1↓P,1+⍴B)-P←B/⍳⍴B | APL2 | |

Length vector given first position indices. | L←¯2-/P,1+⍴B | APL2 | |

Length vector given last position indices. | L←¯2-/0,P | APL2 | |

Length vector given unique items in V. | L←+/U∘.≡V | APL2 | |

Lengthening matrix XM1 to be compatible with XM2. | ((1 0×⍴XM2)⌈⍴XM1)↑XM1 | FinnAPL | |

Lengths of groups of ones in BV. | (A>0)/A←(1↓A)-1+¯1↓A←(~A)/⍳⍴A←0,BV,0 | FinnAPL | |

Lengths of subvectors of XV having equal elements. | (1↓A)-¯1↓A←(A,1)/⍳1+⍴A←1,(1↓XV)≠¯1↓XV | FinnAPL | |

Life: next generation given O<=>140 3x3 wins. | M←¯1⌽¯1⊖⊃∨/O⍷¨⊂M | APL2 | |

Limiting indices and giving a default value XS. | (XV,XS)[(1+⍴XV)⌊IA] | FinnAPL | |

Limiting NA between NV[1] and NV[2], inclusive. | NV[1]⌈NV[2]⌊NA | FinnAPL | |

Limits NA to fit in ⍕ field IV[1 2]. | (NA⌈1↓A)⌊1↑A←(2 2⍴¯1 1 1 ¯.1)+.×10*(-1↓IV),-/IV+IV>99 0 | FinnAPL | |

List of functions and operators without ' '. | VV←(⊂[1]⎕NL 3 4)~¨' ' | 0=⎕IO | APL2 |

List of functions and operators without ' '. | VV←(⊂[2]⎕NL 3 4)~¨' ' | 1=⎕IO | APL2 |

List of names in CM (one per row). | 1↓,',',CM | FinnAPL | |

Locating field number IS starting with first element of CV. | (IS=+\CV=1↑CV)/CV | FinnAPL | |

Locations of texts between and including quotes. | A∨¯1↓0,A←≠\CV='''' | FinnAPL | |

Locations of texts between and including quotes. | A∨¯1↓0,A←2|+\CV='''' | FinnAPL | |

Locations of texts between quotes. | A∧¯1↓0,A←≠\CV='''' | FinnAPL | |

Locations of texts between quotes. | A∧¯1↓0,A←2|+\CV='''' | FinnAPL | |

Lower triangular matrix: IS by IS. | M←(⍳IS)∘.>⍳IS | APL2 | |

Magnitude of fractional part. | 1||NA | FinnAPL | |

Magnitude of fractional part of number. | FA←1||NA | APL2 | |

Magnitude. Absolute Value of NA. | NA←|NA | APL2 | |

Major diagonal of array XA. | (1*⍴XA)⍉XA | FinnAPL | |

Major diagonal of matrix XM. | 1 1⍉XM | FinnAPL | |

Mask Operator. Merge X and Y using B. | V[⍋~B]←V←(B/X),(~B)/Y | APL2 | |

Matricize - for any rank. | M←,[¯1↓⍳⍴⍴A]1/A | APL2 | |

Matricize - for any rank. | M←((×/¯1↓⍴A),¯1↑1,⍴A)⍴A | APL2 | |

Matricize - rank 0, 1, or 2. | M←(¯2↑1 1,⍴A)⍴A | APL2 | |

Matrix for choosing all subsets of XV (truth table). | ((⍴XV)⍴2)⊤¯1+⍳2*⍴XV | FinnAPL | |

Matrix of all indices of XA. | ⎕IO+(⍴XA)⊤(⍳×/⍴XA)-⎕IO | FinnAPL | |

Matrix of vectors to vector of matrices. | VM←↑¨⊂[1]MV | 0=⎕IO | APL2 |

Matrix of vectors to vector of matrices. | VM←↑¨⊂[2]MV | 1=⎕IO | APL2 |

Matrix product. | NA1+.×NA2 | ¯1↑⍴NA1 ←→ 1↑⍴NA2 | FinnAPL |

Matrix product. | M←MX+.×MY | APL2 | |

Matrix to vector at character CS. | V←¯1↓(,⌽1,∨\CS≠⌽CM)/,CM,CS | APL2 | |

Matrix to vector of column vectors. | VV←,⌿M | APL2 | |

Matrix to vector of row vectors. | VV←⊂[1]M | 0=⎕IO | APL2 |

Matrix to vector of row vectors. | VV←⊂[2]M | 1=⎕IO | APL2 |

Matrix with IS columns NV. | ⍉(IS,⍴NV)⍴NV | FinnAPL | |

Matrix with IV[i] leading ones on row i. | IV∘.≥⍳⌈/IV | FinnAPL | |

Matrix with IV[i] leading zeroes on row i. | IV∘.<⍳⌈/IV | FinnAPL | |

Matrix with IV[i] trailing ones on row i. | IV∘.≥⌽⍳⌈/IV | FinnAPL | |

Matrix with IV[i] trailing zeroes on row i. | IV∘.<⌽⍳⌈/IV | FinnAPL | |

Matrix with shape of XM and XV as its columns. | ⍉(⌽⍴XM)⍴XV | FinnAPL | |

Maxima (⌈/) of elements of subvectors of NV indicated by BV. | NV[A[BV/⍋(+\BV)[A←⍒NV]]] | FinnAPL | |

Maxima of elements of subsets of XV specified by BA. | A+(XV-A←⌊/XV)⌈.×BA | FinnAPL | |

Maximum of elements of NV. | ⌈/NV | FinnAPL | |

Maximum of magnitude of NM preserving sign. | N←N××.5-(⌈/NM)≠N←⌈/|NM | APL2 | |

Maximum of magnitude of NM. | N←⌈/|NM | APL2 | |

Maximum of negative value of NM. | N←⌊/NM,0 | APL2 | |

Maximum of NV1 with weights NV2. | NV2⌈.×NV1 | FinnAPL | |

Maximum of positive value of NM. | N←⌈/NM,0 | APL2 | |

Maximum table. | (⍳IS)∘.⌈⍳IS | FinnAPL | |

Maximum value of NM. | N←⌈/NM | APL2 | |

Meaning of life. | ⍎⊖⍕⊃⊂|⌊-*+○⌈×÷!⌽⍉⌹~⍴⍋⍒,⍟?⍳0 | FinnAPL | |

Median. | NV[(⍋NV)[⌈.5×⍴NV]] | FinnAPL | |

Median of non-empty N. | MED←.5×+/N[(⍋N)[⌈.5×¯1 0+⍴N←,N]] | 0=⎕IO | APL2 |

Median of non-empty N. | MED←.5×+/N[(⍋N)[⌈.5×0 1+⍴N←,N]] | 1=⎕IO | APL2 |

Merge X and Y alternately. | V←∊X,¨Y | APL2 | |

Merging vectors XV1 and XV2 alternately. | ,XV2,[⎕IO+.5]XV1 | FinnAPL | |

Merging XV1 and XV2 under control of BV (mesh). | (XV1,XV2)[⍋⍋BV] | FinnAPL | |

Merging XV1 and XV2 under control of BV (mesh). | (XV2,XV1)[⍋⍒BV] | FinnAPL | |

Merging XV1 and XV2 under control of BV (mesh). | A[⍋BV]←A←XV2,XV1 ⋄ A | FinnAPL | |

Merging XV1 and XV2 under control of BV (mesh). | A←BV\XV1 ⋄ A[(~BV)/⍳⍴BV]←XV2 ⋄ A | FinnAPL | |

Merging XV1, XV2, XV3, … under control of IV (mesh). | (XV1,XV2,XV3,…)[⍋⍋IV] | FinnAPL | |

Mesh V according to mask pattern IV. | V←V[⍋⍋IV] | APL2 | |

Mesh X and Y in V using boolean pattern B. | V[⍋B]←V←X,Y | APL2 | |

Mid product of AX and AY. | A←AX,.×AY | APL2 | |

Minima (⌊/) of elements of subvectors of NV indicated by BV. | NV[A[BV/⍋(+\BV)[A←⍋NV]]] | FinnAPL | |

Minimum of elements of NV. | ⌊/NV | FinnAPL | |

Minimum of magnitude of NM preserving sign. | N←N××.5-(⌊/NM)≠N←⌊/|NM | APL2 | |

Minimum of magnitude of NM. | N←⌊/|NM | APL2 | |

Minimum of NV1 with weights NV2. | NV2⌊.×NV1 | FinnAPL | |

Minimum value of NM. | N←⌊/NM | APL2 | |

Mirror in X if B. | ZA←(¯10+~BA)○ZA | APL2 | |

Mirror in X. | ZA←+ZA | APL2 | |

Mirror in Y. | ZA←-+ZA | APL2 | |

Mode(s) of data. | MODE←(I=⌈/I←+⌿N∘.=NU)/NU←(∨⌿<\N∘.=N)/N | APL2 | |

MODULO of NAX and NAY. | NA←NAY|NAX | APL2 | |

Move blanks to end of each row of M. | (,M)←(,M)[⍋,(2×⍳≢M)+[0]' '=M] | 0=⎕IO | APL2 |

Move blanks to end of each row of M. | (,M)←(,M)[⍋,(2×⍳≢M)+[1]' '=M] | 1=⎕IO | APL2 |

Move figure by x=6, y=9. | ZA←ZA+6J9 | APL2 | |

Move items X to end of Y. | V←Y[⍋Y∊X] | APL2 | |

Move set of points NM into first quadrant. | 1 2 1⍉NM∘.-⌊/NM | FinnAPL | |

Moving all blanks to end of each row. | (⍴CA)⍴(,(+/A)∘.>-⎕IO-⍳¯1↑⍴CA)\(,A←CA≠' ')/,CA | FinnAPL | |

Moving all blanks to end of text. | CV[⍒' '≠CV] | FinnAPL | |

Moving elements satisfying condition BV to the start of XV. | XV[⍒BV] | FinnAPL | |

Moving index of width IS for vector XV. | (0,⍳(⍴XV)-IS)∘.+IS | FinnAPL | |

Multiplication table. | (⍳IS)∘.×⍳IS | FinnAPL | |

Multiplication table: IS by IS. | M←(1+⍳IS)∘.×1+⍳IS | 0=⎕IO | APL2 |

Multiplication table: IS by IS. | M←(⍳IS)∘.×⍳IS | 1=⎕IO | APL2 |

Multiply each row of NM by vector N. | NM←NM×[0]N | 0=⎕IO | APL2 |

Multiply each row of NM by vector N. | NM←NM×[1]N | 1=⎕IO | APL2 |

N column matrix from N vectors. | M←↑[0]V W X Y | 0=⎕IO | APL2 |

N column matrix from N vectors. | M←↑[1]V W X Y | 1=⎕IO | APL2 |

N column matrix from N vectors. | M←⍉↑V W X Y | APL2 | |

N row matrix from N vectors. | M←↑V W X Y | APL2 | |

Negative infinity; the smallest representable value. | ⌈/⍬ | FinnAPL | |

Nested to simple char image w/o extra blanks. | CM←I↓(-I←(-2-2>⍴⍴AA)↑|≡AA)↓⍕⊂1/AA | APL2 | |

None, neither. | ~∨/BA | FinnAPL | |

Not first zero (≤\) in each subvector of BV2 indicated by BV1. | ~(B∧BV1)∨(B∨BV1)\A>¯1↓0,A←(B∨BV1)/B←~BV2 | FinnAPL | |

Not first zero (turn on all zeroes after first zero). | ≤\BA | FinnAPL | |

Not leading zeroes (turn on all zeroes after first one). | ∨\BA | FinnAPL | |

Not leading zeroes(∨\) in each subvector of BV2 indicated by BV1. | ≠\(BV2∨BV1)\A≠¯1↓0,A←(BV2∨BV1)/BV2 | FinnAPL | |

NS differences of differences of adjacents. | N←⊃-//NS 1/¯2 N | APL2 | |

NS months after date IS (YYYYMM). | I←1+0 100⊥0 12⊤(0 12⊥0 100⊤IS)+⍳NS | 0=⎕IO | APL2 |

NS months after date IS (YYYYMM). | I←1+0 100⊥0 12⊤(0 12⊥0 100⊤IS)-1-⍳NS | 1=⎕IO | APL2 |

NS months before date IS (YYYYMM). | I←1+0 100⊥0 12⊤(0 12⊥0 100⊤IS)-2+⌽⍳NS | 0=⎕IO | APL2 |

NS months before date IS (YYYYMM). | I←1+0 100⊥0 12⊤(0 12⊥0 100⊤IS)-1+⌽⍳NS | 1=⎕IO | APL2 |

NS spokes of unit wheel. | VZ←0,¨*○0J2×(1+⍳NS)÷NS | APL2 | |

NS spokes of unit wheel. | VZ←0,¨*○0J2×(⍳NS)÷NS | APL2 | |

NS-point spline.(M=Bezier matrix, Z ctrl pts). | Z←(,[⍬](1+⍳NS)÷NS)⊥M+.×Z | 0=⎕IO | APL2 |

NS-point spline.(M=Bezier matrix, Z ctrl pts). | Z←(,[⍬](⍳NS)÷NS)⊥M+.×Z | 1=⎕IO | APL2 |

Number and its negative ('plus minus'). | 1 ¯1×NS | FinnAPL | |

Number of ?s intersecting ?s (NV1=starts, NV2=stops). | +/A∧⍉A←NV1∘.≤NV2 | FinnAPL | |

Number of areas intersecting areas in X. | +/A∧⍉A←∧/X[;A⍴1;]≤2 1 3⍉X[;(A←≢X)⍴2;] | ⍴NQ ←→ (n × 2 × dim) | FinnAPL |

Number of columns in A as vector. | IO←⊃⌽⍴A | APL2 | |

Number of columns in A. | IS←⊃⌽⍴A | APL2 | |

Number of columns in array XA. | (⍴XA)[⍴⍴XA] | FinnAPL | |

Number of columns in array XA as a scalar. | 0⊥⍴XA | FinnAPL | |

Number of columns in matrix XM. | ¯1↑⍴XM | FinnAPL | |

Number of columns in matrix XM. | 1↓⍴XM | FinnAPL | |

Number of columns in matrix XM. | (⍴XM)[2] | FinnAPL | |

Number of combinations of NA1 objects taken NA2 at a time. | NA2!NA1 | FinnAPL | |

Number of days in month IS of years IA (for all leap years). | (12⍴7⍴31 30)[IS]-0⌈¯1+2⊥(IS=2),[.1](0≠400|IA)-(0≠100|IA)-0≠4|IA | FinnAPL | |

Number of days in month IS of years IA (for most leap years). | (12⍴7⍴31 30)[IS]-0⌈¯1+2⊥(IS=2),[.1]0≠4|IA | FinnAPL | |

Number of decimals (up to IS) of elements of NA. | 0+.≠(⌈(10*IS)×10*⎕IO-⍳IS+1)∘.|⌈NA×10*IS | FinnAPL | |

Number of decimals of elements of NV. | ⌊10⍟(⍎('.'≠A)/A←⍕NV)÷NV | FinnAPL | |

Number of digit positions in integers in IA. | 1+⌊10⍟(IA=0)+IA×(1 ¯10)[1+IA<0] | FinnAPL | |

Number of digit positions in scalar NS (depends on ⎕PP). | ⍴⍕NS | FinnAPL | |

Number of digitpositions in integers in IA. | 1+(IA<0)+⌊10⍟|IA+0=IA | FinnAPL | |

Number of digits in positive integers in IA. | 1+⌊10⍟IA+0=IA | FinnAPL | |

Number of elements (also of a scalar). | ×/⍴XA | FinnAPL | |

Number of elements (also of a scalar). | ⍴,XA | FinnAPL | |

Number of elements in A as vector. | IO←⍴,A | APL2 | |

Number of elements in a plane of 3D A. | IS←×/1↓⍴A | APL2 | |

Number of elements in A. | IS←×/⍴A | APL2 | |

Number of elements satisfying condition BV. | +/BV | FinnAPL | |

Number of leading blanks. | NA←+/∧\CA=' ' | APL2 | |

Number of occurrences of scalar XS in array XA. | XS+.=,XA | FinnAPL | |

Number of occurrences of scalar XS in array XA. | +/XS=,XA | FinnAPL | |

Number of permutations of (N,K) combinations. | NS←(!K)×K!N | APL2 | |

Number of permutations of NA1 objects taken NA2 at a time. | (!NA2)×NA2!NA1 | FinnAPL | |

Number of rows in array XA (also of a vector). | ×/¯1↓⍴XA | FinnAPL | |

Number of rows in M as vector. | IO←1↑⍴M | APL2 | |

Number of rows in M. | IS←≢M | APL2 | |

Number of rows in matrix XM. | ≢XM | FinnAPL | |

Number of rows in matrix XM. | ¯1↓⍴XM | FinnAPL | |

Number of rows in matrix XM. | (⍴XM)[1] | FinnAPL | |

Number of rows in matrix XM. | ≢XM | FinnAPL | |

Number of sortable columns at a time using ⊥ and alphabet CV. | ⌊(1+⍴CV)⍟2*(A=¯1+A←2*⍳128)⍳1 | FinnAPL | |

Number of trailing blanks. | NA←+/∧\⌽CA=' ' | APL2 | |

Numeric headers (elements of NV) for rows of table XM. | (3⌽7 0⍕NV∘.+,0),⍕XM | FinnAPL | |

Numeric matrix of (N,K) combinations. | M←(∧⌿2<⌿M)/M←1+((-K)↑⍳N+1)⊤⍳(!K)×K!N | 0=⎕IO | APL2 |

Numeric matrix of (N,K) combinations. | M←(∧⌿2<⌿M)/M←1+((-K)↑⍳N)⊤⍳(!K)×K!N | 1=⎕IO | APL2 |

Occurences of the elements of NV. | |-⌿(2,⍴NV)⍴⍋⍋NV,NV | FinnAPL | |

Occurrences of string CV1 in string CV2. | (∧⌿(¯1+⍳⍴CV1)⌽(CV1∘.=CV2),0)/⍳1+⍴CV2 | FinnAPL | |

Occurrences of string XV1 in string XV2. | (XV2[A∘.+¯1+⍳⍴XV1]∧.=XV1)/A←(A=1↑XV1)/⍳⍴A←(1-⍴XV1)↓XV2 | FinnAPL | |

Occurrences of string XV1 in string XV2. | ((-A)↓XV1∧.=(A,1+⍴XV2)⍴XV2)/⍳(⍴XV2)+1-A←⍴XV1 | FinnAPL | |

Ohm's Law - resistance of parallel resistors. | NS←÷+/÷N | APL2 | |

One column matrix from vector V. | M←,['']V | APL2 | |

One row matrix from vector V. | M←,[¯.5]V | 0=⎕IO | APL2 |

One row matrix from vector V. | M←,[.5]V | 1=⎕IO | APL2 |

Ones, same shape and structure. | B←A=A | APL2 | |

Ones, same shape plus one. | B←0×/V | APL2 | |

Open a gap of IV1[i] after XV[IV2[i]] (for all i). | ((⍳(⍴XV)++/IV1)∊+\1+¯1↓0,((⍳⍴XV)∊IV2)\IV1)\XV | FinnAPL | |

Open a gap of IV1[i] before XV[IV2[i]] (for all i). | ((⍳(⍴XV)++/IV1)∊+\1+((⍳⍴XV)∊IV2)\IV1)\XV | FinnAPL | |

Open gaps before each item of V, L wide. | V←∊(-L+1)↑¨V | APL2 | |

Open gaps between each item in V, L wide. | V←∊(L+1)↑¨V | APL2 | |

Open gaps between points B in V, L wide. | V←((~B)-B\L)/V | APL2 | |

Open NS-1 spaces between each item in V. | V←∊NS↑¨V | APL2 | |

Ordinal numbers of words in CV that indices IA point to. | ⎕IO++/IA∘.≥(' '=CV)/⍳⍴CV | FinnAPL | |

Outer product. | M←X∘.×Y | APL2 | |

Outline of bar chart of data V. | Z←0J1⊥1 0⌽2/↑V(⍳1+⍴V) | 0=⎕IO | APL2 |

Outline of bar chart of data V. | Z←0J1⊥1 0⌽2/0,↑V(⍳⍴V) | 1=⎕IO | APL2 |

Output assigned value. | ⎕←A←2 10⍴⍳20 | APL2 | |

Output of an empty line. | 0⍴XA← | FinnAPL | |

Output of assigned value. | ⊢NA← | FinnAPL | |

Output of assigned value. | ⎕←XA← | FinnAPL | |

Pack an array into a vector based on BA. | V←(,BA)/,A | APL2 | |

Pairwise differences of successive columns (inverse of +\). | NA-((-⍴⍴NA)↑¯1)↓0,NA | FinnAPL | |

Pairwise differences of successive elements of vector NV. | (1↓NV)-¯1↓NV | FinnAPL | |

Pairwise ratios of successive elements of vector NV. | (1↓NV)÷¯1↓NV | FinnAPL | |

Parallel projection of 3D object in M. | Z←0J1⊥M[1 0;] | 0=⎕IO | APL2 |

Parallel projection of 3D object in M. | Z←0J1⊥M[2 1;] | 1=⎕IO | APL2 |

Parity. | ≠/BA | FinnAPL | |

Parity. Connect odd and even ones. | B←≠\B | APL2 | |

Parity+connectors. Connect odd and even ones. | B←B∨≠\B | APL2 | |

Pascal's triangle of order IS (binomial coefficients). | ⍉A∘.!A←0,⍳IS | FinnAPL | |

Pascal's triangle of order IS. | V←V∘.!V←⍳IS+1 | 0=⎕IO | APL2 |

Pascal's triangle of order IS. | V←V∘.!V←0,⍳IS | 1=⎕IO | APL2 |

Perspective projection from distance D. | Z←0J1⊥M[1 0;]×D÷D-M[2;] | 0=⎕IO | APL2 |

Perspective projection from distance D. | Z←0J1⊥M[2 1;]×D÷D-M[3;] | 1=⎕IO | APL2 |

Pinpoint figure rather than polygon. | VZA←,¨ZA | APL2 | |

Places between pairs of ones. | (~BA)∧≠\BA | FinnAPL | |

Playing order in a cup for IS ranked players. | ,⍉(A⍴2)⍴(2*A←⌈2⍟IS)↑⍳IS | FinnAPL | |

Plot of scalaroid function 'f' for data V. | Z←V+¯11○f V | APL2 | |

Plotting a curve from boolean values. | CA←' *'[BA] | 0=⎕IO | APL2 |

Plotting a curve from boolean values. | CA←' *'[1+BA] | 1=⎕IO | APL2 |

Plus Minus. Number and its negative. | NA←(⊂1 ¯1)×NA | APL2 | |

Poisson distribution of states IA with average number NS. | (*-NS)×(NS*IA)÷!IA | FinnAPL | |

Poisson distribution of states X and Y avg. | N←(*-Y)×(Y*X)÷!X | APL2 | |

Polynomial with roots NV. | ⌽((0,⍳⍴NV)∘.=+⌿~A)+.×(-NV)×.*A←((⍴NV)⍴2)⊤¯1+⍳2*⍴NV | FinnAPL | |

Combining two lines into one. | X←'line1'⊣Y←'line2' | APL2 | |

Position of comment in each row of array CA. | B←(<\'/*'⍷CA)∨⌽<\'/*'⍷⌽CA | APL2 | |

Position of first blanks in rows of M. | P←(⊂[1]CM)⍳¨' ' | 0=⎕IO | APL2 |

Position of first blanks in rows of M. | P←(⊂[2]CM)⍳¨' ' | 1=⎕IO | APL2 |

Position of first item in CX not in C. | P←⊃(~CX∊C)/⍳⍴CX | APL2 | |

Position of first occurrence of C in VV. | PO←VV⍳⊂C | APL2 | |

Position of last Y in X - from left. | PO←(⌽X)⍳Y | APL2 | |

Position of last Y in X. | PO←(⍴X)-(1,X≠Y)⊥1 | 1=⎕IO | APL2 |

Position of last Y in X. | PO←1+(⍴X)-(1,X≠Y)⊥1 | 0=⎕IO | APL2 |

Position of the first non-blank char by row. | P←(<\~CM∊' ')+.×⍳⊃⌽⍴CM | APL2 | |

Position of the first non-blank char. | PO←(C≠' ')⍳1 | APL2 | |

Position of the first satisfied condition. | PO←B⍳1 | APL2 | |

Position of the last non-blank char by row. | P←(⊃⌽⍴CM)-(1,CM=' ')⊥1 | 1=⎕IO | APL2 |

Position of the last non-blank char by row. | P←1+(⊃⌽⍴CM)-(1,CM=' ')⊥1 | 0=⎕IO | APL2 |

Position of the last non-blank char. | PO←(⍴C)-(1,C=' ')⊥1 | 1=⎕IO | APL2 |

Position of the last non-blank char. | PO←1+(⍴C)-(1,C=' ')⊥1 | 0=⎕IO | APL2 |

Position of the NSth Y in X. | PO←(+\X≡¨Y)⍳NS | APL2 | |

Position of trailing blanks in rows. | P←(CM≠' ')⌈.×⍳⊃⌽⍴CM | APL2 | |

Position of V in corresponding row of M. | N←M⌊.⍳V | APL2 | |

Position(s) of V in each row of M. | VN←M,.⍳V | APL2 | |

Positions of items in set C in string CX. | P←(CX∊C)/⍳⍴CX | APL2 | |

Positions of ones given length vector L. | P←¯1↓+\0,L | 1=⎕IO | APL2 |

Positions of ones given length vector L. | P←¯1↓+\1,L | 0=⎕IO | APL2 |

Positions of ones in boolean vector B. | P←B/⍳⍴B | APL2 | |

Positions of ones in boolean vector B. | P←(+/B)↑⍒B | APL2 | |

Positions of start of C in string CX. | P←(C⍷CX)/⍳⍴CX | APL2 | |

Positive infinity; the largest representable value. | ⌊/⍬ | FinnAPL | |

Positive maximum, at least zero (also for empty NV). | ⌈/NV,0 | FinnAPL | |

Postfix vector to each row of matrix. | M←↑,/M,⊂V | APL2 | |

Predicted values of best linear fit (least squares). | A+.×NV2⌹A←NV1∘.*0 1 | FinnAPL | |

Predicted values of exponential (curve) fit. | *A+.×(⍟NV2)⌹A←NV1∘.*0 1 | FinnAPL | |

Prefix vector to each row of matrix. | M←⊃,/V,⊂M | APL2 | |

Present value of cash flows NA at int FS. | A←(÷1+FS)⊥⌽NA | APL2 | |

Present value of cash flows NV at interest rate NS %. | (÷1+NS÷100)⊥⌽NV | FinnAPL | |

Prime numbers from 1...IS. | I←(2=+⌿0=I∘.|I)/I←1+⍳IS | 0=⎕IO | APL2 |

Prime numbers from 1...IS. | I←(2=+⌿0=I∘.|I)/I←⍳IS | 1=⎕IO | APL2 |

Product by bucket. U = buckets. | N←N×.*V∘.≡U | ⍴N ←→ ⍴V | APL2 |

Product of elements of NV. | ×/NV | FinnAPL | |

Product of N. | NS←×/N | APL2 | |

Product of two polynomials with coefficients NV1 and NV2. | +⌿(⎕IO-⍳⍴NV1)⌽NV1∘.×NV2,0×1↓NV1 | FinnAPL | |

Products over subsets of XV specified by BA. | XV×.*BA | FinnAPL | |

Progressive index of (without replacement). | ((⍴XV1)⍴⍋⍋XV1⍳XV1,XV2)⍳(⍴XV2)⍴⍋⍋XV1⍳XV2,XV1 | FinnAPL | |

Progressive index of (without replacement). | ((⍋XV1⍳XV1,XV2)⍳⍳⍴XV1)⍳(⍋XV1⍳XV2,XV1)⍳⍳⍴XV2 | FinnAPL | |

Prompt and response on same line. | V←(⍴V)↓⊃⍞ V←⍞←'Finished? ' | APL2 | |

Proof. Returns items of VVX not in VVY list. | VV←VVX~VVY | APL2 | |

Pythagorean: FA = hypotenuse NA = side ratio. | FA←4○NA | APL2 | |

Pythagorean: FA = side NA = hyp:side ≥ 1. | FA←¯4○NA | APL2 | |

Pythagorean: FA = side NA = side:hyp ≤ 1. | FA←0○NA | APL2 | |

Pythagorean: Sum of the squares of AX. | NA←AX+.*2 | APL2 | |

Quick input of (×/I) strings. | VA←⍎¨I⍴'⍞' | I=⍴VA | APL2 |

Quick list of all functions and operators. | M←,['']⎕CR¨⊂[1]⎕NL 3 4 | 0=⎕IO | APL2 |

Quick list of all functions and operators. | M←,['']⎕CR¨⊂[2]⎕NL 3 4 | 1=⎕IO | APL2 |

Quick membership (∊) for positive integers. | A←(⌈/IV1,IV2)⍴0 ⋄ A[IV2]←1 ⋄ A[IV1] | FinnAPL | |

Random numbers between 1-IS w/o repl. | I←1+IS?IS | 0=⎕IO | APL2 |

Random numbers between 1-IS w/o repl. | I←IS?IS | 1=⎕IO | APL2 |

Random numbers between 1-IS w/repl. | I←1+?IS⍴IS | 0=⎕IO | APL2 |

Random numbers between 1-IS w/repl. | I←?IS⍴IS | 1=⎕IO | APL2 |

Randomizing random numbers (in ⎕LX in a workspace). | ⎕RL←⎕TS+.*2 | FinnAPL | |

Range of non-empty N. | RANGE←(⌈/N)-⌊/N | APL2 | |

Rank of A. | IO←⍴⍴A | APL2 | |

Rank of array XA. | ⍴⍴XA | FinnAPL | |

Rank of each item in an array. | AV←⍴¨⍴¨AA | APL2 | |

Rank of the first item in an array. | IO←⊃⍴¨⍴¨AA | APL2 | |

Rank of the first item in an array. | IO←⍴⍴⊃AA | APL2 | |

Ravel of a matrix to IV[1] columns with a gap of IV[2]. | (A×IV[1]*¯1 1)⍴(A←(⍴XM)+(IV[1]|-≢XM),IV[2])↑XM | FinnAPL | |

Real from ZAX and imaginary from ZAX. | ZA←(9○ZAX)+¯11○11○ZAY | APL2 | |

Reassign main diagonal of matrix. | (0 0⍉M)←1 | 0=⎕IO | APL2 |

Reassign main diagonal of matrix. | (1 1⍉M)←1 | 1=⎕IO | APL2 |

Reblock. Cut VV into many ≤LS length vecs. | VV←↑,/((⍴¨VV)⍴¨⊂1+LS↑1)⊂¨VV | APL2 | |

Rectangular scale by x=2,y=3. | ZA←(2,¯11○3)+.×9 11∘.○ZA | APL2 | |

Reduce each item of VV by B. | VV←⊂[2]B/↑VV | (⍴B)∧.=∊⍴¨VV | APL2 |

Reduction with function ⍺ in dimension IS, rank unchanged. | ((⍴XA)*IS≠⍳⍴⍴XA)⍴ ⍺/[IS]XA | FinnAPL | |

Reduction with FUNCTION ⍺ without respect to shape. | ⍺/,NA | FinnAPL | |

Regular unit polygon of NS edges. | Z←*○0J2×(⍳NS+1)÷NS | 0=⎕IO | APL2 |

Regular unit polygon of NS edges. | Z←*○0J2×(0,⍳NS)÷NS | 1=⎕IO | APL2 |

REMAINDER from division of NAX by NAY. | NA←(×NAX)×(|NAY)||NAX | APL2 | |

Remove blank columns. | CM←(' '∨.≠CM)/CM | APL2 | |

Remove blank rows. | CM←(CM∨.≠' ')⌿CM | APL2 | |

Remove blanks in each string. | C←C~¨' ' | APL2 | |

Remove blanks. | C←C~' ' | APL2 | |

Remove duplicate blank columns. | CM←(¯1↓1,B∨1⌽B←' '∨.≠CM)/CM | APL2 | |

Remove duplicate blank rows. | CM←(¯1↓1,B∨1⌽B←CM∨.≠' ')⌿CM | APL2 | |

Remove lead, trail, and duplicate blanks. | V←1↓(B∨1⌽B←0,C≠' ')/' ',C | APL2 | |

Remove leading blank columns. | CM←(∨\' '∨.≠CM)/CM | APL2 | |

Remove leading blank rows. | CM←(∨\CM∨.≠' ')⌿CM | APL2 | |

Remove leading blanks. | V←(∨\C≠' ')/C | APL2 | |

Remove punctuation. | C←C~'.,:;?!' | APL2 | |

Remove trailing blank columns. | CM←(1-(1,' '∧.=CM)⊥1)↓[1]CM | 0=⎕IO | APL2 |

Remove trailing blank columns. | CM←(1-(1,' '∧.=CM)⊥1)↓[2]CM | 1=⎕IO | APL2 |

Remove trailing blank rows. | CM←(1-(1,CM∧.=' ')⊥1)↓[0]CM | 0=⎕IO | APL2 |

Remove trailing blank rows. | CM←(1-(1,CM∧.=' ')⊥1)↓[1]CM | 1=⎕IO | APL2 |

Remove trailing blanks. | V←(⌽∨\⌽C≠' ')/C | APL2 | |

Removing blank columns. | (' '∨.≠CM)/CM | FinnAPL | |

Removing blank rows. | (CM∨.≠' ')⌿CM | FinnAPL | |

Removing blanks. | (' '≠XV)/XV | FinnAPL | |

Removing columns IV from array XA. | (~(⍳¯1↑⍴XA)∊IV)/XA | FinnAPL | |

Removing duplicate blank columns. | (A∨1,¯1↓A←' '∨.≠CM)/CM | FinnAPL | |

Removing duplicate blank rows. | (A∨1↓1⌽1,A←CM∨.≠' ')⌿CM | FinnAPL | |

Removing duplicate elements (nub). | ((XV⍳XV)=⍳⍴XV)/XV | FinnAPL | |

Removing duplicate elements (nub). | (1 1⍉<\XV∘.=XV)/XV | FinnAPL | |

Removing duplicate rows. | ((A⍳A)=⍳⍴A←2⊥XM∧.=⍉XM)⌿XM | FinnAPL | |

Removing duplicate rows. | ((A⍳A)=⍳⍴A←⎕IO++⌿∧⍀XM∨.≠⍉XM)⌿XM | FinnAPL | |

Removing duplicate rows. | (∨⌿<\XM∧.=⍉XM)⌿XM | FinnAPL | |

Removing duplicate rows. | (1 1⍉<\XM∧.=⍉XM)⌿XM | FinnAPL | |

Removing duplicate rows from ordered matrix XM. | (¯1⌽1↓(∨/XM≠¯1⊖XM),1)⌿XM | FinnAPL | |

Removing duplicate XS's from vector XV. | (A∨¯1↓1,A←XV≠XS)/XV | FinnAPL | |

Removing duplicates from an ordered vector. | (¯1⌽1↓(XV≠¯1⌽XV),1)/XV | FinnAPL | |

Removing duplicates from positive integers. | A←9999⍴0 ⋄ A[IV]←1 ⋄ A/⍳9999 | FinnAPL | |

Removing elements XA from beginning and end of vector XV. | ((A⍳1)-⎕IO)↓(⎕IO-(⌽A←~XV∊XA)⍳1)↓XV | FinnAPL | |

Removing elements XA from beginning of vector XV. | (((~XV∊XA)⍳1)-⎕IO)↓XV | FinnAPL | |

Removing elements XA from end of vector XV. | (⎕IO-(~⌽XV∊XA)⍳1)↓XV | FinnAPL | |

Removing elements XS from vector XV. | (XV≠XS)/XV | FinnAPL | |

Removing every IS:th element of XV. | (0≠IS|⍳⍴XV)/XV | FinnAPL | |

Removing every second element of XV. | (2|⍳⍴XV)/XV | FinnAPL | |

Removing leading and multiple blanks. | (A∨¯1↓0,A←' '≠CV)/CV | FinnAPL | |

Removing leading and trailing blanks. | ((⌽∨\⌽A)∧∨\A←' '≠CV)/CV | FinnAPL | |

Removing leading blank columns. | (∨\' '∨.≠CM)/CM | FinnAPL | |

Removing leading blank rows. | (∨\CM∨.≠' ')⌿CM | FinnAPL | |

Removing leading blanks. | (∨\' '≠CV)/CV | FinnAPL | |

Removing leading blanks. | (+/∧\' '=CV)↓CV | FinnAPL | |

Removing leading zeroes. | (¯1+(XV='0')⍳0)↓XV | FinnAPL | |

Removing leading, multiple and trailing blanks. | (' '=1↑CV)↓((1↓A,0)∨A←' '≠CV)/CV | FinnAPL | |

Removing leading, multiple and trailing XS's. | (1↑A)↓(A⍲1⌽A←XS=XV)/XV | FinnAPL | |

Removing multiple and trailing blanks. | ((1↓A,0)∨A←' '≠CV)/CV | FinnAPL | |

Removing multiple blanks. | (A∨¯1↓1,A←' '≠CV)/CV | FinnAPL | |

Removing punctuation characters. | (~XV∊' .,:;?''')/XV | FinnAPL | |

Removing trailing blank columns. | (⌽∨\⌽' '∨.≠CM)/CM | FinnAPL | |

Removing trailing blank columns. | (⌽∨\⌽∨⌿' '≠CM)/CM | FinnAPL | |

Removing trailing blank rows. | (-2↑+/∧\⌽CM∧.=' ')↓CM | FinnAPL | |

Removing trailing blanks. | (1-(' '=CV)⊥1)↓CV | FinnAPL | |

Removing trailing blanks. | (1-(⌽' '≠CV)⍳1)↓CV | FinnAPL | |

Removing trailing blanks. | (⌽∨\⌽' '≠CV)/CV | FinnAPL | |

Removing trailing blanks. | (-+/∧\⌽' '=CV)↓CV | FinnAPL | |

Removing trailing blanks. | (¯1↑(' '≠CV)/⍳⍴CV)⍴CV | FinnAPL | |

Repeat matrix. | (((¯1⌽~A)∧A←(¯1↓XV1=1⌽XV1),0)/XV2)∘.=XV2 | FinnAPL | |

Replace all blanks with dashes. | ((,CA=' ')/,CA)←'-' | APL2 | |

Replace all items, shape unchanged. | (,A)←⊂AX | APL2 | |

Replace all occurrences of element in array. | ((,CA∊1↓C)/,CA)←↑C | APL2 | |

Replace leading zeros with blanks. | ((1=⌈\' 0'⍳C)/C)←' ' | 0=⎕IO | APL2 |

Replace leading zeros with blanks. | ((2=⌈\' 0'⍳C)/C)←' ' | 1=⎕IO | APL2 |

Replace rows of M given boolean start vector. | M←M[⌈\B×⍳⍴B;] | APL2 | |

Replace selected items, shape unchanged. | (B/,A)←(+/B)⍴V | APL2 | |

Replacing all values XS1 in XA with XS2. | A[(A=XS1)/⍳⍴A←,XA]←XS2 ⋄ (⍴XA)⍴A | FinnAPL | |

Replacing elements of XA in set XV1 with corresponding XV2. | A[B/⍳⍴B]←XV2[(B←B≤⍴XV2)/B←XV1⍳A←,XA] ⋄ (⍴XA)⍴A | FinnAPL | |

Replacing elements of XA not satisfying BV with blanks/zeroes. | BV\BV/XA | FinnAPL | |

Replacing elements of XS in set XV with blanks/zeroes. | A\(A←~XS∊XV)/XS | FinnAPL | |

Replacing elements of XV not in set XA with blanks/zeroes. | A\(A←XV∊XA)/XV | FinnAPL | |

Replacing elements of XV satisfying BV with XS. | XV[BV/⍳⍴XV]←XS | FinnAPL | |

Replacing first element of XV with XS. | ¯1⌽1↓XV,XS | FinnAPL | |

Replacing last element of XV with XS. | 1⌽¯1↓XS,XV | FinnAPL | |

Replacing zeroes with corresponding elements of NA2. | NA1+NA2×NA1=0 | FinnAPL | |

Replicate CM at rows indicated by B. | CM←(1+B)⌿CM | APL2 | |

Replicate MU given boolean start vector. | M←MU[¯1++\B;] | 0=⎕IO | APL2 |

Replicate MU given boolean start vector. | M←MU[+\B;] | 1=⎕IO | APL2 |

Replicate XV[i] IV[i] times (for all i). | ((IV≠0)/XV)[+\¯1⌽(⍳+/IV)∊+\IV] | FinnAPL | |

Replicate XV[i] IV[i] times (for all i). | XV[+\(⍳+/IV)∊¯1↓1++\0,IV] | FinnAPL | |

Replicate XV[i] IV[i] times (for all i). | XV[⎕IO++\(⍳+/IV)∊⎕IO++\IV] | FinnAPL | |

Replicating a dimension of rank three array XQ IS-fold. | XQ[;,(IS⍴1)∘.×⍳(⍴XQ)[2];] | FinnAPL | |

Representation of current date (American). | A←⍕100|1⌽3↑⎕TS ⋄ A[(' '=A)/⍳⍴A]←'/' ⋄ A | FinnAPL | |

Representation of current date (ascending format). | A←⍕⌽3↑⎕TS ⋄ A[(' '=A)/⍳⍴A]←'.' ⋄ A | FinnAPL | |

Representation of current date (descending format). | A←⍕1000⊥3↑⎕TS ⋄ A[5 8]←'-' ⋄ A | FinnAPL | |

Representation of current time (12 hour clock). | (1⌽,' ::',3 2⍴6 0⍕100⊥12 0 0|3↑3↓⎕TS),'AP'[1+12≤⎕TS[4]],'M' | FinnAPL | |

Representation of current time (24 hour clock). | A←⍕1000⊥3↑3↓⎕TS ⋄ A[3 6]←':' ⋄ A | FinnAPL | |

Representation of NS1 in base NS2. | ((1+⌊NS2⍟NS1)⍴NS2)⊤NS1 | FinnAPL | |

Reshaping a 400×12 character matrix to fit into one page. | 40 120⍴2 1 3⍉10 40 12⍴CM | FinnAPL | |

Reshaping first element of XA into a scalar. | ⍬⍴XA | FinnAPL | |

Reshaping NA into a matrix of width IS. | ((⌈(⍴,NA)÷IS),IS)⍴NA | FinnAPL | |

Reshaping NA into a matrix of width IS. | (((⍴,NA),1)×IS*¯1 1)⍴NA | FinnAPL | |

Reshaping non-empty lower-rank array XA into a matrix. | (1⌈¯2↑⍴XA)⍴XA | 2≥⍴⍴XA | FinnAPL |

Reshaping non-empty lower-rank array XA into a matrix. | (¯2↑1 1,⍴XA)⍴XA | 2≥⍴⍴XA | FinnAPL |

Reshaping numeric vector NV into a one-column matrix. | NV∘.+,0 | FinnAPL | |

Reshaping one-element vector XV into a scalar. | +/XV | FinnAPL | |

Reshaping only one-element numeric vector NV into a scalar. | ⍎⍕NV | FinnAPL | |

Reshaping planes of rank 3 array to a matrix. | (×/2 2⍴(⍴XQ),1)⍴XQ | FinnAPL | |

Reshaping planes of rank 3 array to rows of a matrix. | (×/2 2⍴1,⍴XQ)⍴XQ | FinnAPL | |

Reshaping scalar XA into a one-element vector. | 1/XA | FinnAPL | |

Reshaping vector XV into a one-column matrix. | (⌽1,⍴XV)⍴XV | FinnAPL | |

Reshaping vector XV into a one-column matrix. | ((⍴XV),1)⍴XV | FinnAPL | |

Reshaping vector XV into a one-row matrix. | (1,⍴XV)⍴XV | FinnAPL | |

Reshaping vector XV into a two-column matrix. | ((0.5×⍴XV),2)⍴XV | FinnAPL | |

Residue replacing 0 with NS. | NA←NS+(-NS)|NA | APL2 | |

Resistance of parallel resistors. | ÷+/÷NV | FinnAPL | |

Restoring argument of cumulative sum (inverse of +\). | NV-¯1↓0,NV | FinnAPL | |

Retrieving scattered elements IM from matrix XM. | 1 1⍉XM[IM[1;];IM[2;]] | FinnAPL | |

RETURN. Leave function, return to caller. | →0 | APL2 | |

Reversal (⌽) of subvectors of NV having lengths IV. | NV[⌽⍒+\(⍳⍴NV)∊+\⎕IO,IV] | FinnAPL | |

Reversal (⌽) of subvectors of XV indicated by BV. | XV[⌽⍒+\BV] | FinnAPL | |

Reverse vector XV on condition BS. | XV[⍒BS!⍳⍴XV] | FinnAPL | |

Reverse vector XV on condition BS. | ,⌽[⎕IO+BS](1,⍴XV)⍴XV | FinnAPL | |

Reversing disclose. | VV←(+/∨\⌽M≠' ')↑¨⊂[1]M | 0=⎕IO | APL2 |

Reversing disclose. | VV←(+/∨\⌽M≠' ')↑¨⊂[2]M | 1=⎕IO | APL2 |

Reversing disclose. Eliminating blanks. | V←(⊂[1]M)~¨' ' | 0=⎕IO | APL2 |

Reversing disclose. Eliminating blanks. | V←(⊂[2]M)~¨' ' | 1=⎕IO | APL2 |

Right justify C in field width NS. | C←NS↑C | APL2 | |

Right justify matrix CM. | CM←(1-(1,CM=' ')⊥1)⌽CM | APL2 | |

Rightmost neighboring elements. | ((-⍴⍴NA)↑1)↓NA,0 | FinnAPL | |

Rightmost neighboring elements cyclically. | 1⌽XA | FinnAPL | |

Roman numerals to Arabic. | I←+/I×¯1*I<1⌽I←0,(,(10*⍳4)∘.×1 5)['IVXLCDM'⍳C] | 0=⎕IO | APL2 |

Roman numerals to Arabic. | I←+/I×¯1*I<1⌽I←0,(,(1,10*⍳3)∘.×1 5)['IVXLCDM'⍳C] | 1=⎕IO | APL2 |

Rotate and scale at same time. | ZA←ZA×2.1D30 | APL2 | |

Rotate figure 30 degrees. | ZA←ZA×1D30 | APL2 | |

Rotate figure in direction of point ZS. | ZA←ZA××ZS | APL2 | |

Rotate first elements (1⌽) of subvectors of XV indicated by BV. | XV[⍋BV++\BV] | FinnAPL | |

Rotation matrix for angle NS (in radians) counter-clockwise. | 2 2⍴1 ¯1 1 1×2 1 1 2○NS | FinnAPL | |

Round to nearest integer. | ⌊0.5+NA | Dyalog | |

Rounding currencies to nearest 5 subunits. | .05×⌊.5+NA÷.05 | FinnAPL | |

Rounding to ⎕PP precision. | ⍎⍕NV | FinnAPL | |

Rounding to IA decimals. | (10*-IA)×⌊0.5+NA×10*IA | FinnAPL | |

Rounding to IS decimal places. | FA←⍎(|IS)⍕NA | APL2 | |

Rounding to nearest even integer. | ⌊NA+1≤2|NA | FinnAPL | |

Rounding to nearest even number. | IA←(×NA)×⌊(1≤2||NA)+|NA | APL2 | |

Rounding to nearest hundredth. | 0.01×⌊0.5+100×NA | FinnAPL | |

Rounding to nearest integer. | ⌊0.5+NA | FinnAPL | |

Rounding to nearest NSth. | FA←(×NA)×(⌊.5+|NA÷NS)×NS | APL2 | |

Rounding to nearest whole number. | IA←(×NA)×⌊.5+|NA | APL2 | |

Rounding to zero values of NA1 close to zero. | NA1×NA2≤|NA1 | FinnAPL | |

Rounding, to nearest even integer for .5 = 1||NA. | ⌊NA+.5×.5≠2|NA | FinnAPL | |

Row averages of NM. | RAVE←(+/NM)÷1⌈⊃⌽⍴NM | APL2 | |

Row averages of NM. (non-zero). | RAVG←(+/NM)÷1⌈+/0≠NM | APL2 | |

Row positions given boolean vector B. | P←B/⍳≢A | APL2 | |

Row positions of MX in MY (0 for not found). | P←(<\MX∧.=⍉MY)+.×⍳↑⍴MY | APL2 | |

Row positions of MX in MY. | P←(⊂[1]MY)⍳⊂[1]MX | 0=⎕IO | APL2 |

Row positions of MX in MY. | P←(⊂[2]MY)⍳⊂[2]MX | 1=⎕IO | APL2 |

Row standard deviation of A. | STD←(((N×+/A*2)-(+/A)*2)÷N×1⌈¯1+N←1⌈⊃⌽⍴A)*.5 | APL2 | |

Row sum of a matrix. | +/NM | FinnAPL | |

Row table. Vectors to rows of a matrix. | M←↑VV | APL2 | |

Row theoretical standard deviation of A. | STD←(((N×+/A*2)-(+/A)*2)*.5)÷N←1⌈⊃⌽⍴A | APL2 | |

Row theoretical variance of A. | VAR←((N×+/A*2)-(+/A)*2)÷(N←1⌈⊃⌽⍴A)*2 | APL2 | |

Row variance of A. | VAR←((N×+/A*2)-(+/A)*2)÷N×1⌈¯1+N←1⌈⊃⌽⍴A | APL2 | |

Row-by-row formatting (width IS) of NM with IV decimals per row. | ((1,IS)×⍴NM)⍴2 1 3⍉(⌽IS,⍴NM)⍴(,IS,[1.1]IV)⍕⍉NM | FinnAPL | |

Rows of matrix XM starting with string XV. | ((((≢XM),⍴XV)↑XM)∧.=XV)⌿XM | FinnAPL | |

Rows of non-empty matrix XM starting with a character in XV. | (XM[;1]∊XV)⌿XM | FinnAPL | |

Row-wise percentage per row. | N←100×NM÷[0]+/NM | 0=⎕IO | APL2 |

Row-wise percentage per row. | N←100×NM÷[1]+/NM | 1=⎕IO | APL2 |

Running parity. | ≠\BA | FinnAPL | |

Running parity (≠\) over subvectors of BV2 indicated by BV1. | ≠\BV2≠BV1\A≠¯1↓0,A←BV1/≠\¯1↓0,BV2 | FinnAPL | |

Running sum of IS consecutive elements of NV. | ((IS-1)↓A)-0,(-IS)↓A←+\NV | FinnAPL | |

Running sum of NS consecutive elements of N. | N←NS+/N | APL2 | |

Scalar (dot) product of vectors. | NV2+.×NV1 | FinnAPL | |

Scan from end with function ⍺. | ⌽⍺\⌽XA | FinnAPL | |

Scatter assignment. | (,A)[(⍴A)⊥⍉PM]←V | 0=⎕IO ⋄ (⍴PM)=(⍴V),⍴⍴A | APL2 |

Scatter assignment. | (,A)[1+(⍴A)⊥⍉¯1+PM]←V | 1=⎕IO ⋄ (⍴PM)=(⍴V),⍴⍴A | APL2 |

Scatter assignment. | (PV⌷¨⊂A)←V | (⍴PV)=⍴V ⋄ (⍴¨PV)=⍴⍴A | APL2 |

Scatter indexing. | V←PV⌷¨⊂A | (⍴PV)=⍴V ⋄ (⍴¨PV)=⍴⍴A | APL2 |

Select random item from vector. Works on ''. | NS←V[(0≠⍴V)?⍴V] | APL2 | |

Select X or Y depending on BS. | Z←BS⊃X Y | 0=⎕IO | APL2 |

Select X or Y depending on BS. | Z←(BS+1)⊃X Y | 1=⎕IO | APL2 |

Select X or Y depending on BS. | Z←⊃BS↓X Y | APL2 | |

Selecting elements of XA satisfying condition BV. | BV/XA | FinnAPL | |

Selecting elements satisfying condition BA, others to 1. | BA!NA | FinnAPL | |

Selecting elements satisfying condition BA, others to one. | NA*BA | FinnAPL | |

Selecting elements satisfying condition BA, zeroing others. | BA×NA | FinnAPL | |

Selecting specific elements from a 'large' outer product. | IV⍉XA1∘.⍺XA2 | FinnAPL | |

Selection depending on index origin. | XV[2×⎕IO] | FinnAPL | |

Selection depending on index origin. | XV[1] | FinnAPL | |

Selection depending on sign of array. | A←(⊂¯1 0 1⍳×NA)⌷SW SX SY | APL2 | |

Selection depending on sign of scalar. | S←(¯1 0 1⍳×NS)⊃SW SX SY | APL2 | |

Selection of elements of NA1 and NA2 depending on condition BA. | (NA1×BA)+NA2×~BA | FinnAPL | |

Selection of XS1 or XS2 depending on condition BS. | ''⍴BS↓XS1,XS2 | FinnAPL | |

Selection of XS1 or XS2 depending on condition BS. | (XS1,XS2)[⎕IO+BS] | FinnAPL | |

Selective multiple subarrays from array. | AV←PAV⊃¨¨⊂⊂A | APL2 | |

Sentence from vector of words. | C←∊' ',¨VV | APL2 | |

Sentence to vector of words. | VV←⍎∊'''',C,''''⊣((C=' ')/C)←⊂''' ''' | APL2 | |

Sentence to vector of words. | VV←((2>/1,B)/⍳⍴B)↓¨(1+(2</B,1)/⍳⍴B←C=' ')↑¨⊂C | 0=⎕IO | APL2 |

Sentence to vector of words. | VV←(¯1+(2>/1,B)/⍳⍴B)↓¨((2</B,1)/⍳⍴B←C=' ')↑¨⊂C | 1=⎕IO | APL2 |

Sentence to vector of words. | VV←(C≠' ')⊆C | APL2 | |

Separating a date YYMMDD to YY, MM, DD. | ⍉(3⍴100)⊤NA | FinnAPL | |

Separating date IS - YYYYMMDD format. | (IW IX IY)←0 100 100⊤IS | APL2 | |

Separating variable length lines. | XV1,⎕TC[2],XV2 | FinnAPL | |

Sequence from NX for IX items. | N←∊NX+⍳¨IX | 0=⎕IO | APL2 |

Sequence from NX for IX items. | N←¯1+∊NX+⍳¨IX | 1=⎕IO | APL2 |

Setting a constant with hyphens. | ⎕LX←⍞ | FinnAPL | |

Shift B forward or backward IS positions. | B←((×IS)×⍴B)↑IS↓B | APL2 | |

Shifting vector XV left with IS without rotate. | (⍴XV)↑IS↓XV | FinnAPL | |

Shifting vector XV right with IS without rotate. | (-⍴XV)↑(-IS)↓XV | FinnAPL | |

Shur product. | 1 2 1 2⍉NM1∘.×NM2 | FinnAPL | |

Sign of point ZS relative to edges of Z. | V←×11○(ZS-1↓Z)×+2-/Z | APL2 | |

SIGN. Transfer of sign from NAY to NAX. | NA←(×NAY)×|NAX | APL2 | |

Sine of a complex number. | (2 2⍴1 6 2 5)×.○NA | ≢NA ←→ 2 | FinnAPL |

Sine of NA in radians. | FA←1○NA | APL2 | |

Size of range of elements of NV. | (⌈/NV)-⌊/NV | FinnAPL | |

Skew by 30 percent in y. | ZA←ZA+¯11○.3×9○ZA | APL2 | |

Smallest possible number. | FS←⌈/⍬ | APL2 | |

Sort by highfliers - M ←→ groups of length L. | M←M[⍒L/L;] | APL2 | |

Sort each column in ascending order. | (,⍉A)←(,A)[⍋,A+(⍴A)⍴(⌈/,A)×⍳×/¯1↓⍴A] | APL2 | |

Sort each column in ascending order. | A←↑[I](⊂¨⍋¨A)⌷¨A←⊂[I←¯2+⍴⍴A]A | 1=⎕IO ⋄ 2≤⍴⍴A | APL2 |

Sort each column in ascending order. | A←↑[I](⊂¨⍋¨A)⌷¨A←⊂[I←¯1+⍴⍴A]A | 0=⎕IO ⋄ 2≤⍴⍴A | APL2 |

Sort each row in ascending order. | (,A)←(,A)[⍋,A+(⊃⌽⍴A)/(⌈/,A)×⍳×/¯1↓⍴A] | APL2 | |

Sort each row in ascending order. | A←↑(⊂¨⍋¨A)⌷¨A←⊂[¯1+⍴⍴A]A←1/A | 1=⎕IO | APL2 |

Sort each row in ascending order. | A←↑(⊂¨⍋¨A)⌷¨A←⊂[⍴⍴A]A←1/A | 0=⎕IO | APL2 |

Sorting a matrix according to Y:th column. | NM[⍋NM[;Y];] | FinnAPL | |

Sorting a matrix into lexicographic order. | NM[⍋+⌿A<.-⍉A←NM,0;] | FinnAPL | |

Sorting a matrix into reverse lexicographic order. | NM[⍒+⌿A<.-⍉A←NM,0;] | FinnAPL | |

Sorting CM in ascending row order. | CM←CM[⍋⎕UCS CM;] | APL2 | |

Sorting CM in descending row order. | CM←CM[⍒⎕UCS CM;] | APL2 | |

Sorting CM in reverse SEQ order. | CM←CM[SEQ⍒CM;] | APL2 | |

Sorting CM in SEQ row order. | CM←CM[SEQ⍋CM;] | APL2 | |

Sorting CVV in alphabetical order. | CVV←CVV[⍋⎕UCS↑CVV] | APL2 | |

Sorting indices IV according to data NV. | IV[⍋NV[IV]] | FinnAPL | |

Sorting NM in ascending row order. | NM←NM[⍋NM;] | APL2 | |

Sorting NM in descending row order. | NM←NM[⍒NM;] | APL2 | |

Sorting NV into ascending order. | NV[⍋NV] | FinnAPL | |

Sorting NV into descending order. | NV[⍒NV] | FinnAPL | |

Sorting rows of matrix NM into ascending order. | (⍴NM)⍴(,NM)[A[⍋(,⍉(⌽⍴NM)⍴⍳≢NM)[A←⍋,NM]]] | FinnAPL | |

Sorting rows of matrix NM into ascending order. | A←(⍋,NM)-⎕IO ⋄ (⍴NM)⍴(,NM)[⎕IO+A[⍋⌊A÷¯1↑⍴NM]] | FinnAPL | |

Sorting rows of XM according to key XV (alphabetizing). | XM[⍋(1+⍴XV)⊥XV⍳⍉XM;] | FinnAPL | |

Sorting words in list CM according to word length. | CM[⍋CM+.≠' ';] | FinnAPL | |

Sorting XV2 according to XV1. | XV2[⍋XV1] | FinnAPL | |

Spacing out text. | ((2×⍴CV)⍴1 0)\CV | FinnAPL | |

Spacing out text. | ,CV,[1.1]' ' | FinnAPL | |

Split A into a vector of arrays given B. | VA←↑[1↓⍳⍴⍴A]¨(+\B)⊆⊂[1↓⍳⍴⍴A]A | APL2 | |

Split complex array into real and imaginary. | NA←9 11∘.○ZA | APL2 | |

Split V into subvectors given boolean B. | VV←(+\B)⊂V | APL2 | |

Split V into subvectors indicated by L. | VV←(L/⍳⍴L)⊆V | APL2 | |

Splitting a variable into a set of variables. | (N B I F Z)←VV | APL2 | |

Square of elements of NA without change of sign. | NA×|NA | FinnAPL | |

Square without changing sign. | NA←NA×|NA | APL2 | |

Standard deviation of NV. | ((+/(NV-(+/NV)÷⍴NV)*2)÷⍴NV)*.5 | FinnAPL | |

Starting points for IS1 fields of width IS2. | (IS1×IS2)⍴IS2↑1 | FinnAPL | |

Starting points for XV in indices pointed by IV. | (⍳⍴XV)∊IV | FinnAPL | |

Starting points of groups of equal elements (non-empty XV). | 1,(1↓XV)≠¯1↓XV | FinnAPL | |

Starting positions of subvectors having lengths IV. | #NAME? | FinnAPL | |

State of switch given BX=on and BY=off spikes. | B←≠\B\2≠/0,(B←BX∨BY)/BX | APL2 | |

Stereo pair. (Eye separation NS). | VZ←(¯.5 .5×NS)+⊂Z | APL2 | |

Students grades given score IA. | CA←'FDCBA'[+/IA∘.≥10×6 7 8 9] | 0=⎕IO | APL2 |

Students grades given score IA. | CA←'FDCBA'[+/IA∘.≥10×0 6 7 8 9] | 1=⎕IO | APL2 |

Successive transposes of XA (IV1 after IV2: IV1⍉IV2⍉XA). | IV1[IV2]⍉XA | FinnAPL | |

Sum by bucket. U = buckets. | N←N+.×V∘.≡U | ⍴N ←→ ⍴V | APL2 |

Sum elements of NV1 marked by succeeding identicals in NV2. | A-¯1↓0,A←(NV2≠1↓NV2,0)/+\NV1 | FinnAPL | |

Sum of all elements in NA. | NS←+/∊NA | APL2 | |

Sum of alternating reciprocal series NV2÷NV1. | NV2-.÷NV1 | FinnAPL | |

Sum of common parts of matrices (matrix sum). | 1 2 1 2⍉NM1∘.+NM2 | FinnAPL | |

Sum of elements of NV. | +/NV | FinnAPL | |

Sum of magnitude of N. | NS←+/|N | APL2 | |

Sum of N. | NS←+/N | APL2 | |

Sum of numbers in character matrix XM. | ⍎,'+',XM | FinnAPL | |

Sum of reciprocal series NV2÷NV1. | NV2+.÷NV1 | FinnAPL | |

Sum of squares of NV. | NV+.*2 | FinnAPL | |

Sum of squares of NV. | NV+.×NV | FinnAPL | |

Sum of subvectors of V given boolean B. | N←+/¨(+\B)⊆V | APL2 | |

Sum of subvectors of V indicated by L. | N←+/¨(L/⍳⍴L)⊆V | APL2 | |

Sum of the elements of vector NV. | 1⊥NV | FinnAPL | |

Sum over elements of NV1 determined by elements of NV2. | NV1+.×NV2∘.=((⍳⍴NV2)=NV2⍳NV2)/NV2 | FinnAPL | |

Summation over subsets of XV specified by BA. | XV+.×BA | FinnAPL | |

Sums according to codes XA2. | (XA2∘.=XA1)+.×NA | FinnAPL | |

Sums over (+/) subvectors of NV indicated by BV. | A-¯1↓0,A←(1⌽BV)/+\NV | FinnAPL | |

Sums over (+/) subvectors of NV, lengths in IV. | A-¯1↓0,A←(+\NV)[+\IV] | FinnAPL | |

Swap real and imaginary. | ZA←¯11○+ZA | APL2 | |

SWIFT check digit from IS bank number. | IS←97+¯97|IS | APL2 | |

Syllabization of a Finnish word XV. | (~A∊1,⍴XV)/A←A/⍳⍴A←(1↓A,0)←~XV∊'aeiouyäö' | FinnAPL | |

Syntax error to stop execution. | ∘ | FinnAPL | |

Table of divisibility. | M←0=(1+⍳⌈/I)∘.|I | 0=⎕IO | APL2 |

Table of divisibility. | M←0=(⍳⌈/I)∘.|I | 1=⎕IO | APL2 |

Take of at most IA elements from XA. | (IA⌊⍴XA)↑XA | FinnAPL | |

Taking every IS:th element of XV. | (0=IS|⍳⍴XV)/XV | FinnAPL | |

Tangent of NA in radians. | FA←3○NA | APL2 | |

Taylor series at point X, coefficients Y. | N←+/Y×(X*N)÷!N←⍳⍴Y | 0=⎕IO | APL2 |

Taylor series at point X, coefficients Y. | N←+/Y×(X*N)÷!N←¯1+⍳⍴Y | 1=⎕IO | APL2 |

Temporary ravel of XA1 for indexing with IA. | A←⍴XA1 ⋄ XA1←,XA1 ⋄ XA1[IA]←XA2 ⋄ XA1←A⍴XA1 | FinnAPL | |

Temporary ravel of XA1 for indexing with IA. | A←,XA1 ⋄ A[IA]←XA2 ⋄ XA1←(⍴XA1)⍴A | FinnAPL | |

Test for antisymmetricity of square matrix NM. | ~0∊NM=-⍉NM | FinnAPL | |

Test for associativity of f1 and f2. | BS←((V f1 X)f2 Y)≡V f1 X f2 Y | APL2 | |

Test for commutativity of fn. | BS←⊃≡/X Y fn Y X | APL2 | |

Test for distributivity of f1 and f2. | BS←((V f1 X)f2 Y)≡⊃f1/V X f2⊂Y | APL2 | |

Test for symmetricity of matrix XM. | ⍎⍎'1','↑↓'[⎕IO+∧/(⍴XM)=⌽⍴XM],'''0~0∊XM=⍉XM''' | FinnAPL | |

Test for symmetricity of matrix XM. | ⍎(¯7*A∧.=⌽A←⍴XM)↑'0~0∊XM=⍉XM' | FinnAPL | |

Test for symmetricity of square matrix XM. | ~0∊XM=⍉XM | FinnAPL | |

Test if all elements of vector BV are equal. | ∨/∧/0 1∘.=BV | FinnAPL | |

Test if all elements of vector BV are equal. | BV∧.=∨/BV | FinnAPL | |

Test if all elements of vector BV are equal. | BV∧.=∧/BV | FinnAPL | |

Test if all elements of vector BV are equal. | ⍲/0 1∊BV | FinnAPL | |

Test if all elements of vector BV are equal. | (∧/BV)∨~∨/BV | FinnAPL | |

Test if all elements of vector BV are equal. | (∧/BV)=∨/BV | FinnAPL | |

Test if all elements of vector BV are equal. | ∧/BV÷∨/BV | FinnAPL | |

Test if all elements of vector BV are equal. | ≠/0 1∊BV | FinnAPL | |

Test if all elements of vector BV are equal. | ∧/BV/1⌽BV | FinnAPL | |

Test if all elements of vector BV are equal. | ~∧/BV∊~BV | FinnAPL | |

Test if all elements of vector BV are equal. | 0=(⍴BV)|+/BV | FinnAPL | |

Test if all elements of vector NV are equal. | (⌈/NV)=⌊/NV | FinnAPL | |

Test if all elements of vector XV are equal. | ∧/⎕IO=XV⍳XV | FinnAPL | |

Test if all elements of vector XV are equal. | ∧/XV=1⌽XV | FinnAPL | |

Test if all elements of vector XV are equal. | ∧/XV=1↑XV | FinnAPL | |

Test if all elements of vector XV are equal. | ∧/XV=XV[1] | FinnAPL | |

Test if arrays are identical. | ~0∊XA1=XA2 | FinnAPL | |

Test if arrays of equal shape are identical. | ∧/,XA1=XA2 | ⍴XA1 ←→ ⍴XA2 | FinnAPL |

Test if circular lists are equal (excluding phase). | ∨/XV2∧.=⍉(⍳⍴XV1)⌽(2⍴⍴XV1)⍴XV1 | FinnAPL | |

Test if CV is a valid APL name. | ¯1≠⎕NC CV | FinnAPL | |

Test if each element of XV occurs only once. | ∧/(XV⍳XV)=⍳⍴XV | FinnAPL | |

Test if elements differ from next ones (non-empty XV). | (¯1↓XV≠1⌽XV),1 | FinnAPL | |

Test if elements differ from previous ones (non-empty XV). | 1,1↓XV≠¯1⌽XV | FinnAPL | |

Test if elements of XM1 belong to corr. row of XM2 (XM1[i;]∊XM2[i;]). | ∨/1 2 1 3⍉XM1∘.=XM2 | ≢XM1 ←→ ≢XM2 | FinnAPL |

Test if even. | ~2|IA | FinnAPL | |

Test if IA is a leap year. | (0=400|IA)∨(0≠100|IA)∧0=4|IA | FinnAPL | |

Test if integer. | NA=⌊NA | FinnAPL | |

Test if IS1 is an integer within range [ IS2,IS3 ). | ~IS1≤.≥(⌈IS1),IS2,IS3 | FinnAPL | |

Test if IV is a permutation vector. | IV∧.=⍋⍋IV | FinnAPL | |

Test if IV is a permutation vector. | IV[⍋IV]∧.=⍳⍴IV | FinnAPL | |

Test if IV is a permutation vector. | ∧/1=+⌿IV∘.=⍳⍴IV | FinnAPL | |

Test if IV is a permutation vector. | ∧/(⍳⍴IV)∊IV | FinnAPL | |

Test if NA is in ascending order along direction IS. | ∧/[IS]NA=⌈\[IS]NA | FinnAPL | |

Test if NA is in descending order along direction IS. | ∧/[IS]NA=⌊\[IS]NA | FinnAPL | |

Test if NA is within range ( NM[1;],NM[2;] ]. | NA<.≤NM | ≢NQ ←→ 2 | FinnAPL |

Test if NA is within range ( NM[1;],NM[2;] ]. | (NA,[.1+⍴⍴NA]NA)>.>NM | ≢NQ ←→ 2 | FinnAPL |

Test if NA is within range ( NV[1],NV[2] ). | (NV[1]<NA)∧NA<NV[2] | FinnAPL | |

Test if NA is within range [ NV[1],NV[2] ). | ≠/NA∘.≥NV | FinnAPL | |

Test if NA is within range [ NV[1],NV[2] ]. | (NV[1]≤NA)∧(NA≤NV[2]) | 2=⍴NQ | FinnAPL |

Test if NM is a lower triangular matrix. | ∧/,(0≠NM)≤A∘.≥A←⍳≢NM | FinnAPL | |

Test if NM is an upper triangular matrix. | ∧/,(0≠NM)≤A∘.≤A←⍳≢NM | FinnAPL | |

Test if NS is within range ( NM[1;],NM[2;] ]. | NS<.≤NM | ≢NQ ←→ 2 | FinnAPL |

Test if NS is within range [ NM[1;],NM[2;] ). | NS<.<NM | ≢NQ ←→ 2 | FinnAPL |

Test if numeric. | 0∊0\0⍴XV | FinnAPL | |

Test if numeric. | 0∊1↑0⍴XA | FinnAPL | |

Test if numeric and conversion to numeric form. | 1↓⍎'0 ',(∧/CV∊' ',⎕D)/CV | FinnAPL | |

Test if NV1 and NV2 are permutations of each other. | NV2[⍋NV2]∧.=NV1[⍋NV1] | FinnAPL | |

Test if rows of XA contain elements differing from XS. | XA∨.≠XS | FinnAPL | |

Test if single or scalar. | 1∊⍴,XA | FinnAPL | |

Test if the elements of NV are ascending. | NV<.≥1⌽NV | FinnAPL | |

Test if vector. | 1∊⍴⍴XA | FinnAPL | |

Test if vector XV is a row of array XA. | 1∊XA∧.=XV | FinnAPL | |

Test if XA and XV have elements in common. | ∨/XV∊XA | FinnAPL | |

Test if XA is an empty array. | 0∊⍴XA | FinnAPL | |

Test if XA is boolean. | ∧/,XA∊0 1 | FinnAPL | |

Test if XV is a subset of XA (XV ⊂ XA). | ∧/XV∊XA | FinnAPL | |

Test relations of elements of NA1 to range NA2; result in ¯2…2. | +/×NA1∘.-NA2 | 2=¯1↑⍴NA2 | FinnAPL |

Tests the social security number (Finnish). | (¯1↑X)=((~Y∊'GIOQ')/Y)[1+31|⍎9↑X] | 10=⍴X | FinnAPL |

Text (including quotes) in expression. | C←(B∨≠\B←C='''')/C | APL2 | |

Text (with first quote) in expression. | C←(≠\C='''')/C | APL2 | |

Text (without quotes) in expression. | VV←((~B)∧≠\B←C='''')⊆C | APL2 | |

The average # of lines per pgm. in a WS. | IS←(+/⊃¨⍴¨⎕CR¨⊂[1]M)÷≢M←⎕NL 3 4 | 0=⎕IO | APL2 |

The average # of lines per pgm. in a WS. | IS←(+/⊃¨⍴¨⎕CR¨⊂[2]M)÷≢M←⎕NL 3 4 | 1=⎕IO | APL2 |

The enclose of the items of PV (which must be of depth 2) catenated along their first axes. | ⍪/PV | Dyalog | |

The enclose of the items of PV (which must be of depth 2) catenated along their last axes. | ,/PV | Dyalog | |

The Exponential. e to the NAth power. | FA←*NA | APL2 | |

The first item in any rank array. | A←⊃A | APL2 | |

The first sub-array along the first axis of XA. | ⊣⌿XA | Dyalog | |

The first sub-array along the last axis of XA. | ⊣/XA | Dyalog | |

The index of positive integers in IV. | A←9999⍴⎕IO+⍴IV ⋄ A[⌽IV]←⌽⍳⍴IV ⋄ A[IA] | FinnAPL | |

The item in the bottom right of XA (⎕ML<2). | ⊃⌽,XA | Dyalog | |

The item in the bottom right of XA (⎕ML≥2). | ↑⌽,XA | Dyalog | |

The item in the top right of XA (⎕ML<2). | ⊃⌽XA | Dyalog | |

The item in the top right of XA (⎕ML≥2). | ↑⌽XA | Dyalog | |

The last item in any rank array. | A←⊃⌽,A | APL2 | |

The last sub-array along the first axis of XA. | ⊢⌿XA | Dyalog | |

The last sub-array along the last axis of XA. | ⊢/XA | Dyalog | |

The length of the first axis of each item in XA (⎕ML<2). | ⊃∘⍴¨XA | Dyalog | |

The length of the first axis of each item in XA (⎕ML≥2). | ↑∘⍴¨XA | Dyalog | |

The natural logarithm of NA. | FA←⍟NA | APL2 | |

The NAX based logarithm of NAY. | FA←NAX⍟NAY | APL2 | |

The NAYth root of the items in NAX. | FA←NAX*÷NAY | APL2 | |

The number of code lines in a workspace. | IS←+/⊃¨⍴¨⎕CR¨⊂[1]⎕NL 3 4 | 0=⎕IO | APL2 |

The number of code lines in a workspace. | IS←+/⊃¨⍴¨⎕CR¨⊂[2]⎕NL 3 4 | 1=⎕IO | APL2 |

The number of leading 1s in each row of BA. | +/∧\BA | Dyalog | |

The number of leading blank spaces in each row of CA. | +/∧\' '=CA | Dyalog | |

The number of objects in a workspace. | IS←≢⎕NL 2 3 4 | APL2 | |

The positions in BV corresponding to the 1s in XV. | XV/⍳⍴BV | Dyalog | |

The prototype of A. | A←⊃0⍴⊂⊃A | APL2 | |

The rank of XA as a 1-element vector. | ⍴⍴XA | Dyalog | |

The rank of XA as a scalar. | ≢⍴XA | Dyalog | |

The subset of BV corresponding to the 1s in NS. | NS/⍳BV | Dyalog | |

The subset of XV in the index positions defined by NA (equivalent to XV[NA]). | NA⊃¨⊂XV | Dyalog | |

The type of A. | A←⊃0⍴⊂A | APL2 | |

Three wise rolling average. | AVG3←(3+/NA)÷3 | APL2 | |

Total standard deviation of A. | STD←((+/(,A-(+/,A)÷1⌈⍴,A)*2)÷1⌈¯1+⍴,A)*.5 | APL2 | |

Total theoretical standard deviation of A. | STD←((+/(,A-(+/,A)÷N)*2)÷N←1⌈⍴,A)*.5 | APL2 | |

Total theoretical variance of A. | VAR←(+/(,A-(+/,A)÷N)*2)÷N←1⌈⍴,A | APL2 | |

Total variance of A. | VAR←(+/(,A-(+/,A)÷1⌈⍴,A)*2)÷1⌈¯1+⍴,A | APL2 | |

Transpose every submatrix of A. | A←(⍋(-⍴⍴A)↑1 0)⍉A | APL2 | |

Transpose matrix XM on condition BS. | (BS⌽1 2)⍉XM | FinnAPL | |

'Transpose' of matrix XM with column fields of width Y. | ((⌽A)×1,Y)⍴2 1 3⍉(1⌽Y,A←(⍴XM)÷1,Y)⍴XM | FinnAPL | |

Transpose of planes of a rank three array. | 1 3 2⍉XQ | FinnAPL | |

Truth table with IS variables. | M←2|⌊(⍳2*IS)∘.÷1+2*IS-⍳IS | 0=⎕IO | APL2 |

Truth table with IS variables. | M←2|⌊(¯1+⍳2*IS)∘.÷2*IS-⍳IS | 1=⎕IO | APL2 |

Truth table: All possibilities of and(∧). | CM←('∧-',B),[0]B,'|',B∘.∧B←0 1 | 0=⎕IO | APL2 |

Truth table: All possibilities of and(∧). | CM←('∧-',B),[1]B,'|',B∘.∧B←0 1 | 1=⎕IO | APL2 |

Truth table: All possibilities of nand(⍲). | CM←('⍲-',B),[0]B,'|',B∘.⍲B←0 1 | 0=⎕IO | APL2 |

Truth table: All possibilities of nand(⍲). | CM←('⍲-',B),[1]B,'|',B∘.⍲B←0 1 | 1=⎕IO | APL2 |

Truth table: All possibilities of nor(⍱). | CM←('⍱-',B),[0]B,'|',B∘.⍱B←0 1 | 0=⎕IO | APL2 |

Truth table: All possibilities of nor(⍱). | CM←('⍱-',B),[1]B,'|',B∘.⍱B←0 1 | 1=⎕IO | APL2 |

Truth table: All possibilities of or(∨). | CM←('∨-',B),[0]B,'|',B∘.∨B←0 1 | 0=⎕IO | APL2 |

Truth table: All possibilities of or(∨). | CM←('∨-',B),[1]B,'|',B∘.∨B←0 1 | 1=⎕IO | APL2 |

Two column matrix from one vector. | M←((⌈.5×⍴V),2)⍴V | APL2 | |

Two column matrix from two vectors. | M←X,[.5]Y | 0=⎕IO | APL2 |

Two column matrix from two vectors. | M←X,[1.5]Y | 1=⎕IO | APL2 |

Two row matrix from two vectors. | M←X,[¯.5]Y | 0=⎕IO | APL2 |

Two row matrix from two vectors. | M←X,[.5]Y | 1=⎕IO | APL2 |

Type of simple A. 1-char, 2-num, 3-mixed. | IO←1+(0,⍴,A)⍳0+.=⊃¨0⍴¨,A | 0=⎕IO | APL2 |

Type of simple A. 1-char, 2-num, 3-mixed. | IO←(0,⍴,A)⍳0+.=⊃¨0⍴¨,A | 1=⎕IO | APL2 |

Underlines a string. | CM←C,[¯.5]'¯' | 0=⎕IO | APL2 |

Underlines a string. | CM←C,[.5]'¯' | 1=⎕IO | APL2 |

Underlines non-blanks in a string. | CM←C,(⎕UCS 10),(C≠' ')\'¯' | APL2 | |

Underlining a string. | CV,[⎕IO-.1]'¯' | FinnAPL | |

Underlining words. | CV,[⎕IO-.1](' '≠CV)\'¯' | FinnAPL | |

Union of sets, ? | XV2,(~XV1∊XV2)/XV1 | FinnAPL | |

Union of two sets of numbers. | V←Y,(~X∊Y)/X | APL2 | |

Union of two sets of numbers. | V←Y,X~Y | APL2 | |

Unique. Drop duplicates from list. | MU←(∨⌿<\M∧.=⍉M)⌿M | APL2 | |

Unique. Drop duplicates from ordered list. | MU←(¯1↓1,∨/MG≠1⊖MG)⌿MG | APL2 | |

Unique. Drop duplicates from ordered vector. | U←(¯1↓1,V≠1⌽V)/V | APL2 | |

Unique. Drop duplicates from vector. | U←((V⍳V)=⍳⍴V)/V | APL2 | |

Unique. Drop duplicates from vector. | U←(∨⌿<\V∘.=V)/V | APL2 | |

Unit cube. | M←2 2 2⊤1+⍳8 | 0=⎕IO | APL2 |

Unit cube. | M←2 2 2⊤⍳8 | 1=⎕IO | APL2 |

Unit square. | M←2 2⊤1+⍳4 | 0=⎕IO | APL2 |

Unit square. | M←2 2⊤⍳4 | 1=⎕IO | APL2 |

Unit tesseract. | M←2 2 2 2⊤1+⍳16 | 0=⎕IO | APL2 |

Unit tesseract. | M←2 2 2 2⊤⍳16 | 1=⎕IO | APL2 |

Unpack a vector into an array based on BA. | ((,BA)/,A)←V | APL2 | |

Using a variable named according to XS. | ⍎'VAR',(⍕XS),'←XA' | FinnAPL | |

Using boolean matrix BM in expanding XV. | (⍴BM)⍴(,BM)\XV | FinnAPL | |

Using default value 100 if XA does not exist. | ⍎(¯3*2≠⎕NC 'XA')↑'XA100' | FinnAPL | |

Value of fixed-degree polynomial NV at points NA. | NV[3]+NA×NV[2]+NA×NV[1] | FinnAPL | |

Value of polynomial with coefficients NA at point NS. | NS⊥NA | FinnAPL | |

Value of polynomial with coefficients NA at point NS. | (NS*¯1+⍳⍴NA)+.×⌽NA | FinnAPL | |

Value of polynomial with coefficients NV2 at points NV1. | (NV1∘.+,0)⊥NV2 | FinnAPL | |

Value of saddle point. | (<\,(NM=(⍴NM)⍴⌈⌿NM)∧NM=⍉(⌽⍴NM)⍴⌊/NM)/,NM | FinnAPL | |

Value of Taylor series with coefficients NV at point NS. | +/NV×(NS*A)÷!A←¯1+⍳⍴NV | FinnAPL | |

Value of Taylor series with coefficients NV at point NS. | +/NV××\1,NS÷⍳¯1+⍴NV | FinnAPL | |

Variance (dispersion) of NV. | (+/(NV-(+/NV)÷⍴NV)*2)÷⍴NV | FinnAPL | |

Vector (cross) product of vectors. | ((1⌽NA1)×¯1⌽NA2)-(¯1⌽NA1)×1⌽NA2 | FinnAPL | |

Vector (IV[1]⍴1),(IV[2]⍴0),(IV[3]⍴1),… | ≠\(⍳+/IV)∊+\⎕IO,IV | FinnAPL | |

Vector (IV1[1]⍴1),(IV2[1]⍴0),(IV1[2]⍴1),… | (⍳+/IV1,IV2)∊+\1+¯1↓0,((⍳+/IV1)∊+\IV1)\IV2 | FinnAPL | |

Vector (IV2[1]+⍳IV1[1]),(IV2[2]+⍳IV1[2]),(IV2[3]+⍳IV1[3]),… | ⎕IO++\1+((⍳+/IV1)∊+\⎕IO,IV1)\IV2-¯1↓1,IV1+IV2 | ⍴IV1 ←→ ⍴IV2 | FinnAPL |

Vector having as many ones as XM has rows. | ∨/0/XM | FinnAPL | |

Vector of length IS2 with IS1 ones on the left, the rest zeroes. | IS2↑IS1⍴1 | FinnAPL | |

Vector of matrices to matrix of vectors. | MV←⍉↑⊂[1]¨VM | 0=⎕IO | APL2 |

Vector of matrices to matrix of vectors. | MV←⍉↑⊂[2]¨VM | 1=⎕IO | APL2 |

Vector of matrices to vector of vectors. | VV←⊃,/⊂[1]¨VM | 0=⎕IO | APL2 |

Vector of matrices to vector of vectors. | VV←⊃,/⊂[2]¨VM | 1=⎕IO | APL2 |

Vector of positions of ones in boolean array. | VP←(,BA)/,⊃∘.,/⍳¨⍴BA | APL2 | |

Vector to expand a new element after each one in BV. | (,BV,[1.5]1)/,BV,[1.5]~BV | FinnAPL | |

Vector to matrix at selected characters. | CM←↑(~V∊C)⊆V | APL2 | |

Vectorize - for any rank. | V←⊂[1↓⍳⍴⍴A]1/A | APL2 | |

Vectorize - keep only 1st column of M. | V←M[;0] | 0=⎕IO | APL2 |

Vectorize - keep only 1st column of M. | V←M[;1] | 1=⎕IO | APL2 |

Vectors as column matrices in catenation beneath each other. | X,[1+.5×⌈/(⍴⍴X),⍴⍴Y]Y | FinnAPL | |

Vectors as row matrices in catenation upon each other. | X,[.5×⌈/(⍴⍴X),⍴⍴Y]Y | FinnAPL | |

Weekday (S-S:0-6) given Y M D. | IS←7|+/D(⍎M⊃'0032503514624'),⌊5 1.25×4 100⊤Y-3>M | 1=⎕IO | APL2 |

Weekday (S-S:0-6) given Y M D. | IS←7|+/D(⍎M⊃'032503514624'),⌊5 1.25×4 100⊤Y-3>M | 0=⎕IO | APL2 |

Weekday (S-S:0-6) of first of year IS (YYYY). | IS←7|6+IS+-/⌈IS÷4 100 400 | APL2 | |

Weighted average of vector/matrix columns. | WAVG←(N+.×NM)÷+/N | APL2 | |

Weighted average of vector/matrix rows. | WAVG←(NM+.×N)÷+/N | APL2 | |

WHERE. Execute "fn" on condition B mask. | ((,B)/,A)←fn(,B)/,A | APL2 | |

Which class do elements of NA belong to. | +/NA∘.≥0 50 100 1000 | FinnAPL | |

Which elements of XA are not in set XV (difference of sets). | (⎕IO+⍴XV)=XV⍳XA | FinnAPL | |

Which rows of M are all numeric? | B←0∧.=↑¨0⍴¨M | APL2 | |

Widening matrix XM1 to be compatible with XM2. | ((0 1×⍴XM2)⌈⍴XM1)↑XM1 | FinnAPL | |

Window enclosing Z. | Z←0J1⊥0 1⌽2/|⌊/M,[0.5]-M←11 9∘.○Z | 0=⎕IO | APL2 |

Window enclosing Z. | Z←0J1⊥0 1⌽2/|⌊/M,[1.5]-M←11 9∘.○Z | 1=⎕IO | APL2 |

Word lengths of words in list CA. | CA+.≠' ' | FinnAPL | |

XA1 (XA2 is ignored). | XA1{⍺}XA2 | Dyalog | |

XA1 and XA2 are ignored (no result produced). | XA1{}XA2 | Dyalog | |

XA1 and XA2 as a two item vector (XA1 XA2). | XA1{⍺ ⍵}XA2 | Dyalog | |

XA1 redefined to be XA1 with XA2 catenated along its first axis. | XA1⍪←XA2 | Dyalog | |

XA1 redefined to be XA1 with XA2 catenated along its last axis. | XA1,←XA2 | Dyalog | |

XA2 (XA1 is ignored). | XA1{⍵}XA2 | Dyalog | |

XM with the rows sorted into numerical or alphabetical order. | {⍵[⍋⍵;]}XM | Dyalog | |

XM with the rows sorted into reverse numerical or alphabetical order. | {⍵[⍒⍵;]}XM | Dyalog | |

XM1⍳XM2 for rows of matrices. | ⎕IO++⌿∧⍀XM1∨.≠⍉XM2 | FinnAPL | |

XV sorted into numerical or alphabetical order. | {⍵[⍋⍵]}XV | Dyalog | |

XV sorted into reverse numerical or alphabetical order. | {⍵[⍒⍵]}XV | Dyalog | |

Y:th moment of NV. | (+/(NV-(+/NV)÷⍴NV)*Y)÷⍴NV | FinnAPL | |

Z←AX(lo OAX I)AY. Run "lo" on axes I of AX. | Z←↑[I](⊂[I]AX)lo⊂AY | APL2 | |

Z←AX(lo OAY I)AY. Run "lo" on axes I of AY. | Z←↑[I](⊂AX)lo⊂[I]AY | APL2 | |

Z←X(lo IO B)Y;⎕IO. Run "lo" in origin B. | Z←X lo Y⊣⎕IO←B | APL2 | |

Z←X(lo PR)Y. Perform "lo" as scalar. | ⍎'Z←X lo ',((1<|≡Y)/'PR¨'),'Y' | APL2 | |

Zero array of shape and size of NA. | 0×NA | FinnAPL | |

Zero or space depending on the type of XA (fill element). | 1↑0⍴XA | FinnAPL | |

Zeroing a vector (without change of size). | NV[]←0 | FinnAPL | |

Zeroing all boolean values. | 0∧BA | FinnAPL | |

Zeroing elements of NA1 depending on their values. | NA1×~NA1∊NA2 | FinnAPL | |

Zeros, same shape and structure. | B←A≠A | APL2 | |

Zeros, same shape plus one. | B←0+/V | APL2 | |

Zeros, same shape when A is simple. | B←A∊⍬ | APL2 |