Deleted bars.py, rays.py
setting up stage for the signal abstraction.
The Signal abstraction

The Signal class is awesome. You initialize a signal like this:

from sig import * # all the examples below assume this line is on top

s = Signal(data, sampling_rate)

Now, s has some time varying values. Like s.t, the current time; s.x,
the current sample.

You can lift any function to make it a time varying value associated
with the signal. e.g.:

s.xsquared = lift(lambda sig: sig.x**2)
Now, s.xsquared is s.x squared, and varies with s.x.

You can also lift long sequences of the same length as the data in
the Signal:

s.A = lift((s.Y[:, 0] + s.Y[:, 1]) / 2)   # average of left and right
channels

s.A will contain the (s.x)th average value

You can also make these arrays "temporally indexable".

e.g. if you instead do s.A = lift((s.Y[:, 0] + s.Y[:, 1]) / 2, True)
(the True means make it t-indexed)
s.A[0] will be the s.xth average value, s.A[-1] is the one before that.
You can say s.A[-512:512] to get 1024 values in A offset by the
current s.x

Therefore you can define short-time fft like this:

S.fft = lift(lambda s: dsp.fft(s.A[-N/2:N/2]))
where N is the size of your window

finally, processes can "perceive" a signal:

perceive(processes, s, fps)

here, processes is a list of functions that do something with the
current value of s, the signal being perceived.
perceive simulates changes in the signal as if it is being
received in real-time. see player.py for an example process and use of
the signal abstraction.