This directory contains demonstrations in support of the keynote talk, "The
Sampling Theorem and Its Discontents", ICMC 2015, Denton, Texas.  The writeup
can be found on msp.ucsd.edu/Publications/icmc15.pdf .  The examples are all
realized as Pure Data patches, and were tested in Pd 0.47.  They should run on
Windows XP or later, MacOS 10.6 or later, or any version of linux. No extra
libraries are needed as long as the directory structure here is maintained with
subdirectories "lib" and "rungekutte~".  The patches (in the order that they are
mentioned in the paper) are:

mathews-table-lookup-example.pd - a Max Mathews sampling theorem demo
bentbob-test.pd - a spin on the Moog ladder filter
forcedosc-test.pd - a forced oscillator
lorenz-test.pd - the Lorenz attractor
coupled-sampled.pd - two coupled oscillators, using a non-RK approach

About the three examples using the rungekutte~ object:

bentbob-test.pd is a modified Moog ladder filter whose cutoff frequency may
take different values depending on the sign of one of the state variables,
so that in "oscillation" mode one half of the waveform plays faster than the
other.

forcedosc-test.pd is a simple nonlinear forced oscillator.

lorenz-test.pd realizes the Lorenz dynamic system.

Other examples (not using rungekutte~):

mathews-table-lookup-example.pd : an example due to Max Mathews demonstrating
foldover in non-interpolated table lookup oscillators.  

coupled-sampled.pd - two coupled oscillators demonstrating how a flow on a
surgically modified torus can be solved exactly in discrete time even though
the system modeled is continuous-time.  This "realization" is actually the
genesis of the idea, and doesn't implement the idea as it is (more correctly)
described in the paper.  Instead, there are two sampled oscillators, each
based on rotating a vector about the origin and correcting its amplitude to
1 at each sample.  Then, of the two oscillators, considered as masses on
springs, "hit" each other, the phases are further altered as if they has
rebounded off each other.

About the rungekujtte~ object:

rungekutte~ loads a shared object file defining a differential equation
and integrates teh rquation using the runge-kutte technique.
The differential equation is supplied as a shared object loaded by the
rungekutte~ object at run time.  The shared object should provide two
integers:

int nstate;
int nparam;

initialized to the number of state variables and of input parameters to the
system, and a function:

void derivative(float *result, float *state, float *params)

where:
 result is the routine's output (the calculated derivitaves, nstate elements)
 state is the current state of the system (nstate elements)
 params is an array of additional parameters (nparams elements)

The rungekutte~ object takes "nparams" and "nstate" as creation arguments and
has "nparams" inlets and "nstate" outputs, all signals.

Two sample differential equation sets are included:

'bob' is a model of the Moog voltage-controlled resonant filter, which
is described in the dicumentation for Pd's bob~ object.  The equations are:

y1' = k * (S(x - r * y4) - S(y1))
y2' = k * (S(y1) - S(y2))
y3' = k * (S(y2) - S(y3))
y4' = k * (S(y3) - S(y4))

where k controls the cutoff frequency, r is feedback (<= 4 for
stability), and S(x) is a saturation function.

The second is the Lorentz attractor:

x' = alpha * (sigma * (y - x))
y' = alpha * (x * (rho - z) - y)
z' = alpha * (x * y - beta * z)

Here we've added a parameter alpha to control the overall time scale, in
addition to the three classical parameters sigma, rho, and beta (CF. the
Wikipedia page).

The rungekutte~ object is BSD licensed; copyright notice is in the source code.