Javascript divide buffer into golden rectangles

Question

Im using JS in max/Msp and want to slice the buffer into sections using the golden ratio. I know that this will be a recursive function using the formula a+b/a = a/b but im not sure how to express this in javascript and how to then divide the remaining sections into golden rectangles recursively.

Answer 1

The golden ratio of 1.6xx talks about spiraling out, expanding. If you start with a buffer and want to mark inwards, you can expand it by the reciprocal to shrink.

golden_ratio = ( 1 / 1.61803398875 ) // 0.6180339887498547 of 1.00
//where 1.00 is the 'whole' of your buffer
//the following values are percentage points the slices are at in the buffer
slice_1 =  1.00 * golden_ratio   // .618
slice_2 = slice_1 * golden_ratio // .618^2
slice_3 = slice_2 * golden ratio // .618^3

You could calculate a given-depth slice of from an arbitrary buffer in one explicit call:

slicepoint = Math.pow(golden_ratio, slice_depth) * buffer_size

Otherwise manually performing that recursively could be from providing the initial condition (buffer size) and multiplying the last slice you just calculated by the golden ratio again. Our "last slice" would be the first condition provided, whatever buffer you've got.

some pseudocode:

A[0] = buffer_size
while n++
A[n] = A[n-1] * golden_ratio

for actual javascript code:

Slicing 1sec. of audio into 10 buffers (9 slices needed for 10 buffers)

arbitrary_buffer = 44100 //buffer length 1 sec @ 44.1kHz
slices = 10;              //slice count

// get the reciprocal of golden ratio 
// we can just shrink the whole and mark those points as slices
golden_ratio = ( 1 / 1.61803398875 )

// creepily enough 
// the reciprocal of the golden ratio is 
// its same value without the integer in front of it: .6180339887498547 
// so its a 61.80339887498547% of the original size per-iteration

// This is a list of our slice point locations
slice_points = new Array();

// add an initial condition (arbitrary_buffer) for the recursion 
// like knowing the end of a loaf of bread before cutting
slice_points[0] = arbitrary_buffer;

// the following recursion is in the [i-1] back-tracking
// that's why this for-loop condition has i at 1 instead of 0 per usual
// we provided the initial 44100 and start with index 1 instead
// slice_point[1] should be about 27255.29890386859

for(i=1;i<slices;i++)
    slice_point[i] = slice_points[i-1] * golden_ratio;

The array is populated in descending order starting at its end: 44100

You can switch those values to forward-facing if you just take arbitrary_buffer - slice_point[i];

or, outside of the js object and back in max use [- ] and subtract the js output value from the buffer ms length from bufferinfo~'s right-most outlet, converted to samples.

You might also try using this as a velocity-map for loudness