fractal sequencer

i mean, note range (how many notes the melody should consist of, from 1 to 12 or maybe more) should be controlled by a integer and duration (how long the series is) should be controlled by an integer and variation, which is the hard part i think, should be controlled by an integer. So if the note range is 3 and the duration is 4, two variations could be [1, 2, 3, 1] and [1, 1, 2, 3] for example

and [0, 1, 3, 0] would be a variation too, if 0's (non played notes) is included too

and now build a patch which does that.

the trick is to just start patching.

Hi M.K.,

Everything you asked for in your first post here is included in that patch. Do a close reading of the details on Norgard's practice on the link I provided. Here it is again: http://www.pernoergaard.dk/eng/ideer/hierarkisk.html

In that first post you referred to the fractal qualities of self-similarity (the pattern is contained with a pattern is contained within a pattern..... ) and scale invariance (the pattern appears at different levels of scale). The infinity sequence you can generate with the patch I posted gives you both of those. Accessing these features of the sequence is as simple as counting. The basic, and most simple, way of using the patch is to simply feed it the output of a counter: 0 1 2 3 4 . . . This will generate, as output, the infinity sequence. Embedded in that sequence are the self similarity and scale invariance characteristics. On examination the sequence reveals repeated versions of itself in both its original and inverted forms as well as transposed. One way to start exploring this is to enter a sequence of integers to the inlet of the patch that count by 4 or 16 or 64 or... you see the pattern. To count by 4s, multiply the output of a counter by 4, to count by 16s multiply the counter's output by 16, etc. To combine these as layers of a musical flow use separate infinityseriesvalue objects for each thread of the musical fabric, feeding them the appropriate integer count at the appropriate time. This gives you the classical variations of inversion and transposition. Count backwards through the series and you get retrograde and retrograde inversion. Work with subsets of the series that you find interesting as melodic figures or themes and repeat them with variations and in counterpoint with other figures/themes derived from the series. There's so much to explore and discover there.

Another, by now canonic, example of a musical fractal is 1/f noise. It turns out that music exhibits a similar 1/f distribution in several of its dimensions, pitch contour, rhythmic quality, loudness variations in performances, etc.

See this article from Scientific American that introduced the idea to the wider public back in the 80's.

http://homes.soic.indiana.edu/donbyrd/Teach/PapersEtcByOthers/SciAmMathGames77_FractalMusic.pdf

The algorithm for generating a sequence of numbers that exhibit a 1/f that Gardner shared with us is interesting. It's based on a hierarchical ordering of random values at several levels of scale (sound familiar?). And, it's a similar to Ken Perlin's original approach to generating fractal noise for use in procedural computer graphics.

Then there's the fractal form of the harmonic series to play with in terms of melodic construction and harmonic function... but that's another story. Check out the Table of Pythagoras, Harry Partch's Genesis of a Music.

Enjoy!

Kenneth.

I wrote an external in C, and a very trivial patch around it. The external runs the classic Mandelbrot formula, and outputs:

col, row, and a value which is equal to maxColors % iteration

The inputs are self-explained in the patch.

Is there somebody more skilled than me in Max graphics willing to add the drawing part, including mapping those values to a color palette?
Please note that so far the object outputs 0 if "black" must be painted.
I was wandering if changing it to -1 or whatever...

Of course all the usual "zooming" stuff is missing so far, but it's just to give it a try...

After that, I (we) can devise some kind of (layered) notes production, if you folks think that is of some interest.

Nicola

roman, sorry if this is a stupid question but how can i recreate your thue morse sequencer so it outputs more values than 0 and 1? 4 values for instance 0, 1, 2, 3

it does that; it is the "system" parameter. supports up to 9.

originallly planned up to hexadecimal, but then you´d run out of outlets one day. :)

watch out that the"focus" is not set to a bigger value than the "system". auto limiting this numberbox is missing in this version (i once lost tons of updated bpatchers)

big fun is when you let several of them control each other instead of using a counter.

also try out what happens when you do * 95 to the counter input and things like that.

>>Is there somebody more skilled than me in Max graphics willing to add the drawing part

nicola can you provide me some quasi-code for the formula? i always wanted to have a mandelbrot generator (as max patch), but failed interpreting what i found about how it works. :)

Roman, I would be glad to share. But let me share also some other things. First of all, I deserve no credit for the Mandelbrot formula psuedo-code! i got it form here: http://jonisalonen.com/2013/lets-draw-the-mandelbrot-set/, so the credits go to them!
Here it is:

for (int row = 0; row < height; row++) {
    for (int col = 0; col < width; col++) {
        double c_re = (col - width/2.0)*4.0/width;
        double c_im = (row - height/2.0)*4.0/width;
        double x = 0, y = 0;
        int iteration = 0;
        while (x*x+y*y 

I just implemented (in C Language) a first version coming directly from the pseudo-code above, I added some inlets and outlets management, and got the "fractalc.mxo" external I attached to my previous post.

But I noticed that this code is very heavy on the performance side if I simply BANG it to run as it is (with a single BANG), so I devised a new solution.

I developed a new version in which I BANG it continuously using the Global Transport and the "metro" object, but of course I let it run (each time) only for a pre-selected (configurable) number of "row" and "col" iterations. Here is my piece of code:

int maxColors;
int row, col, height, width, maxIter, step, retIter;
double x_new, c_re, c_im;

iterQuantum = myQuantum;
maxColors = myColors;
maxIter = myIterations;
height = myHeight;
width = myWidth;
step = myStep;

while (glRow < height) {
    
    while (glCol < width) {
        
        c_re = (glCol - width/(step/2))*step/width;
        c_im = (glRow - height/(step/2))*step/width;
        
        retIter = game(x,c_re,c_im,step,maxIter);
        
        if (retIter < maxIter) myintout123(x, glCol, glRow, (maxColors % retIter));
        else myintout123(x, glCol, glRow, 0);
        
        glCol++;
        if (((glCol % iterQuantum) == 0) || (glCol == width)) { if (glCol == width) glCol = 0; break; }
    }
    glRow++;
    if (((glRow % iterQuantum) == 0) || (glRow == height)) { if (glRow == height) glRow = 0; break; }
}

Please note that:

- glRow and glCol are global
- all the variables named "mySOMETHING" come from the inlets
- the game() function contains the remaining "while" cycle you can find in the pseudo-code above

I will post the new versions as soon as I manage to (kind of) complete them.

Nicola

after i asked yesterdasy i googled again for it (which i didnt do for some 8 years) and actually found a few.

and i noticed that the main issue is probably that i am trying to "generalize" the method which was originally made for 2d graphics while understanding and coding it at the same time.

what i am trying to say is this: i would like to avoid to start with a plotted graphics version, as i feel that this means coding 90% stuff which i have to remove later anyway (when my aim will be note numbers, modulation signals, or lists of ASCII...)

maybe my approach is wrong?

would be great if you could create a simple model as max code using only basic max objects. or eventually this does not make sense at all, we will see. :)