Did you know that the scale of acoustic pitches is logarithmic?  This means that, even though we perceive the scale of notes as increasing or decreasing linearly, the actual frequencies are doubling or halving with each octave.

In my Deconspectrum installation, I’m mapping acoustic frequencies to color.  If I mapped them linearly, the colors would change very rapidly in the low frequencies, and then stop changing as obviously as the pitch gets higher.  This is not the effect you would expect, since you want each pitch to be represented by another color.

The solution is to map frequency to color (hue) logarithmically instead of linearly.  Thankfully, AVR C gives us a handy base-10 log function:

int hueFreq = log10(frequency - FREQ_MIN) * hueScale;

If we graph this, we get:

The ‘y’ scale is hue and the ‘x’ is frequency.  You can see that, with each octave, the change in color progresses more naturally, mimicking our linear perception of pitch.

Here’s the same graph with a logarithmic frequency axis:

The dotted line is the log10 function without the cutoff, so you can see the “simulated” linearity.

Handy, and highly effective!

Occasionally on my server I’ll get dead processes that fit a specific command pattern, and I need to kill them.  However, I don’t want to killall, as other processes of the same program are still running normally.  Here’s a handy one-liner I just whipped up to do this:

sudo kill `ps ax -o"pid,command" | grep -E 'command_pattern' | awk '{print $1}'`

ps ax -o"pid,command"

gives you a list of all processes, just showing pid and command.

grep -E 'command_pattern'

searches for a regex command pattern.

awk '{print $1}'

returns the first column—the pid. This is the ultimate output of the backticked expression, which is substituted as the parameter for kill.

Hope you find it useful!

Check it:

for i in test-{0..10}; do echo "dummy data" > $i; done

Neat!

Building out a Flash interface from a PSD can be a time consuming process, so to make things most efficient, here are some handy guidelines for preparing Photoshop files.  Designers may want to duplicate their PSD and save it as a new file specifically for Flash import if they want to keep extra hidden layers, etc..

• Turn off or delete all unused or irrelevant layers.
• Merge all adjustment layers or masks into regular layers.  Masked layers or groups cannot be used!
• Layer effects are OK!  However, if you turn one off and don’t plan on using it at all, make sure you remove the effect by dragging it onto the trash icon in the Layers palette.
• Vector graphics are always preferred!  If you are using Illustrator to design any assets, please provide the Illustrator file too, as Flash cannot import Smart Vector Objects.
• Vector graphics are especially preferred for layers intended to be animated.  Imported bitmaps will often look shoddy and low-resolution when moving around and rotating.
• If an Illustrator file can’t be provided, rasterize any Smart Vector Objects or other non-standard layers.
• Keep groups and layers orderly and named accurately whenever possible

I was getting this error:

Error #2078: The name property of a Timeline-placed object cannot be modified.

…even though I had no code addressing any Timeline-placed objects. What gived? I was trying to give an instance name of “name” to the object. Change it and you’re good. Word to the wise!

Here’s a weird little function I just wrote to “slice” an integer out of a byte:

int byteSlice(byte input, byte startIndex, byte endIndex){

  // generates an integer value from an arbitrary slice of a byte
  // Example:
  //
  // index:   01234567
  // input = B01101100 (int 108)
  //
  // startIndex = 1
  // endIndex = 4
  // slice = B1101
  // returns int 13

  byte output;

  // shift left to shave off bits before startIndex
  output = input << startIndex;
  // shift right to shave off bits after endIndex
  output = output >> (7-endIndex) + startIndex;

  return int(output);
}

This basically takes out a chunk of a byte and gives you the integer representation of its bits.  The input index byte datatypes are a neurotic memory optimization, since the indices can’t be greater than 7. Example Arduino implementation:

void setup(){

  Serial.begin(9600);
  byte in = 108;

  Serial.print(in, DEC);
  Serial.print("\t");
  Serial.println(in, BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 0, 7), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 0, 7), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 1, 4), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 1, 4), BIN);
  Serial.println("----------------");
  Serial.print(byteSlice(in, 3, 6), DEC);
  Serial.print("\t");
  Serial.println(byteSlice(in, 3, 6), BIN);
}

void loop(){
}

Here are two super-useful Arduino utility functions I just devised for my thesis:

byte arrayToByte(int arr[], int len){
  // Convert -1 to 0 and pack the array into a byte
  int i;
  byte result = 0;

  for(i=len-1; i>=0; i--){
    if(arr[i] == -1){
      result &= ~(0 << i);
    } else {
      result |= (1 << i);
    }
  }
  return result;
}

int* byteToArray(byte in){
  int i, temp, out[8];

  for(i=0; i<8; i++){     temp = (in >> i) & 1;
    if(temp == 0) temp = -1;
    out[i] = temp;
  }
  return out;
}

The first function takes in an array of up to 8 integers valued 1 or -1 and generates a corresponding byte; the second does the reverse.  Easy to modify for other integer values.

A perceptron is one of the simplest forms of neural networks: a linear classifier.  It is a method of associating input patterns with output patterns, with the advantage that it is forgiving of noise in the input.

The network consists of an input and output layer (and optional “hidden” layers in between) with weighted connections between all of them.  To train a perceptron, you present an input pattern and the output pattern it should learn to output.  Then you step through each pair of neurons in each pair of layers and modify their weights with this equation:

∆w_i = c (d – sign( ∑x_iw_i)) x_i

…where w_i is the ith weight (real-valued), c is the learning constant (i.e. 0.1), d is the desired output for this node (1 or -1), and x_i is the input activation (1 or -1).  The input activation term indicates that the input node in question “contributes” to the output or “inhibits” it.  sign() is given by:

sign(x) = 1 if x ≥ 0, else -1

Here’s a C++ implementation from my Neuroduino Arduino library:

int Neuroduino::signThreshold(double sum){
	if (sum >= _net.Theta) {
		return 1;
	} else {
		return -1;
	}
}

double Neuroduino::weightedSum(int l, int node){
	// calculates input activation for a particular neuron
	int i;
	double currentWeight, sum = 0.0;

	for (i=0; i<_net.Layer[l-1]->Units; i++) {
		currentWeight = _net.Layer[l]->Weight[node][i];
		sum += currentWeight * _net.Layer[l-1]->Output[i];
	}

	return sum;
}

void Neuroduino::adjustWeights(int trainArray[]){
	int l,i,j;
	int in,out, error;
	int activation;	// for each "rightmost" node
	double delta;

	for (l=1; l<_numLayers; l++) {
		// cycle through each pair of nodes
		for (i=0; i<_net.Layer[l]->Units; i++) {
			// "rightmost" layer
			// calculate current activation of this output node
			activation = signThreshold(weightedSum(l,i));
			out = trainArray[i];	// correct activation
			error = out - activation;	// -2, 2, or 0

			for (j=0; j<_net.Layer[l-1]->Units; j++) {
				// "leftmost" layer

				in = _net.Layer[l-1]->Output[j];

				delta = _net.Eta * in * error;
				_net.Layer[l]->Weight[i][j] += delta;
			}
		}
	}
}

void Neuroduino::simulateNetwork(){
	/*****
	 Calculate activations of each output node
	 *****/
	int l,j;

	for (l=_numLayers-1; l>0; l--) {
		// step backwards through layers
		// TODO: this will only work for _numLayers = 2!
		for (j=0; j < _net.Layer[l]->Units; j++) {
			_output[j] = signThreshold(weightedSum(1, j));
		}
	}
}

Today I needed to find the Least Common Multiple of more than 2 numbers for my recombinatory poem tool, and discovered it’s more of a sophisticated problem than I had initially thought.  Here is my implementation, using recursive greatest common divisor reduction:

function gcd(a, b){
	// Euclidean algorithm
	var t;
	while (b != 0){
		t = b;
		b = a % b;
		a = t;
	}
	return a;
}

function lcm(a, b){
	return (a * b / gcd(a, b));
}

function lcmm(args){
	// Recursively iterate through pairs of arguments
	// i.e. lcm(args[0], lcm(args[1], lcm(args[2], args[3])))

	if(args.length == 2){
		return lcm(args[0], args[1]);
	} else {
		var arg0 = args[0];
		args.shift();
		return lcm(arg0, lcmm(args));
	}
}

Just pass in an array like so:

trace(lcmm([1,2,3,4]));

I’ve begun developing an algorithmic, recursive gestural tree using JavaScript to draw into the HTML5 <canvas> element.  After running into a few initial problems, like discovering I was overflowing my browser stack limit, I progressed to some scribbly sketches.

Fixing the locating problems yielded these:

I then decided to move towards a continuous, single line composed of Bezier segments:

This could easily pave the way for a recursive sketching algorithm that composes each Bezier segment from n number of smaller Bezier segments down to a predefined number of levels.  The larger question, in this investigation, remains: what determines the high-level gestures?