Lambdas & higher-order builtins

fn is a value

square = fn(x) -> x * x
show square(7.0)

Quadrature

Integral of x² over [0,1]; exact answer 1/3.

show simpson(fn(x) -> x * x, 0.0, 1.0, 40)

Exact derivatives

deriv uses forward-mode autodiff, so the slope is exact to rounding: d/dx[x sin x] at 2 against the product rule.

show deriv(fn(x) -> x * sin(x), 2.0)
show sin(2.0) + 2.0 * cos(2.0)

deriv knows log

d/dx log(x) at 3 is 1/3.

show deriv(fn(x) -> log(x), 3.0)

Two-argument lambdas

add = fn(a, b) -> a + b
show add(3.0, 4.0)

simpson accepts an odd panel count

Simpson's rule needs an even number of panels, so simpson rounds an odd n up to the next even number: 7 panels give exactly the 8-panel answer. The integrand is exp, which Simpson's rule does not integrate exactly, so the two would differ otherwise.

odd = simpson(fn(x) -> exp(x), 0.0, 1.0, 7)
even = simpson(fn(x) -> exp(x), 0.0, 1.0, 8)
show odd == even
show trapezoid(fn(x) -> x * x, 0.0, 1.0, 1000)

deriv composes through the chain rule

d/dx exp(sin x) at 1 = exp(sin 1) · cos 1.

show deriv(fn(x) -> exp(sin(x)), 1.0)
show exp(sin(1.0)) * cos(1.0)

The functions deriv can differentiate

Besides + - * and /, deriv knows exp, sqrt, pow, sin, cos, log and tan. The last line uses the quotient rule.

show deriv(fn(x) -> sqrt(x), 4.0)
show deriv(fn(x) -> pow(x, 3.0), 2.0)
show deriv(fn(x) -> tan(x), 1.0)
show deriv(fn(x) -> sin(x) / x, 2.0)

deriv wants a constant exponent

pow(x, c) differentiates only for literal c.

show deriv(fn(x) -> pow(x, x), 2.0)

expected error: constant exponent…

Quadrature error shrinks with panels

For the integral of sin on [0, pi], exactly 2, Simpson's error falls from 0.0046 with 4 panels to 6.5e-8 with 64.

pi_v = 3.141592653589793
show abs(simpson(fn(x) -> sin(x), 0.0, pi_v, 4) - 2.0)
show abs(simpson(fn(x) -> sin(x), 0.0, pi_v, 64) - 2.0)

An array of functions

An array holds numbers, or it holds functions. A function array can be written as a literal, indexed, passed to len, and passed to a def. That is enough to keep a list of methods and pick one while the program runs: because the index is not known in advance, the compiled call goes through a function pointer instead of being fixed at compile time.

def sq(x) {
    return x * x
}
def cube(x) {
    return x * x * x
}
methods = [sq, cube]
for i to len(methods) {
    show apply(methods[i], 3.0)
}

Methods take the function they work on

Each method's first argument is the function it works on, so one program can hand the same problem to several methods and compare their answers. Here spread returns the gap between the largest and smallest answer.

def target(x) {
    return x * x - 2.0
}
def left(f, a, b) {
    return f(a)
}
def right(f, a, b) {
    return f(b)
}
def spread(ms, f, a, b) {
    lo = apply(ms[0], f, a, b)
    hi = lo
    for i to len(ms) {
        v = apply(ms[i], f, a, b)
        lo = min(lo, v)
        hi = max(hi, v)
    }
    return hi - lo
}
show spread([left, right], target, 0.0, 3.0)

Every function in an array takes the same arguments

Every function in one array must have the same C signature: the same number of arguments, in the same positions. Mixing them is an error at the line that builds the array. The interpreter refuses it too, so a program cannot pass in the browser and then fail when compiled to C.

def one(x) {
    return x
}
def two(x, y) {
    return x + y
}
ms = [one, two]
show len(ms)

expected error: the same number of arguments…