Arrays

Elementwise math on an array

Every 1-argument math builtin maps elementwise over an array. No loop.

x = linspace(0.0, 3.14159265, 5)
y = sin(x)
show y

Broadcasting an array and a scalar

+, -, *, / broadcast between arrays and scalars, in either order.

x = linspace(0.0, 2.0, 3)
show 2.0 * x + 1.0
show 1.0 - x
show x / 2.0

Resetting an array in place with fill

fill(a, v) sets every element. Rebinding (a = zeros(n)) makes a new array, and a caller that passed a in never sees the change; fill changes the array in place.

a = zeros(3)
a[0] = 7.0
fill(a, 0.0)
show a
fill(a, 1.5)
show a

Literals and indexing

Comma-separated subscripts, zero-based.

v = [10.0, 20.0, 30.0]
M = [[1.0, 2.0], [3.0, 4.0]]
show v[1]
show M[1, 0]

zeros and indexed stores

zeros allocates rank 1 through 4.

Z = zeros(2, 2)
Z[0, 1] = 7.0
show Z

Elementwise arithmetic

* between arrays is elementwise (the Hadamard product); array times scalar scales.

a = [1.0, 2.0]
b = [10.0, 20.0]
show a + b
show a * b
show a * 5.0

len and linspace

len reads the leading dimension.

g = linspace(0.0, 1.0, 5)
show g
show len(g)

Functions take and return arrays

head_tail takes an array and returns a new one.

def head_tail(v) {
    w = zeros(2)
    w[0] = v[0]
    w[1] = v[len(v) - 1.0]
    return w
}
show head_tail([3.0, 9.0, 27.0])

Scalars broadcast

A scalar combines elementwise with an array from either side, for every arithmetic operator.

v = [1.0, 2.0, 4.0]
show v + 10.0
show 1.0 + v
show 2.0 / v
show v / 2.0

Matrices combine elementwise too

A = [[1.0, 2.0], [3.0, 4.0]]
B = [[10.0, 20.0], [30.0, 40.0]]
show A + B
show A * B

Rank 3 and 4 exist

Allocate with zeros; index with one subscript per axis. show prints the flat data for rank 3+.

z = zeros(2, 2, 2)
z[1, 0, 1] = 5.0
show z[1, 0, 1]

linspace endpoints are inclusive

Both endpoints are in the array, as in NumPy. With n = 1 it is the start alone, and with n = 0 it is empty.

show linspace(0.0, 10.0, 5)
show linspace(3.0, 9.0, 1)

dot is the loop you would write

dot(a, b) is a builtin. The def below is the loop it runs, left to right, and gives the same sum.

def mydot(a, b) {
    s = 0.0
    for i to len(a) {
        s += a[i] * b[i]
    }
    return s
}
u = [1.0, 2.0, 3.0]
v = [4.0, 5.0, 6.0]
show mydot(u, v)
show dot(u, v)

Negative indices count from the end

As in Python: a[-1] is the last element, a[:-1] all but it, A[-1, :] the last row.

a = [10.0, 11.0, 12.0]
show a[-1]
show a[:-1]
A = [[1.0, 2.0], [3.0, 4.0]]
show A[-1, :]

A comprehension builds an array

Its for takes any loop head, and its if keeps the elements it holds for.

xs = [3.0, 1.0, 4.0, 1.0, 5.0]
show [x * x for x in xs if x > 1.0]
show [i * 2.0 for i to 4]

in, and a key for max and sorted

x in a is NumPy's: some element equals x. A key is a def, a builtin or fn(x) -> ....

a = [3.0, -7.0, 4.0]
show 4.0 in a
show max(a, key=abs)
show sorted(a, key=fn(v) -> v * v)

norm is the square root of dot

norm(v) is a builtin too, the square root of dot(v, v).

v = [3.0, 4.0]
show norm(v)
show sqrt(dot(v, v))