abo-abo/j.org

## j.org

      
    Raw
  

              j.org
            
          
    Basics

Precedence

There’s none: only evaluation from right to left.
  Although adverbs and conjunctions are applied first.
Global Variables

=: is like `setq’

gvar =. 23
fun1 =: 3 : 0
gvar + y
)
fun2 =: 3 : 0
gvar =: 7
gvar + y
)
fun1 3
fun2 3
fun1 3
=. is like `let’

gvar =. 23
fun1 =: 3 : 0
gvar + y
)
fun2 =: 3 : 0
gvar =. 7
gvar + y
)
fun1 3
fun2 3
fun1 3
Comparisons

= dyad

23 = 34
23 = 23
Result is just a number:
10 + 3 = 3
< <: > >:

Control Structure

There are 9 control structure patterns:
if. T do. B end.

convert =: dyad : 0
if. x = 'c'
 do. *: y
 else. %: y
end.
)
'c' convert 4
'f' convert 4
if. T do. B else. B1 end.

x =: 3 : 0
if. y do. 2 else. 3 end.
)
x 0
if. T do. B elseif. T1 do. B1 elseif. T2 do. B2 end.

x =: 3 : 0
if. y = 1 do. 2 elseif. y = 2 do. 3 elseif. 1 do. y end.
)
x 1
x 2
x _10
try. B catch. B1 end.

x =: 3 : 0
try. 1 catch. 2 end.
)
x 1
while. T do. B end.

whilst. T do. B end.

for. T do. B end.

for_i. T do. B end.

select. T case. T0 do. B0 case. T1 do. B1 end.

Environment

Locale

Locale is equivalent to a namespace:
abc_def_ =: 2
is like def::abc = 2; in C++.
Locale defaults to base if elided:
abc_base_ =: 4
abc__
Names

depending on argument
0

list nouns
a =. 23
b =.  24
a_q_ =. 25
w_q_ =. 26
names 0
names_q_ 0
3

list verbs
foo =: 3 : 0
y * y
)
foo 5
names 3
6

list locale names
names 6
dyad

'n' names_z_ 3
Define a verb in a locale

NB. defines arg y as "a" in global locale
f_q_ =. 3 : 'a =: y'
a =. 23                         NB. define a in the base locale
a_q_ =. 24                      NB. define a in locale q
f_q_ 100
a
a_q_
z locale

names_z_ 0
names_z_ 3


scripts verb

”

scripts ''


‘v’

scripts 'v'


load verb

load 'convert'
toupper 'testing 1 2 3'
Debugging

define a function to debug

centigrade =. 3 : 0
t1 =. y - 32
t2 =. t1 * 5
t3 =. t2 % 9
)
load lib

load 'debug'
set breakpoint on all lines

dbss 'centigrade  *:*'
enable debugger

dbr 1
continue

dbrun ''
lists

assignment

a =. 12 24 47
b =. 12 34 45
a
b
index

a =. 12 24 47
0 { a
2 { a
append

a =. 1 2
b =. a , 3
b , 4
length

a =. 12 24 47
# a
reverse

|. 'abcdefg'
|. i.10
add lists

basic implementation

addlists =: dyad : 0
r =. ''
count =. #x
i =. 0
while. i < count do.
 left =. i { x
 right =. i { y
 sum =. left + right
 r =. r, sum
 i =. i + 1
end.
r
)
2 3 4 addlists 4 5 6
shorter implementation

adda =: dyad : 0
r =. ''
count =. #x
i =. 0
while. i < count do.
 r =. r , (i{x) + (i{y)
 i =. i + 1
end.
r
)
2 3 4 adda 4 5 6
J way

addb =: 4 : 'x + y'
2 3 4 addb 4 5 6
just +

2 3 4 + 4 5 6
+ variations

1 + 2 3 4
2 3 4 + 1
this works for - * % = < <: as well:
2 4 6 * 7 8 9
2 * 2 3 4
2 3 4 * 2
5 6 7 % 2
2 3 4 - 3
2 3 4 = 7 3 8
2 < 0 1 2 3 4 5
2 <: 0 1 2 3 4 5
't' = 'testing'


i. monad (integers)

approx range
i. 6
$ dyad (shape)

5 $ 7
? monad (roll)

Random number from 0 to arg.
? 10
? 10
? 10
? 10
? 0
combine $ ?
5 $ 100
? 5 $ 100                       NB. ? 100 100 100 100
^ dyad (power)

3 ^ 2
2 ^ 3
o. (circle)

with 1 on left gives sin
i.7
1 o. i.7
plot

load 'plot'
plot 5 10 23 45 8
load 'plot'
plot 2 ^ i.5
load 'plot'
plot ? 50 $ 100
load 'plot'
'TITLE myplot;TYPE bar' plot 2 ^ i.5
load 'plot'
plot 1 o. 0.1 * i.200


dimension

atom

23
  ‘a’
list

23 24 25
  ‘this is a string’
table and $ dyad (shape)

Can’t be written to, only created with $.
2 3 $ 7
2 3 $ i.6
3 4 $ 'abcdefghijklmnopqrstuv'
2 3 $ 7 8
$ monad (shape)

a =. 2 3 $ 7
$ a
i. a b creates table

i.2 3
higher dimension arrays

2 3 4 $ i.24
i. for higher dimension arrays

i. 2 3 4
shape of nouns

a =. 4 2 3 $ 'abcdef'
$ a
rank of arrays is #$

a =. 4 2 3 $ 'abcdef'
#$ a
#$ i. 2 3
#$ i.2
#$ 1
#$ ''
verb arguments

m =. i. 2 2
NB. add 2x2 matrices
m + 2 2 $ 10 11 12 13
NB. add numer to 2x2 matrix
10 + m
NB. add vector to each row
10 20 + m
NB. add vector to each col
10 20 + "1 m


adverbs

/ (insert)

approx reduce.
  +/ 1 2 3 is equivalent to 1 + 2 + 3.
+/ 1 2 3
a =. i. 3 4
a
+/ a
v/ (table)

addition table

a =. i.5
a +/ a
times table

a =. i.5
a */ a
+ table on booleans

0 1 +/ 0 1
times

0 1 */ 0 1
or

0 1 +./ 0 1
not-or

0 1 +:/ 0 1
and

0 1 *./ 0 1
not-and

0 1 *:/ 0 1
plot1

load 'plot'
plot 1 2 o. / 0.2 * i.60


box: monad <

basic

b =. < 2 3 4
b
append

b =. < 2 3 4
c =. < 4 7 9
d =. b , c
d
link: dyad ;

2 3 4 ; 4 7 9
'abc' ; 4 7 9
(2 3 $ 'abcdef') ; (i. 3 4) ; 23


Boxes the left agument always, but right only if it’s not already
  boxed:
'abc' ; 'defg' ; 'hijl'
'abc' ; ('defg' ; 'hijl')
'abc' ; < 'defg' ; 'hijl'


open: monad >

basic

Inverse of box. Applied to a noun that’s already open, has no effect.
a =. 1 2 3 ; 5 6 7
a
> a
results for different shape

Each atom is opened and the partial results are extended to fit into
  the result frame.
a =. 1 ; 2 3 ; 4 5 6
a
> a
results for characters of different shape

Gets extended with spaces
> 'abc' ; 'defg' ; 'hijkl'
results for mixed numbers and characters

> 1 2 3 ; 'asdf'
from: dyad {

basic

a =. 5 7 9 4 8
3 { a
0 { a
2 4 { a
2 0 4 { a
selects rows in tables

m =. i. 3 4
m
0 { m
2 1 { m
selects tables from rank 3 arrays

1 { i. 2 3 4
boxed indexes

If left argument of { is boxed, then it’s opened and
  each of its items gives the indexes along successive axes of the right
  argument.
m =. i. 3 4
m
(< 1 2) { m
when fewer indexes than axes

m =. i. 3 4
(<1) { m
rank 3 array example

d =. i.2 3 4
d
(< 1 2 3) { d
(< 1 2) { d


select rows 0 2 and columns 0 2 3 simultaneously

m =. i. 3 4
m
(< 0 2 ; 0 2 3) { m
] d =. i.2 3 4
(< 0 1 ; 0 2 ; 2 3) { d


select all rows and some columns

] m =. i. 3 4
(< 0 1 2 ; 2 3) { m
scattered indexing

When left argument isn’t a box, standard rules apply for { (it has
  left rank 0):
] m =. i. 3 4
(0 2 ; 2 3) { m
(0 0 ; 1 1 ; 2 2) { m
amend: adverb }

change list in one place

change_index_two =. 2}
15 change_index_two 5 6 7 8
15 (2}) 5 6 7 8
change list at multiple places

23 (1 4}) 7 7 7 7 7
23 24 (1 4}) 7 7 7 7 7
'pd' 1 3} 'ooooo'
more1

m =. i. 3 4
1 { m
23 23 23 23 (1}) m
more2

m =. i. 3 4
(2 4 $ 23 23 23 23 24 24 24 24) (1 2}) m
more3

m =. i. 3 4
12 ((< 1 2 ; 0 3)}) m
more4

m =. i. 3 4
(2 2 $ 23 24 25 26) ((< 1 2 ; 0 3)}) m
selecting without from

head: monad {.

{. 5 6 7
tail: monad {:

{: 5 6 7
behead: monad }.

}. 5 6 7
curtail: monad }:

}: 5 6 7
take: dyad {.

3 {. i.8
2 3 {. i.3 4
2 3 {. i.3 4
use take to extend array

5 {. 5 6 7
4 5 {. i. 2 3
drop: dyad }.

1 }. 2 3 4
1 2 }. i. 3 4
copy: dyad #

3 2 1 2 3 # 'abcde'
It’s equivalent to:
0 0 0 1 1 2 3 3 4 4 4 { 'abcde'
cut: conjunction ;.

2

means to use last element as splitter and include it
< ;. 2 'how now brown cow '
# ;. 2 'how now brown cow '
< ;. 2 (1 2 3 1 4 5 1)
# ;. 2 (1 2 3 1 4 5 1)


_2

means to use last element as splitter and not include it
< ;. _2 'how now brown cow '
# ;. _2 'how now brown cow '
< ;. _2 (1 2 3 1 4 5 1)
# ;. _2 (1 2 3 1 4 5 1)


more operations examples

a =. 2 3 4 _1 5 3 2 _1 23 45 65 132 _1
< ;. _2 a
# ;. _2 a
+/ ;. _2 a
1 or _1

< ;. 1 'madam i''m adam'
< ;. _1 'madam i''m adam'
splitter separately

1 0 0 0 1 0 0 < ;. 1 'abcdefg'
d =. 'the test is the thing'
'the' E. d
each

Apply op to boxed items
monad

a =. 10 12 13 ; 2 3 ; 4 5 6 8 3
a
+/ each a
,,*/ each a
|. each a                       NB. reverse each
>./ each a                      NB. max over each


dyad

a =. 10 12 13 ; 2 3 ; 4 5 6 8 3
23 , each a                     NB. append each
5 < each a                      NB. compare each to 5
1 |. each a


hook

A train is a sequence of two or three words in a row that is given a
  special meaning.
  A train of two words is a hook and is evaluated as follows:

  (f g) y evaluates as y f g y
  x (f g) y evaluates as x f g y

Divide all list elements by its max.
a =. 3 5 8 2 7
>./ a                           NB.max
a % (>./ a)                     NB.divide by max
(% >./)a                        NB.simplify
fork

A train of three verbs is a fork and is evaluated as follows:

  (f g h) y evaluates as (f y) g (h y)
  x (f g h) y evaluates as (x f y) g (x h y)

Average:
a =. 5 9 12
(+/ a) % (# a)
(+/ % #) a                      NB. same as above
mean =. +/ % #
mean i.999
bond: conjunction &

With a constant left argument returns a derived monad that is the verb
  on the right with constant left arg
add3 =: 3 & +
add3 i.3
tacit definition

examples

plus =. +
sumover =. +/
maxover =. >./
scale =. % >./
mean =. +/ % #
example convert to tacit

v0

fahrenheit =: 3 : 0
t1 =. y * 9
t2 =. t1 % 5
t3 =. t2 + 32
)
fahrenheit 100
fahrenheit 200
v1

fahrenheit in one line
fa =: 3 : '(y * 9 % 5) + 32'
fa 100
fa 200
v2

rearrange the terms
fa =: 3 : '32 + ((9 % 5) * y)'
fa 100
fa 200
v3

Create auxiliary verbs using bond &:
add32 =: 32 & +
ninefifthtimes =: (9 % 5) & *
add32 ninefifthtimes 100
add32 ninefifthtimes 200
v4

Use atop conjunction @ to compose add32 and ninefifthtimes:
add32 =: 32 & +
ninefifthtimes =: (9 % 5) & *
fc =: add32 @ ninefifthtimes
fc 100
fc 200
use fix to elide defining add32 and ninefifthtimes

add32 =: 32 & +
ninefifthtimes =: (9 % 5) & *
fc =: add32 @ ninefifthtimes
fc
fz =. fc f.
fz
atop: dyad @

(u @ v) y evaluates as u v y
fix: adverb f.

Like all adverbs, takes argument on the left.
  Takes a tacit definition and replaces names with their definitions.
inverse

fz =: 32&+@(1.8&*)
cz =: fz inverse
fz 100
cz 212
fz 0
cz 32
explicit-to-tacit translator

fx =: 3 : '32 + y * 9 % 5'      NB. 3 explicit
ft =: 13 : '32 + y * 9 % 5'     NB. 13 tacit
ft
files

write

writefile =: 1!:2

fn =. < '/tmp/test.txt'
'testing 1 2 3' writefile fn
read

readfile =: 1!:1
fn =. < '/tmp/test.txt'
data =: readfile fn
data
need to convert to string to write

writefile =: 1!:2
numtab =. i.4 5
cdata =. ": numtab
ddata =. cdata ,"1 LF
ddata
$ ddata
ldata =. , ddata
ldata
$ ldata
ldata writefile < '/tmp/test.txt'


linefeed: LF

'abc' , LF , 'def'
read the data back

rdata =. 1!:1 <'/tmp/test.txt'
dlf =. toJ rdata                NB.convert line breaks
bdata =. cutopen dlf
bdata
ndata =. 0 ". each bdata
ndata
> ndata


convert chars to numbers: dyad “.

0 ". '5 2 7'
1 + 0 ". '5 2 7'
left arg is value to use if conversion fails
0 ". '5 7.5 23.b 8'
wrap up in a function

writetable =: dyad : 0
d =. ": x
d =. d , "1 LF
d =. toHOST , d
d 1!:2 y
)
readtable =: 3 : 0
d =. 1!:1 y
d =. toJ d
d =. cutopen d
d =. 0 ". each d
d =. > d
)
shorter version

writetable =: 4 : '(toHOST,(": x),"1 LF) 1!:2 y'
(i.4 4) writetable < '/tmp/test.txt'
component files

A boxed list stored in a file
basic

load 'jfiles'
f =. '/home/oleh/data.jf'
jcreate f
'first component' jappend f
(1.5 + i.2 3) jappend f
('asdf' ; 23) jappend f
(< 'mum' ; 'dad') jappend f
jsize f
jread f ; 0
jread f ; 1
jread f ; 2
jread f ; 3
jread f ; 4


data processing

create data

load 'files'
fn =. '/tmp/text.txt'
data =. 'abc' , LF , 'bc' , LF , 'b' , LF
data fwrite fn
fread fn
JPhrases

conventions


  c conjunction
  n noun
  d dyad
  v ambivalent verb

change display

linear

9!:3 (5)
+/ % #
box, tree, and linear

9!:3 (2 4 5)
+/ % #
example 1

pss =: +/\
x =: }. i.7
x
pss x                           NB. partial sums
sss =: +/ \.
sss |. x
|. sss |. x
sss &. |. x
<\ x                            NB. Box prefix scan
<\. x                           NB. Box suffix scan


example 2

s =: sort =: /:~
numb =: 3 1 4 1 [ char =: 'cage'
poem =: 'i sing' , 'of olaf' ,: 'glad and big'
	(,.s numb) ; (,.s char) ; poem ; (s poem) ; s"1 poem
fixing definitions

n16 =: m =: 3 1 4 , 2 0 5 ,: 1 4 1
d17 =: ip =: +/ . *             NB. inner (matrix) product
m18 =: L =: m & ip
L
L x =: 1 2 5
h =: 'L' f.
h x
ip =: -/ . *
L x
h x
function tables

d0 =: +/                        NB. Addition table
d1 =: */                        NB. Multiplication table
d2 =: >./                       NB. Maximum table
d3 =: [ by ] over +/            NB. Bordered addition table
d4 =: by =: ' ' & ; @ ,. @ [ ,. ] NB. Format function
d5 =: over =: ({. ; }.) @ ": @ ,  NB. Format function
m6 =: +/ ~ @ i.                   NB. Addition table on first y integers
m7 =: bc =: !/~ @ i.              NB. Binomial coefficients of order y
a8 =: ft =: 1 : 'x/~ @ i.'        NB. Function table
a9 =: bft =: 1 : 'i. by i. over x/ ~ @ i.' NB. Bordered function table (explicity definition)
2 3 5 (d0 ; d1 ; d2) 0 1 2 3 4 5
Bond or Curry

m0 =: 1 & +                     NB. increment >:
m1 =: + & 1                     NB. "
m2 =: _1 & +                    NB. decrement <:
m3 =: - & 1                     NB. "
m4 =: 1 & -                     NB. Not -. (logical and probability complement)
m5 =: 1 & ~:                    NB. "
m6 =: 0 & =                     NB. "
m7 =: 0 & -                     NB. Negate - (arithmetic)
m8 =: _1 & *                    NB. "
m9 =: * & _1                    NB. "
m10 =: 2 & *                    NB. Double +:
m11 =: * & 2                    NB. "
m12 =: 3 & *                    NB. Triple
m13 =: * & 3                    NB. "
m14 =: 0j1 & *                  NB. j. (Multiply by sqrt(-1))
m15 =: ^ @ j.                   NB. r. (Complex # on unit circle at y radians)
m16 =: 1p1 & *                  NB. pi times
m17 =: 0.5 & *                  NB. Halve -:
m18 =: * & 0.5                  NB. "
m19 =: % & 2                    NB. "
m20 =: 1 & %                    NB. Reciprocal %
m21 =: ^& _1                    NB. "
m22 =: ^& 2                     NB. Square *:
m23 =: ^& 3                     NB. Cube
m24 =: ^& 0.5                   NB. Square root %:
m25 =: ^& 1r2                   NB. "
m26 =: 2 & %:                   NB. "
m27 =: ^& (% 3)                 NB. Cube root
m28 =: ^& 1r3                   NB. "
m29 =: 3 & %:                   NB. "
m30 =: (^1) & ^                 NB. Exponential ^
m31 =: 1x1 & ^                  NB. "
m32 =: 1x1 & ^.                 NB. Natural log ^.
m33 =: 10 & ^                   NB. power 10
m34 =: 10 & ^.                  NB. Base-10 log
NB. (1+ (floor (log10 (max 1 (ceil x)))))
m35 =: >: @ <. @ (10 & ^.)@(1 & >.) NB. # of digits needed to represent integer y
m36 =: # @ (10 & #. ^: _1)"0    NB. "
Learning J

|

monad: Magnitude

| 6 _6 3j4
dyad: Residue

3 | 0 1 2 3 4 5 6 7
#

monad: Tally

# 3 4 5
dyad: Copy

y =: 6 7 8 9 10
1 1 0 1 0 # y
(y > 7) # y
>.

monad: Ceiling

>. _1.7 1 1.7
dyad: Max

3 >. 1 3 5
>./ 1 6 5
>:

monad: Icrement

>: _2 3 5 6.3
dyad: Larger or Equal

3 >: 1 3 5
i.

monad: Integers

i.5
dyad: Index Of

'abra' i. 'r'
conditional and other forms

halve =: -:
mult =: 1: + (* 3:)
odd =: 2 & |
halve 6
mult 6
odd 6
collatz =: halve ` mult @. odd
collatz 17
bank interest example


  If the balance is $100 or more, the bank pays interest of 0.5%
  If the balance is negative, the bank charges interest at 2%.
  Otherwise the balance is unchanged.

pi =: * & 1.005                 NB. pay interest
ci =: * & 1.02                  NB. charge interest
uc =: * & 1                     NB. unchanged
case =: (>: & 0) + (>: & 100)
case _50 0 1 100 200
PB =: ci ` uc ` pi @. case
PB _50
PB 0
PB 1
PB 100
PB 200
PB _50 0 1 100 200
(PB"0) _50 0 1 100 200


Recursion

define +/ as recursive function

empty =: # = 0:
first =: {.
rest =: }.
Sum =: (first + Sum @ rest) ` 0: @. empty
Sum 1 1 2
Ackermann’s function

Ack =: 4 : 0
if. x = 0     do. y + 1
elseif. y = 0 do. (x - 1) Ack 1
elseif. 1     do. (x - 1) Ack (x Ack y - 1)
end.
)
2 Ack 3
3 Ack 3
tacit Ackermann’s function

ack =: c1 ` c1 ` c2 ` c3 @. (#. @ (,&*))
c1 =: >: @ ]                    NB. 1+y
c2 =: <: @ [ ack 1:             NB. (x-1) ack 1
c3 =: <: @ [ ack [ ack <: @ ]   NB. (x-1) ack x ack y
2 ack 3
3 ack 3
^: Power

Verb applied multiple times over.
(+: ^: 3) 1
With arg _ find the fixed point
p =: 3 : '2.8 * y * (1 - y)'
(p ^: 0 1 2 3 19 20 _) 0.5
(f ^: g) y  means  f ^: (g y) y
(+: ^: %:) 16
iterating while

halve =: -:
even =: 0: = 2 & |              NB. returns 0 or 1
foo =: halve ^: even            NB. halve 0 or 1 times
(foo"0) i.10
w =: (halve ^: even) ^: _       NB. keep halving while even
w 48
equivalence with while.

The following are equivalent:
f =: -:
g =: 0: = 2 & |
w1 =: f ^: g ^: _
w2 =: 3 : 0
  while. (g y)
  do. y =. f y
  end.
  y
)
w1 48
w2 48
iterating a dyadic verb

x (u ^: w) y
  means
  ((x & u) ^: w) y
((3 & +) ^: 2) 0
3 (+ ^: 2) 0
generating tacit verbs from explicit

monad

e =: 3 : '(+/ y) % #y'
t =: 13 : '(+/ y) % #y'
e
t
e 1 2 3
t 1 2 3
dyad

ed =: 4 : 'y % x'
td =: 13 : 'y % x'
ed
td
(2 ed 6),(2 td 6)
“13 : body” evaluates body, but “3 : body” doesn’t

k =: 99
p =: 3 : 'y + k'
q =: 13 : 'y + k'
p
q
(p 6) ; q 6
k =: 0
(p 6) ; q 6


C =: @: 
g =: %: 
foo =: 13 : '(f C f y) , g y'
foo
f =: *:
foo 4
more on tacit

ex1

scale =: * & (5 % 4) 
scale 
scale 8
SCALE =: * & 5 % 4
SCALE
Second one is (* & 5) applied to (% 4). It’s explained by conjunctions
  having short right scope.
ex2

z =: 3 & + @: *: 
z 2
Adverbs and conjunctions have long left scope.
  That means that the left argument of @: is the entire 3 & +
names of nouns are evaluated

a =: 5
b =: 4
f =: * & (a % b) 
f
names of verbs are not evaluated

a =: 5
b =: 4
w =: * 
g =: w & (a % b) 
g
unknowns are verbs

When a new name is encountered, it is assumed to be a
  yet-to-be-defined verb.
h =: ytbd & (5 % 4) 
ytbd =: * 
h 8
A sequence of hitherto-unknown names is assumed to be a train of
  verbs:
ctof =: shift @ scale
shift =: + & 32
scale =: * & (9 % 5)
ctof
ctof 0 100
scale =: * & 2
ctof 0 100
how to protect agaist dynamic scope

method 1: wrap with explicit definition

CTOF =: 3 : 0
shift =. + & 32
scale =. * & (9 % 5)
shift @ scale y
)
CTOF 100
method 2: fix

ctof =: shift @ scale
shift =: + & 32
scale =: * & (9 % 5)
ctof
ctof f.
parametric functions

y =: lambda * x * (1 - x)
P =: 3 : 'lambda * y * (1 - y)'
x =: 0.6
lambda =: 3.0
P x
lambda =: 3.5
P x
tP =: 13 : 'lambda * y * (1 - y)'
tP
erase <'lambda'
tP =: 13 : 'lambda * y * (1 - y)'
tP
lambda =: 3.5
tP x


fix 1

Compromise “fully tacit”
tP =: (3 : 'lambda') * ] * (1: - ]) 
lambda =: 3.5
tP 0.6
fix 2

Compromise “exact equivalent”
lambda =: 3.5 " 0
tP =: lambda * ] * (1: - ]) 
tP 0.6
lambda =: 3.75 " 0
tP 0.6
Explicit Verbs

General Form

type : body
type

3

monadic or ambivalent verbs
4

strictly dyads
13

with expansion/freeze
type mnemonics


  noun 0
  adverb 1
  conjunction 2
  verb 3
  monad 3
  dyad 4
  def :
  define : 0

body

0

multiline definition, finish with )
PosDiff =: 4 : 0
larger =. x >. y
smaller =: x <. y
larger - smaller
)
3 PosDiff 4
embed LF

PosDiff =: 4 : ('la =. x >. y' , LF , 'sm =. x <. y' , LF , 'la - sm')
PosDiff
3 PosDiff 4
boxed list of lines

PosDiff =: 4 : ('la =. x >. y' ; 'sm =. x <. y' ; 'la - sm') 
PosDiff
3 PosDiff 4
Ambivalent Verbs

Has both monadic and dyadic case.
  Monadic case is written first, then a line of a solo colon,
  then dyadic case.
log =: 3 : 0
^. y
:
x ^. y
)
log 2.71
10 log 100
ex1: positive difference

PosDiff =: 4 : '(x >. y) - (x <. y)'
3 PosDiff 4
4 PosDiff 3
ex2: positive difference with mnemonics

PosDiff =: dyad def '(x >. y) - (x <. y)'
3 PosDiff 4
Destructuring

1

'day mo yr' =: 16 10 95
day , mo , yr
2

('day' ; 'mo' ; 'yr') =: 17 11 96
day , mo , yr 
N =: 'day' ; 'mo' ; 'yr'
(N) =: 18 12 97
day , mo , yr
ex1: roots of quadratic poly

rq =: 3 : 0
'a b c' =. y
((- b) (+ , -) %: (b ^ 2) - 4 * a * c) % (2 * a) 
)
rq 1 1 _6
rq 1 ; 1 ; _6
control structures

ex1

sum =: 3 : 0
if.
  length =. # y                 NB. T block
  length = 0                    NB. T block
do.
  0                             NB. B1 block
else.
  first =. {. y                 NB. B2 block
  rest =. }. y                  NB. B2 block
  first + sum rest              NB. B2 block
end.
)
ex2

ClaTePo =: 3 : 0
if. y > 80 do. 'too hot'
else.
	if. y < 60 do.  'too cold'
        else.           'just right'
	end.
end.
)
ClaTePo 70
select

branched if

class =: 3 : 0
t =. 4 !: 0 < y
if.     t = 0 do. 'noun'
elseif. t = 1 do. 'adverb'
elseif. t = 2 do. 'conjunction'
elseif. t = 3 do. 'verb'
elseif. 1     do. 'bad name'
end.
)
class 'class'
class 'oops'
equivalent select

class =: 3 : 0
select. 4 !: 0 < y
case. 0 do. 'noun'
case. 1 do. 'adverb'
case. 2 do. 'conjunction'
case. 3 do. 'verb'
case.   do. 'bad name'
end.
)
class 'class'
class 'oops'
select allows boxed list in case.

class =: 3 : 0
select. 4 !: 0 < y
case. 0     do. 'noun'
case. 1 ; 2 do. 'operator'
case. 3     do. 'verb'
case.       do. 'bad name'
end.
)
o =: @:
class 'o'
class 'oops'
while.

fact =: 3 : 0
r =. 1
while. y > 1
do. r =. r * y
    y =. y - 1	
end.
r
)
fact 5
whilst.

whilst. T do. B end.
means
B
  while. T do. B end.
for.

for_a. A do. B end.
means
for each item a in array A, execute block B.
Sum =: 3 : 0
r =. 0
for_term. y do. r =. r + term end.
r
)
Sum 1 2 3
a_index is also available similar to Python’s enumerate
f3 =. 3 : 0
r =. 0 2 $ 0
for_item. y do. r =. r , (item_index ; item) end.
r
)
f3 'ab' ; 'cdef' ; 'gh' 
Explicit Operators

operators generating tacit verbs

ex 1

Suppose we want an adverb A s.t.
  u A   means   u ” 0
A =: 1 : 'u"0'
f =: < A
f 1 2
ex 2

W =: 1 : '<"u'
0 W
z =: 'abc' 
0 W z
1 W z
ex 3

y =: 1 0 2 3
1 0 1 1 # y                     NB. dyad Copy
> & 0 y                         NB. select items greater than 0
(> & 0 y) # y
f =: > & 0 # ]                  NB. fork to select items >0
f y
B =: 1 : 'u # ]' 
g =: >&0 B
g 1 0 _2 3
ex 4

u THEN v is to be v @: u
THEN =: 2 : 'v @: u' 
h =: *: THEN <
h
h 1 2 3
ex 5

Count items greater than 0
foo =: # @: (> & 0 # ]) 
foo 5 0 _7 3
Generalize to a conjunction
  u C v is to be u @: (v # ])
C =: 2 : 'u @: (v # ])' 
f =: # C (> & 0) 
f 5 0 _7 3
ex 6

Previous conjunction as multiline
D =: 2 : 0
select =: v # ] 
u @: select
)
f =: # D (> & 0) 
f
f 5 0 _7 3
fix dependence on select with f.

E =: 2 : 0
select =. v # ] 
(u @: select)f.
)
E
g =: # E (> & 0) 
g
y =: 1 0 2 3
g y
Note that g unlike doesn’t have local names.
new definitions from old

smooth appending 0

Write a function that replaces each number on the list
  by the mean of its two neighbors, assuming 0 neighbor for first and
  last.
sh    =: |. !. 0                 NB. shift, entering zero
prev  =: _1 & sh                 NB. right shift
next  =: 1 & sh                  NB. left shift
halve =: -: 
smoo  =: halve @: (prev + next)
N =: 6 2 8 2 4
N
prev N
next N
smoo N
smooth circular

To have circular smoothing, we need sh to become |. (rotate).
SMOO =: 1 : ('sh =. u' ; 'smoo f.')  
rv =: |. SMOO
rv
smoo N
rv N 
operators generating explicit verbs

Suppose we want a conjunction u H v equivalent to
3 : 0
z =. v y
y u z
)
messy way

H =: 2 : 0
U =. 5!:5 < 'u'
V =. 5!:5 < 'v'
string =. 'z =. ', V , 'y', LF
string =. string , 'y ', U , ' z', LF
3 : string
)
foo =: + H *:
foo
foo 5
This is similar to
(defun H (u v)
  (read (format "(lambda(x) (%s x (%s x)))"
                u v)))
(setq foo (H "(lambda(x y)(+ x y))"
             "(lambda(x)(* x x))"))
(funcall foo 5)
neat way

K =: 2 : 0
z =. v y
y u z
)

bar =: + K *: 
bar
bar 5
This is similar to
(defun H (u v)
  `(lambda(x)
    (funcall ,u x (funcall ,v x))))

(setq foo (H (lambda(x y)(+ x y))
             (lambda(x)(* x x))))
(funcall foo 5)
adverb generating monad

Consider a monadic verb selecting items greater than 0:
e =: 3 : '(> & 0 y) # y'
y =: 1 0 2 3
e y
Generalize to form an adverb which selects items according to a
  supplied test-verb, i.e. a filter:
F =: 1 : '(u y) # y'
>&1 F y
<&2 F y
adverb generating explicit dyad

ex 1

Suppose u W is to be =4 : ‘(u x) + (u y)’=
W =: 1 : 0
:
(u x) + (u y) 
)
(*: 2) + (*: 16)
2 (*: W) 16
ex 2

Suppose u T is to be =4 : ‘x (u”0 0) ” 0 1 y’,
  i.e. a self-made / (table).
T =: 1 : 0
:
x ((u"0 0)"0 1) y
)
1 2 3 + T 4 5 6 7
conjunction generating explicit monad

G =: 2 : 0
selected =. (v y) # y
u selected
)
y
# G (> & 0) y
conjunction generating explicit dyad

H =: 2 : 0
:
(u x) + (v y) 
)
(*: 2) + (%: 16) 
2 (*: H %:) 16
alternative names for argument variables

Arguments to operators can be named m and n instead of u and v
  to constrain arguments to be nouns.
executing the body (or not)

operator of first kind

display =: (1 !: 2) & 2
R =: 2 : 0
display 'hello'
select =. v # ] 
(u @: select) f.
)
f =: # R (> & 0)
f 1 0 2 0 3
operator of second kind

S =: 2 : 0
display 'hello'
selected =. (v y) # y
u selected
)
g =: # S (> & 0)
g 1 0 2 0 3
operators generating nouns

f =: 3 : '2.8 * y * (1 - y)' 
FFF =: 1 : '(u ^: _) 0.5'
p =: f FFF
p
where =: 2 : 'u'
mean =: sum % # where sum =: +/ 
mean 1 2 3 4 
(z + 1) * (z - 1) where z =: 7
operators generating operators

CS =: @: *: 
- CS
- CS 2 3
- *: 2 3
Suppose we need u K is to be @: u
K =: 1 : '@: u' 
L =: *: K
- L
- L 2 3
Gerunds

Gerund represents a list of verbs.
  It’s useful mainly for supplying a list of verbs as a single argument
  to an operator.
making gerunds

abs =: + ` - @. (< & 0) 
abs
abs _3
G =: + ` - ` abs
G
recovering verbs from gerund

Verbs packed into a gerund can be unpacked again with the built-in
  adverb “Evoke Gerund” denoted by (`: 6).
EV =: `: 6
f =: 'f' & , 
g =: 'g' & , 
H =: f ` , ` g
foo =: H EV
foo
foo 'o'
Individual verbs can be unpacked by indexing the boxed list H and
  the applying EV.
H
2 { H
vb =: (2 { H) EV
vb
vb 'o'
H
1 2 { H
tr =: (1 2 { H) EV
tr 'a'
gerunds as arguments to built-in operators

as argument to APPEND adverb

APPEND =: `: 0
sum =: +/ 
count =: # 
mean =: sum % count
G1 =: count ` sum ` mean
G1
foo =: G1 APPEND
foo
foo 1 2 3
(u`v`w...) APPEND y means (u y),(v y),(w y),...
G2 =: 2 2 $ G1
G2
G2 APPEND 4 5
as argument to AGENDA conjunction

abs =: + ` - @. (< & 0)
abs 6
abs _6
Here, @. takes a verb on the right.
  It can also take a noun on the right.
G =: + ` - ` % 
f =: G @. 0
f
1 f 1
G
h =: G @. 0 2
h
h 4
G
EV =: `: 6
(G @. 0 2) 4
((0 2 { G)) EV 4
T =: * (- 1:)
T 3
T 4
foo =: (* ` - ` 1:) @. (0 ; 1 2)
T
foo
foo 3
as argument to INSERT

If G is f`g`h
  and X is x0,1,x2,x3
  then G/X is x0 f x1 g x2 h x3
ger =: + ` % 
ger/ 1 2 3
1 + 2 % 3
If the gerund is too short, it’s re-used cyclically.
  This means that a one-verb gerund is equivalent to a single inserted
  verb.
as argument to POWER conjunction

Recall power conjunction:
double =: +: 
(double ^: 3) 1
As a variation, the number of iterations ca be computed by a verb
  right-argument. The scheme is, for verbs u and v:
  (u ^: v) y means u ^: (v y) y
decr =: <: 
double ^: (decr 3) 3
(double ^: decr) 3
More generally, the right argument can be given as a gerund, and the
  verbs in it do some computations at the outset of the iteration
  process.
  u ^: (v1 ` v2) y means u ^: (v1 y) (v2 y)
Verb to compute a Fibonacci sequence:
u =: , sumlast2
sumlast2 =: +/ @ last2
last2 =: _2 & {. 
as argument to AMEND

recall } (amend)

'o' 1 } 'baron'
general version

Takes a gerund of three verbs:
  x (U`V`W) } y means (x U y) (x V y) } (x W y)
  That is the new items, the indexes and the “old” array are all to be
  computed from given x and y.
ex 1

Define a verb R to amend a matrix by multiplying its i‘th row by
  a constant k. The left argument of R is to be the list i k and
  the right argument is to be the original matrix.
  R is defined as the amend adverb applied to a gerund of 3 verbs.
i =: {. @ [                     NB. x i y is first of x
k =: {: @ [                     NB. x k y is last of x
r =: i { ]                      NB. x r y is (x i y)'th row of y
R =: ((k * r) ` i ` ]) } 
For example:
M =: 3 2 $ 2 3 4 5 6 7
z =: 1 10                       NB. row 1 times 10
M
(z i M) ; (z k M) ; (z r M)
z R M
(40 50) 1 } M


as argument to user-defined operators

ex1

Define adverb A to produce a fork-like verb:
  x (f ` g ` h A) y is to be (f x) g (h y)
A =: 1 : 0
f =. u @. 0
g =. u @. 1
h =. u @. 2
((f @ [) g (h @ ])) f.
)
To demonstrate A, here is a verb to join the first item of x to
  the last of y.
H =: {. ` , ` {:
zip =: H A
zip
'abc' zip 'xyz'
'abc' ({. @ [ , {: @ ]) 'xyz'
ex2: Abelson and Sussman accumulator

A combination of filter, map and reduce.
ACC =: 1 : 0
com =. u @. 0
map =. u @. 1
fil =. u @. 2
((com/) @: map @: (#~ fil)) f.
)
For example, to compute the sum of squares of odd numbers in a given
  list:
+/ *: ((2 & |) # ]) 1 2 3 4
(+ ` *: ` (2 & |)) ACC 1 2 3 4
Tacit Operators

adverbs from conjunctions

recall ” (rank)

<"0 'abc'
A conjunction takes two arguments. If we supply only one, the result
  is an adverb.
  For example, an adverb to apply a given verb to each scalar
  is ("0).
each =: " 0
< each
z =: < each 'abc'
z
The scheme is that for conjunction C and noun N,
  (C N) denotes an adverb such that
  x (C N) means x C N.
  Argument to be supplied the the conjunction can be  a noun or a verb,
  on the left or on the right.
  Note that this is similar to the bond &, except & isn’t necessary
  because conjunctions don’t have a monadic case.
recall &. (under)

f =: 'f' & , 
g =: > 
z =: 'a' ; 'b' ; 'c'
z
(f &. g) z
Define EACH adverb to mean “inside each box”:
EACH =: &. > 
f EACH
z
f EACH z
compositions of adverbs

For adverbs A and B, the bident (A B) denotes an adverb:
  x (A B) means (x A) B
ex1: cumulative sums and products

cum =: /\ 
z =: 2 3 4
+ cum z
* cum z
ex2: generating trains

A =: * `                        NB. verb conjunction
B =: `: 6                       NB. conjunction noun
H =: A B                        NB. compound adverb - a hook maker
<: A
<: A B
h =: <: H
h
h 5
ex3: rewriting

It’s possible to rewrite the definition of a verb to an equivalent
  form by rearraning its terms.
  Suppose we start with a definition of the factorial function
f =: (* ($: @: <:)) ` 1: @. (= 0:) 
f 5
The idea now is to rewrite f to the form $: adverb by a sequence
  of steps.
step 1

A1 =: @. (= 0:) 
g =: (* ($: @: <:)) ` 1: A1
f =: (* ($: @: <:)) ` 1: @. (= 0:) 
g 5
f 5
step 2

A2 =: ` 1:
h =: (* ($: @: <:)) A2 A1
h 5
step 3

A3 =: (* `) (`: 6) 
h =: (* ($: @: <:)) A2 A1
i =: ($: @: <:) A3 A2 A1
i 5
step 4

A4 =: @: <: 
j =: $: A4 A3 A2 A1
j 5
step 5

A =: A4 A3 A2 A1
k =: $: A
k 5
m =: $: (@: <:) (* `) (`: 6) (` 1:) (@. (= 0:))
m 5
f 
m
Rearrangements

Permutations

ex1

y =: 'abcde' 
4 2 3 1 0 { y
p =: 4 2 3 1 0 & { 
y
p y
p p y
p p p p p p y
p ^: 6 y
The permutation (4 2 3 1 0) can be represented as a cyle of 2 and a
  cycle of 3
C. 4 2 3 1 0
C. 3 1 2 ; 4 0
First representation is called direct, second is called cyclic.
ex2: predefined collating sequences

Upper-case letters come before lower-case letters.
65 66 67 97 98 99 { a.
Complex numbers are ordered by the real part then the imaginary part.
n =: 0 1 _1 2j1 1j2 1j1
n /: n
With boxed arrays, the ordering is by the contents of each box.
The precedence is
first by type

numerical < empty < chars < boxed
[k =: (< 'abc') ; 'pqr' ; 4 ; '' ; 3
k /: k


second by rank

low rank < high rank
[m =: 2 4 ; 3 ; (1 1 $ 1)
(# @ $ @ >) m
m /: m
finally element by element

If they have the same rank, compare elementwise:
  1 2 < 1 3,
  3 3 < 3 3 3
a =: 2 3 $ 1 2 3 4 5 6
b =: 3 2 $ 1 2 5 6 3 4
c =: 1 3 $ 1 2 3
[u =: a ; b ; c
u /: u


ex3: user-defined collating sequences

Suppose we want to sort by abs.
x =: 2 1 _3
keys =: | x
x /: keys
Transpositions

The monadic verb |: will transpose a matrix, that is interchange the
  first and second axes.
Shifting

The items which would be brought around by cyclic rotation can instead
  be replaced with a fill-term.
A shifting verb is written (|. !. f) where f is the fill-item.
ash =: |. !. '*'                NB. alphabetic shift
nsh =: |. !. 0                  NB. numeric shift
y =: 'abcde'
y ; (_2 ash y) ; (1 ash y)
z =: 2 3 4
z ; (_1 nsh z) ; (2 nsh z)
Patterns of Application

Scanning

Prefix Scanning

<\ 'abcde'
+/\ 0 1 2 3
+./\ 0 1 0 1 0
Infix Scanning

In the expression x f \ y the verb f is applied to successive
  sections (“infixes”) of y, each of length x.
z =: 1 4 9 16
2 <\ z
3 <\ z
If x is negative, then the sections are non-overlapping, in which
  case the last section may not be full-length.
z =: 1 4 9 16
_3 <\ z
_2 <\ i.10
We can compute the differences between successive items, by choosing 2
  for the section-length, and applying to each section a verb
  “second-minus-first”, that is, ({: - {.)
smf =: {: - {. 
smf 1 4
diff =: 2 & (smf\)
z =: 1 4 9 16
,. diff z
Suffix Scanning

(f \. y) applies f to successively shorter suffixes of y:
<\. 'abcde'
Outfix

(x f \. y) applies f to the whole of y with
  successive sections removed, each being of length x.
  If x is negative, then the removed sections are non-overlapping.
y =: 'abcde' 
2 <\. y
_2 <\. y
How to enter tables of numbers

Start with
T =: 0 : 0
1   2  3
4   5  6
19 20 21
)
$ T
+/ T = LF
T is a character-string with 3 embedded line-feed chars.
  Now cut T into lines. Then eval them with “.
[ TBL =: (". ;. _2) T
*: TBL
Punctuation

frets =: ' ? !.' 
t =: 'How are you?'
[ b =: t e. frets
Now the bitvector b can be used to specify the frets for cutting
  text t into words:
b < ;. _2 t
Consider cutting a numeric vector into intervals such that each is in
  ascending sequence.
Compute a bitvector by scanning infixes of length 2, applying >/
  to each pair of items. Where we get 1, the second item of the pair is
  the beginning of a new interval. We make sure the first item of all is 1.
data =: 3 1 4 1 5 9
2 ]\ data
2 >/\ data
] bv =: 1 , 2 >/\ data
data ,: bv
bv < ;. 1 data
Lines in Files

First, create an example file.
text =: 0 : 0
What can be said
at all
can be said
clearly.
)
text (1 !: 2) < 'foo.txt'
Now read into a string and cut it:
string =: (1 !: 1) < 'foo.txt'
] lines =: (< ;. _2) string
Note that we rely here on LF for cutting.
  Windows has CRLF instead of LF.
  J follows the convention of the single LF regardless of the system.
  However CR have to be taken care of.
  Here’s how to strip it:
string =: (string ~: CR) # string
Secondly, depending on how the file of text was produced,
  we may not be able to guarantee that the last line is actually
  terminated.
tidy =: 3 : 0
y =. y , (LF ~: {: y) # LF      NB. append LF if not already there
(y ~: CR) # y                   NB. remove CR
)
(< ;. _2) tidy (1 !: 1) < 'foo.txt'
Tiling

x u ;. 3 y applies u separately to each of a collection
  of subarrays extracted from y.
  These subarrays may be called tiles.
  The size and arrangement of the tiles are defined by x.
y =: 4 4 $ 'abcdefghijklmnop'
spec =: > 2 2 ; 2 2             NB. offset, shape
spec < ;. 3 y
Tiling may leave incomplete pieces(“shards”) at the edges.
  They’re included or excluded with 3 or _3.
sp =: > 3 3 ; 3 3
sp < ;. 3 y
sp < ;. _3 y


Sets, Classes and Relations

Set Equal

seteq =: *./ @: (e. , e.~) 
1 2 3 seteq 3 1 2 1
1 2 3 seteq 1 2
Classes

Self-Classify

Consider finding frequency-distribution of letters.
y =: 'hook' 
~. y
(~. y) =/ y
= y
If we sum each row we obtain the counts, in the order of the letters
  in the nub.
y =: 'hook' 
= y
+/"1 = y
The counts can be paired with the letters of the nub:
y =: 'hook' 
~. y
(~. y) ;"0 (+/"1 = y)
Classification Schemes

Classify soil-type as acid, neutral or alkaline depending on pH.
classify =: ({ & 'ANL') @: ((>: & 6) + (> & 7))
classify 6
classify 4.8 5.1 6 7 7.1 8
The Key Adverb

data =: 7 5 6 4 8
] k =: classify data
k = 'A'
(k = 'A') # data
Now suppose we wish to count the items in each class.
data
[ k =: classify data
k #/. data
k </. data
The verb we apply can discover for itself the class of each separate
  argument, by classifying the first member:
u =: (classify @: {.) ; # 
data
] k =: classify data
k u/. data


The general scheme for the “Key” is:
  in x u/. y take y to be a list, and x a list of keys,
  and u a verb to be applied separately to each class.
] y =: 4 5 6 7 8
] x =: classify y
u =: < 
= x
(=  x) (u @ #) y
x u/. y


More letter counting

y =: 'LETTUCE'
= y
(~. y) ;"0 +/"1 (= y)


u =: {. ; # 
y u/. y


Relations

Suppose there are a number of publications, such as:

  “Pigs” by Smith, on the subject of pigs
  “Pets” by Brown, on cats and dogs
  “Dogs” by Smith and James, on dogs

and we aim to catalog such publications.
  We can use two tables called relations.
first representation: tables of boxed strings

The authors-titles relation is:
] AT =: (". ;. _2) 0 : 0
'Smith' ; 'Pigs'
'Brown' ; 'Pets'
'Smith' ; 'Dogs'
'James' ; 'Dogs'
)
And the titles-subjects relation is:
] TS =: (". ;. _2) 0 : 0
'Pigs' ; 'pigs'
'Pets' ; 'cats' 
'Pets' ; 'dogs' 
'Dogs' ; 'dogs' 
)
A method is as follows. Consider all possible pairs consisting of a
  row at from table AT and a row ts from table TS.
  Each pair at,ts is of the form:
  author ; title ; title ; subject
  If title matches, i.e. item 1 matches item 2, then we extract author
  and subject, i.e. items 0 and 3.
test =: 1 & { = 2 & {
extr =: 0 3 & { 
These verbs can be plugged into a suitable conjunction to do the
  pairing.
  It writing this conjunction, we aim to avoid requiring the whole set
  of possible pairs to be present at the same time, since this set may
  be large. We also aim to avoid any duplicates in the result.
  Here is a first attempt.
PAIR =: 2 : 0
: 
z =. 0 0 $ '' 
for_at. x do. 
   for_ts. y do.
     if. u at , ts do. z =. z , v at , ts end. 
   end.
end.
~. z
)
join =: test PAIR extr
AT join TS


The join verb as defined above is slow, because the test and
  extr verbs are applied to a single x,y pair at a time - they are
  scalar computations. Performance will be better if we can give these
  verbs as much data as possible to work on at one time.
Here is a revised vector-oriented version of PAIR and join,
  which still avoids building the entire set of pairs.
VPAIR =: 2 : 0
: 
z =. 0 0 $ '' 
for_at. x do.
  z =. z , |: v (#~"1 u) |: at ,"1 y
end.
~. z
)
vjoin =: test VPAIR extr
AT vjoin TS


What are Symbols?

Symbols are for efficient computation with string data.
  They’re a distinct data-type, in the same way as characters,
  boxes and numbers.
  A symbol is a scalar which refers to a string.
  A symbol can be created by applying s: to a boxed string.
] a =: s: < 'hello'
Although it looks like the original string with ` prepended,
  it’s a scalar:
# $ a
The original string is stored in a data-structure, maintained
  automatically by the J system, called the symbol-table.
  Strings aren’t duplicated so if there’s two references to the same
  string, they’re equal.
b =: s: < 'hello'
b = a
Note that this is a scalar comparison and not a string comparison.
sAT =: s: AT
sTS =: s: TS
sAT vjoin sTS
Symbols are lexicographically ordered to reflect the ordering of the
  original strings. Hence tables of symbols can be sorted:
sAT
/:~ sAT
Measurements Compared

A utility verb giving time in seconds to evaluate an expression,
  averaged over 4 executions:
time =: (8j5 & ":) @: (4 & (6 !: 2))
AT =: 100 $ AT
TS =: 100 $ TS
sAT =: 100 $ sAT
sTS =: 100 $ sTS
t1 =: time 'AT join TS'         NB. scalar method, boxed strings
t2 =: time 'sAT join sTS'       NB. scalar method, symbols
t3 =: time 'AT vjoin TS'        NB. vector method, boxed strings
t4 =: time 'sAT vjoin sTS'      NB. vector method, symbols
3 3 $ ' ' ; 'strings' ; 'symbols' ; 'scalar' ; t1 ; t2 ; 'vector' ; t3 ; t4
Saving and Restoring the Symbol Table

Suppose that data is an array of symbols.
] data =: s: 2 2 $ 'hello' ; 'blah' ; 'blah' ; 'goodbye' 
i.2 3 4
s: 2 2 $ 'fooommmmm' ; 'blurg' ; 'blah' ; 'bar' 
s: 2 2 $ 'blah' ; 'bar' ; 'fooommmmm' ; 'blurg'


pdfs

sudoku

i =: ,((,|:)i.9 9),,./,./i.4$3
c =: (#=[:#~.)@-.&0
t =: [:(([:*/_9:c\])"1#])i&{+"1 1(>:i.9)*/[:i&=i.&0
r =: [:,`$:@.(0:e.,)[:;(<@t)"1
s =: 9 9&$@r@,
]m =: 9 9 $"."0'200370009009200007001004002050000800008000900006000040900100500800007600400089001'
s m
2 0 0 3 7 0 0 0 9
0 0 9 2 0 0 0 0 7
0 0 1 0 0 4 0 0 2
0 5 0 0 0 0 8 0 0
0 0 8 0 0 0 9 0 0
0 0 6 0 0 0 0 4 0
9 0 0 1 0 0 5 0 0
8 0 0 0 0 7 6 0 0
4 0 0 0 8 9 0 0 1

2 8 4 3 7 5 1 6 9
6 3 9 2 1 8 4 5 7
5 7 1 9 6 4 3 8 2
1 5 2 4 9 6 8 7 3
3 4 8 7 5 2 9 1 6
7 9 6 8 3 1 2 4 5
9 6 7 1 4 3 5 2 8
8 1 3 5 2 7 6 9 4
4 2 5 6 8 9 7 3 1

factorial

i.20
1 + i.20
*/ 1 + i.20
(f g h) y	evaluates as	(f y) g (h y)
x (f g h) y	evaluates as	(x f y) g (x h y)