In [ ]:

]box on -style=max -trains=tree -fns=on

Out[ ]:

┌→─────────────────────────────────────┐
│Was ON -style=max -trains=tree -fns=on│
└──────────────────────────────────────┘

Sets and stuff¶

`∊` (Epsilon)¶

monadic `∊` (Enlist)¶

In [ ]:

⎕←mat←2 3⍴⍳6

Out[ ]:

┌→────┐
↓1 2 3│
│4 5 6│
└~────┘

In [ ]:

∊ 0 mat (7 8) 'nine'

Out[ ]:

┌→─────────────────────┐
│0 1 2 3 4 5 6 7 8 nine│
└+─────────────────────┘

dyadic `∊` (Member of)¶

In [ ]:

'abc' 4 ∊ 4 'ab' 'abcd'

Out[ ]:

┌→──┐
│0 1│
└~──┘

In [ ]:

mat←2 3⍴⍳6
mat ∊ 6 2 7 4

Out[ ]:

┌→────┐
↓0 1 0│
│1 0 1│
└~────┘

`⍷` (Epsilon Underbar)¶

dyadic `⍷` (Find)¶

In [ ]:

1 ⍷ 3 1 4 1 5 9 2

Out[ ]:

┌→────────────┐
│0 1 0 1 0 0 0│
└~────────────┘

In [ ]:

1 4 ⍷ 3 1 4 1 5 9 2

Out[ ]:

┌→────────────┐
│0 1 0 0 0 0 0│
└~────────────┘

In [ ]:

'ana' ⍷ 'Banana'

Out[ ]:

┌→──────────┐
│0 1 0 1 0 0│
└~──────────┘

In [ ]:

X ← 2 2 ⍴ 0 1 1 0
Y ← 4 4 ⍴ 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0
X Y

Out[ ]:

┌→────────────────┐
│ ┌→──┐ ┌→──────┐ │
│ ↓0 1│ ↓0 1 0 0│ │
│ │1 0│ │1 0 0 1│ │
│ └~──┘ │0 0 1 0│ │
│       │0 1 0 0│ │
│       └~──────┘ │
└∊────────────────┘

In [ ]:

X ⍷ Y

Out[ ]:

┌→──────┐
↓1 0 0 0│
│0 0 1 0│
│0 1 0 0│
│0 0 0 0│
└~──────┘

`∩` (Up shoe)¶

dyadic `∩` (Intersection)¶

In [ ]:

'ABRA'∩'CAR'

Out[ ]:

┌→──┐
│ARA│
└───┘

In [ ]:

22 'ab' 'fg' ∩ 'a' 'ab' 22

Out[ ]:

┌→────────┐
│    ┌→─┐ │
│ 22 │ab│ │
│    └──┘ │
└∊────────┘

`∪` (Down shoe)¶

monadic `∪` (Unique)¶

In [ ]:

a ← 2 3 4 2 3 4 5

In [ ]:

∪a

Out[ ]:

┌→──────┐
│2 3 4 5│
└~──────┘

In [ ]:

(≠a)/a 

Out[ ]:

┌→──────┐
│2 3 4 5│
└~──────┘

In [ ]:

∪ 'ab' 'ba' 'ab' 1 1 2

Out[ ]:

┌→──────────────┐
│ ┌→─┐ ┌→─┐     │
│ │ab│ │ba│ 1 2 │
│ └──┘ └──┘     │
└∊──────────────┘

dyadic `∪` (Union)¶

In [ ]:

'ABRA'∪'CAR'

Out[ ]:

┌→────┐
│ABRAC│
└─────┘

In [ ]:

22 'ab' 'fg' ∪ 'a' 'ab' 22

Out[ ]:

┌→───────────────┐
│    ┌→─┐ ┌→─┐   │
│ 22 │ab│ │fg│ a │
│    └──┘ └──┘ - │
└∊───────────────┘

Sort / index¶

`⌷` (Squad)¶

monadic `⌷` (Materialise)¶

For ⌷ ⍵: If ⍵ is an array, returns ⍵. For a class/COM/.Net object, it materialises the items.

dyadic `⌷` (Index)¶

In [ ]:

v ← 2×⍳12
3⌷v

Out[ ]:

In [ ]:

(⊂3 5) ⌷v

Out[ ]:

┌→───┐
│6 10│
└~───┘

In [ ]:

⎕ ← mat ← 3 4 ⍴⍳12

Out[ ]:

┌→─────────┐
↓1  2  3  4│
│5  6  7  8│
│9 10 11 12│
└~─────────┘

In [ ]:

2 3 ⌷ mat

Out[ ]:

`⍒` (Grade Down)¶

monadic `⍒` (Grade Down)¶

In [ ]:

⍒ 33 11 44 66 22

Out[ ]:

┌→────────┐
│4 3 1 5 2│
└~────────┘

In [ ]:

a ← 33 11 44 66 22

In [ ]:

a[⍒a]

Out[ ]:

┌→─────────────┐
│66 44 33 22 11│
└~─────────────┘

In [ ]:

a⌷⍨⊂⍒a

Out[ ]:

┌→─────────────┐
│66 44 33 22 11│
└~─────────────┘

{⍵[⍋⍵]} and {(⊂⍋⍵)⌷⍵} are sort idioms (special cased for performance)

In [ ]:

sort ← ⌷⍨∘⊂∘⍒⍨

In [ ]:

sort a

Out[ ]:

┌→─────────────┐
│66 44 33 22 11│
└~─────────────┘

In [ ]:

tsort ← (⊂∘⍒)⌷⊢  ⍝ h/t Rory Kemp

In [ ]:

tsort a

Out[ ]:

┌→─────────────┐
│66 44 33 22 11│
└~─────────────┘

dyadic `⍒` (Dyadic Grade Down)¶

In [ ]:

a ← 'abcdefgabcdefg'

In [ ]:

b ← 'cgf' ⍒ a

In [ ]:

a⌷⍨⊂b

Out[ ]:

┌→─────────────┐
│abdeabdeffggcc│
└──────────────┘

`⍋` (Grade Up)¶

monadic `⍋` (Grade Up)¶

In [ ]:

⍋ 33 11 44 66 22

Out[ ]:

┌→────────┐
│2 5 1 3 4│
└~────────┘

In [ ]:

a ← 33 11 44 66 22

In [ ]:

a[⍋a]

Out[ ]:

┌→─────────────┐
│11 22 33 44 66│
└~─────────────┘

In [ ]:

a⌷⍨⊂⍋a

Out[ ]:

┌→─────────────┐
│11 22 33 44 66│
└~─────────────┘

dyadic `⍒` (Dyadic Grade Down)¶

In [ ]:

a ← 'abcdefgabcdefg'
b ← 'cgf' ⍋ a
a⌷⍨⊂b

Out[ ]:

┌→─────────────┐
│ccggffabdeabde│
└──────────────┘

Rotate / transpose / flip¶

`⌽` (Circle Stile)¶

monadic `⌽` (Reverse)¶

In [ ]:

⌽ 'trams'

Out[ ]:

┌→────┐
│smart│
└─────┘

In [ ]:

⎕ ← mat ← 3 4 ⍴⍳12

Out[ ]:

┌→─────────┐
↓1  2  3  4│
│5  6  7  8│
│9 10 11 12│
└~─────────┘

In [ ]:

⌽ mat

Out[ ]:

┌→─────────┐
↓ 4  3  2 1│
│ 8  7  6 5│
│12 11 10 9│
└~─────────┘

dyadic `⌽` (Rotate)¶

In [ ]:

1 ⌽ 'HatStand'

Out[ ]:

┌→───────┐
│atStandH│
└────────┘

In [ ]:

3 ⌽ 'HatStand'

Out[ ]:

┌→───────┐
│StandHat│
└────────┘

In [ ]:

¯2 ⌽ 1 2 3 4 5 6

Out[ ]:

┌→──────────┐
│5 6 1 2 3 4│
└~──────────┘

In [ ]:

⎕ ← mat ← 3 4 ⍴⍳12

Out[ ]:

┌→─────────┐
↓1  2  3  4│
│5  6  7  8│
│9 10 11 12│
└~─────────┘

In [ ]:

¯1 ⌽ mat

Out[ ]:

┌→─────────┐
↓ 4 1  2  3│
│ 8 5  6  7│
│12 9 10 11│
└~─────────┘

In [ ]:

1 ¯1 2 ⌽ mat

Out[ ]:

┌→─────────┐
↓ 2  3 4  1│
│ 8  5 6  7│
│11 12 9 10│
└~─────────┘

`⊖` (Circle Bar)¶

monadic `⊖` (Reverse First)¶

In [ ]:

⊖ 'trams'

Out[ ]:

┌→────┐
│smart│
└─────┘

In [ ]:

mat ← 3 4 ⍴⍳12
⊖ mat

Out[ ]:

┌→─────────┐
↓9 10 11 12│
│5  6  7  8│
│1  2  3  4│
└~─────────┘

dyadic `⊖` (Rotate First)¶

In [ ]:

3 ⊖ 'HatStand'

Out[ ]:

┌→───────┐
│StandHat│
└────────┘

In [ ]:

mat ← 3 4 ⍴⍳12
¯1 ⊖ mat

Out[ ]:

┌→─────────┐
↓9 10 11 12│
│1  2  3  4│
│5  6  7  8│
└~─────────┘

`⍉` (Circle Bar)¶

monadic `⍉` (Transpose)¶

In [ ]:

mat ← 3 4 ⍴⍳12
⍉ mat

Out[ ]:

┌→─────┐
↓1 5  9│
│2 6 10│
│3 7 11│
│4 8 12│
└~─────┘

In [ ]:

⎕←cube ← 2 3 4 ⍴⍳24

Out[ ]:

┌┌→──────────┐
↓↓ 1  2  3  4│
││ 5  6  7  8│
││ 9 10 11 12│
││           │
││13 14 15 16│
││17 18 19 20│
││21 22 23 24│
└└~──────────┘

In [ ]:

⍉ cube

Out[ ]:

┌┌→────┐
↓↓ 1 13│
││ 5 17│
││ 9 21│
││     │
││ 2 14│
││ 6 18│
││10 22│
││     │
││ 3 15│
││ 7 19│
││11 23│
││     │
││ 4 16│
││ 8 20│
││12 24│
└└~────┘

In [ ]:

⍴⍉ cube

Out[ ]:

┌→────┐
│4 3 2│
└~────┘

dyadic `⊖` (Rotate First)¶

In [ ]:

mat ← 3 4 ⍴⍳12
2 1 ⍉ mat

Out[ ]:

┌→─────┐
↓1 5  9│
│2 6 10│
│3 7 11│
│4 8 12│
└~─────┘

In [ ]:

1 1 ⍉ mat  

Out[ ]:

┌→─────┐
│1 6 11│
└~─────┘

In [ ]:

⎕ ← cube ← 2 3 4 ⍴⍳24

Out[ ]:

┌┌→──────────┐
↓↓ 1  2  3  4│
││ 5  6  7  8│
││ 9 10 11 12│
││           │
││13 14 15 16│
││17 18 19 20│
││21 22 23 24│
└└~──────────┘

In [ ]:

⍴ 2 1 3 ⍉ cube

Out[ ]:

┌→────┐
│3 2 4│
└~────┘

In [ ]:

1 1 1⍉ cube

Out[ ]:

┌→───┐
│1 18│
└~───┘

In [ ]:

2 1 1⍉ cube

Out[ ]:

┌→────┐
↓ 1 13│
│ 6 18│
│11 23│
└~────┘

Other operators¶

`⌺` (Quad Diamond)¶

Dyadic operator `⌺` (Stencil)¶

In [ ]:

{⊂⍺ ⍵}⌺3 3⊢3 3⍴⍳12

Out[ ]:

┌→──────────────────────────────────────────────────────────┐
↓ ┌→──────────────┐  ┌→──────────────┐  ┌→───────────────┐  │
│ │ ┌→──┐ ┌→────┐ │  │ ┌→──┐ ┌→────┐ │  │ ┌→───┐ ┌→────┐ │  │
│ │ │1 1│ ↓0 0 0│ │  │ │1 0│ ↓0 0 0│ │  │ │1 ¯1│ ↓0 0 0│ │  │
│ │ └~──┘ │0 1 2│ │  │ └~──┘ │1 2 3│ │  │ └~───┘ │2 3 0│ │  │
│ │       │0 4 5│ │  │       │4 5 6│ │  │        │5 6 0│ │  │
│ │       └~────┘ │  │       └~────┘ │  │        └~────┘ │  │
│ └∊──────────────┘  └∊──────────────┘  └∊───────────────┘  │
│ ┌→──────────────┐  ┌→──────────────┐  ┌→───────────────┐  │
│ │ ┌→──┐ ┌→────┐ │  │ ┌→──┐ ┌→────┐ │  │ ┌→───┐ ┌→────┐ │  │
│ │ │0 1│ ↓0 1 2│ │  │ │0 0│ ↓1 2 3│ │  │ │0 ¯1│ ↓2 3 0│ │  │
│ │ └~──┘ │0 4 5│ │  │ └~──┘ │4 5 6│ │  │ └~───┘ │5 6 0│ │  │
│ │       │0 7 8│ │  │       │7 8 9│ │  │        │8 9 0│ │  │
│ │       └~────┘ │  │       └~────┘ │  │        └~────┘ │  │
│ └∊──────────────┘  └∊──────────────┘  └∊───────────────┘  │
│ ┌→───────────────┐ ┌→───────────────┐ ┌→────────────────┐ │
│ │ ┌→───┐ ┌→────┐ │ │ ┌→───┐ ┌→────┐ │ │ ┌→────┐ ┌→────┐ │ │
│ │ │¯1 1│ ↓0 4 5│ │ │ │¯1 0│ ↓4 5 6│ │ │ │¯1 ¯1│ ↓5 6 0│ │ │
│ │ └~───┘ │0 7 8│ │ │ └~───┘ │7 8 9│ │ │ └~────┘ │8 9 0│ │ │
│ │        │0 0 0│ │ │        │0 0 0│ │ │         │0 0 0│ │ │
│ │        └~────┘ │ │        └~────┘ │ │         └~────┘ │ │
│ └∊───────────────┘ └∊───────────────┘ └∊────────────────┘ │
└∊──────────────────────────────────────────────────────────┘

In [ ]:

s←2 2⍴3 3 2 2    ⍝ 2x2 stride with 3x3 kernel
({⊂⍵}⌺s)3 4⍴⍳12

Out[ ]:

┌→────────────────────┐
↓ ┌→────┐  ┌→────┐    │
│ ↓0 0 0│  ↓0 0 0│    │
│ │0 1 2│  │2 3 4│    │
│ │0 5 6│  │6 7 8│    │
│ └~────┘  └~────┘    │
│ ┌→─────┐ ┌→───────┐ │
│ ↓0 5  6│ ↓ 6  7  8│ │
│ │0 9 10│ │10 11 12│ │
│ │0 0  0│ │ 0  0  0│ │
│ └~─────┘ └~───────┘ │
└∊────────────────────┘

`@` (At)¶

Dyadic `@` (At)¶

In [ ]:

(0@2 4) ⍳6

Out[ ]:

┌→──────────┐
│1 0 3 0 5 6│
└~──────────┘

In [ ]:

(3 1@2 4) ⍳6

Out[ ]:

┌→──────────┐
│1 3 3 1 5 6│
└~──────────┘

In [ ]:

÷@2 4 ⍳6

Out[ ]:

┌→───────────────┐
│1 0.5 3 0.25 5 6│
└~───────────────┘

In [ ]:

10 (×@2 4) ⍳5

Out[ ]:

┌→──────────┐
│1 20 3 40 5│
└~──────────┘

In [ ]:

0@(2∘|)⍳6

Out[ ]:

┌→──────────┐
│0 2 0 4 0 6│
└~──────────┘

In [ ]:

⌽@(2∘|)⍳6

Out[ ]:

┌→──────────┐
│5 2 3 4 1 6│
└~──────────┘

Special non-math glyphs¶

`&` (Ampersand)¶

Monadic `&` (Spawn)¶

& spawns a new thread in which f is applied to its argument(s).

In [ ]:

÷&4   ⍝ Reciprocal in background

`→` (Branch)¶

Branching is superseded by the more modern control structures such as :If ... :EndIf.

`⍞` (Print without CR, or stdin)¶

When ⍞ is assigned with a vector or a scalar, the array is displayed without the normal ending new-line character.

In [ ]:

⍞←'2+2' ⋄ ⍞←'=' ⋄ ⍞←2+2

Out[ ]:

2+2=4

When ⍞ is referenced, terminal input is expected without any specific prompt, and the response is returned as a character vector (however this doesn't work in Jupyter).

In [ ]:

⎕←j ← 4 6 ⍴ '{     "a":1,"b":42}     '

Out[ ]:

┌→─────┐
↓{     │
│"a":1,│
│"b":42│
│}     │
└──────┘

`⍠` Variant¶

Used to pass options/variants to some system functions, such as JSON convert.

In [ ]:

⎕←mat←(⎕JSON⍠('Format' 'M'))j

Out[ ]:

┌→────────────┐
↓   ┌⊖┐ ┌⊖┐   │
│ 0 │ │ │0│ 1 │
│   └─┘ └~┘   │
│   ┌→┐       │
│ 1 │a│ 1   3 │
│   └─┘       │
│   ┌→┐       │
│ 1 │b│ 42  3 │
│   └─┘       │
└∊────────────┘

In [ ]:

1(⎕JSON⍠('Format' 'M')) mat

Out[ ]:

┌→─────────────┐
│{"a":1,"b":42}│
└──────────────┘

`⌶` (I-Beam)¶

I-Beam is a monadic operator that provides a range of system related services. WARNING: Although documentation is provided for I-Beam functions, any service provided using I-Beam should be considered as "experimental" and subject to change. As at Aug-2022 services include SVD, probability distributions, and much more.

`⍎` (Hydrant)¶

Monadic `⍎` (Execute expression)¶

In [ ]:

⍎ '1+1'

Out[ ]:

In [ ]:

V ← 1 2 3
⍎ 'V'

Out[ ]:

┌→────┐
│1 2 3│
└~────┘

In [ ]:

A← ⍎'1+1 ⋄ 2+2'

Out[ ]:

In [ ]:

Out[ ]:

Dyadic `⍎` (Execute expression in given namespace)¶

X must be a namespace reference or a simple character scalar or vector representing the name of a namespace in which the expression is to be executed.

`⍕` (Thorn)¶

Monadic `⍕` (Format)¶

In [ ]:

4 5 6  ⍝ These are numbers (see the `~` in bottom left)

Out[ ]:

┌→────┐
│4 5 6│
└~────┘

In [ ]:

⍕ 4 5 6  ⍝ These are characters (no `~` in bottom left)

Out[ ]:

┌→────┐
│4 5 6│
└─────┘

Dyadic `⍕` (Format By Specification)¶

Field-width and number of decimal places:

In [ ]:

6 2 ⍕ 3.125 0.002

Out[ ]:

┌→───────────┐
│  3.13  0.00│
└────────────┘

In [ ]:

Sets and stuff¶

∊ (Epsilon)¶

monadic ∊ (Enlist)¶

dyadic ∊ (Member of)¶

⍷ (Epsilon Underbar)¶

dyadic ⍷ (Find)¶

∩ (Up shoe)¶

dyadic ∩ (Intersection)¶

∪ (Down shoe)¶

monadic ∪ (Unique)¶

dyadic ∪ (Union)¶

Sort / index¶

⌷ (Squad)¶

monadic ⌷ (Materialise)¶

dyadic ⌷ (Index)¶

⍒ (Grade Down)¶

monadic ⍒ (Grade Down)¶

dyadic ⍒ (Dyadic Grade Down)¶

⍋ (Grade Up)¶

monadic ⍋ (Grade Up)¶

dyadic ⍒ (Dyadic Grade Down)¶

Rotate / transpose / flip¶

⌽ (Circle Stile)¶

monadic ⌽ (Reverse)¶

dyadic ⌽ (Rotate)¶

⊖ (Circle Bar)¶

monadic ⊖ (Reverse First)¶

dyadic ⊖ (Rotate First)¶

⍉ (Circle Bar)¶

monadic ⍉ (Transpose)¶

dyadic ⊖ (Rotate First)¶

Other operators¶

⌺ (Quad Diamond)¶

Dyadic operator ⌺ (Stencil)¶

@ (At)¶

Dyadic @ (At)¶

Special non-math glyphs¶

& (Ampersand)¶

Monadic & (Spawn)¶

→ (Branch)¶

⍞ (Print without CR, or stdin)¶

⍠ Variant¶

⌶ (I-Beam)¶

⍎ (Hydrant)¶

Monadic ⍎ (Execute expression)¶

Dyadic ⍎ (Execute expression in given namespace)¶

⍕ (Thorn)¶

Monadic ⍕ (Format)¶

Dyadic ⍕ (Format By Specification)¶

`∊` (Epsilon)¶

monadic `∊` (Enlist)¶

dyadic `∊` (Member of)¶

`⍷` (Epsilon Underbar)¶

dyadic `⍷` (Find)¶

`∩` (Up shoe)¶

dyadic `∩` (Intersection)¶

`∪` (Down shoe)¶

monadic `∪` (Unique)¶

dyadic `∪` (Union)¶

`⌷` (Squad)¶

monadic `⌷` (Materialise)¶

dyadic `⌷` (Index)¶

`⍒` (Grade Down)¶

monadic `⍒` (Grade Down)¶

dyadic `⍒` (Dyadic Grade Down)¶

`⍋` (Grade Up)¶

monadic `⍋` (Grade Up)¶

dyadic `⍒` (Dyadic Grade Down)¶

`⌽` (Circle Stile)¶

monadic `⌽` (Reverse)¶

dyadic `⌽` (Rotate)¶

`⊖` (Circle Bar)¶

monadic `⊖` (Reverse First)¶

dyadic `⊖` (Rotate First)¶

`⍉` (Circle Bar)¶

monadic `⍉` (Transpose)¶

dyadic `⊖` (Rotate First)¶

`⌺` (Quad Diamond)¶

Dyadic operator `⌺` (Stencil)¶

`@` (At)¶

Dyadic `@` (At)¶

`&` (Ampersand)¶

Monadic `&` (Spawn)¶

`→` (Branch)¶

`⍞` (Print without CR, or stdin)¶

`⍠` Variant¶

`⌶` (I-Beam)¶

`⍎` (Hydrant)¶

Monadic `⍎` (Execute expression)¶

Dyadic `⍎` (Execute expression in given namespace)¶

`⍕` (Thorn)¶

Monadic `⍕` (Format)¶

Dyadic `⍕` (Format By Specification)¶