generic variables X and Y global variables max step length random density slop ^maybe globals get assigned to different modulators each lunar cycle for more emergence for shifting algo parameters over time - not just change the random max, but also the min, shifting the whole random window over time "it's takes so long for the seasons to change, by the time the next one comes, you can barely remember what it felt like a year ago" ^^remembering that coming back to things on a multi month basis is actually a very long time away calling the different colors epochs, and there are 8 rotating ones of them, each one taking a full lunar cycle to complete (because there are 8 readable colors on rgb - could even change the hue of the rgb over time but that seems confusing could flash all LEDs a certain color on startup to denote the current epoch (as a reminder) and even flash multipe times if that epoch has been seen by the user yet ///////////// # AlGO-BASIC ///////////// 16 step set length variable step density (percent chance to turn a step on) //////////////// # ALGO-BASIC FUN //////////////// same but variable step length, non variable density ^might be good to have 1 on output, one on the other ///////////// # ALGO-REICH ///////////// X is rest length Y is steps to add (something small, like 1-3) roll for base XO plays 1st Y steps, then rests for X steps, then adds Y number of steps to be played in next time through once whole sequence is added and played through once, resets back to the first step /////////////////////// # ALGO-REICH-NORMALIZED /////////////////////// use an array called mutes, that additvely assigns 1(on) or 0(mute) to each step in the sequence in the same way the reich algo does so the length of the pattern is constant, just the active steps get revelealed and hidden over time ////////////// # ALGO-SUMMATION ///////////// vars uknown Plays whole sequence repeating for X times where X is the length of the sequence in steps remove one step from the end, repeat reset when done could also have rest in between sets, either at random step length or the length of the current set ie for the sequence xoxxo would be / xoxxo xoxxo xoxxo xoxxo xoxxo / xoxx xoxx xoxx xoxx / xox xox xox / xo xo / x ///////////////// # ALGO-PAINTOVER ///////////////// X - number of loops before overwriting a bit generates two patterns of equal length, different patterns though S1 and S1A slowly rewrites s1 to s1a swaps 1bit per x loops, in order from S1[ind] to S1A[ind] once one pattern is totally overwritten, starts writing back over to the other pattern, in an infinite loop ////////////// # ALGO-SKIPPY ////////////// play once through then play every other step in sequence, for 2 loops then every third note for 3 loops, etc. unti only one note played ////////////// # ALGO-CULTURE ////////////// fuzzy idea storing a bunch of culturally significant pre written rhythms then assigning 1 to each output maybe flipping some bits or something so they're slightly different but not so different to totally change the DNA good would prob be 1 bespoke rhythm + 1 generated for a patch rhythms from african bell pattern and variations, common two part stroke rhythms from latin different claves, rumba salsa bases etc. from european hemiola, waltz, etc. some from contemporary composers also using inverted versions of the rhythms (swapping where x and o are) ALGO CULTURE ALT putting those rhythms in a pattern with larger resolution and moving some notes 1/32 or 1/64th off ///////////////// # ALGO-DISTRIBUTE ///////////////// rather than rolling random for every step having a pretermined amount of steps, then randomly distributing throughout the pattern the number of steps could be static while the length of the loop changes or - for another algorithm the number of steps could be a small random range or, for another algorithm the length of loop could be static while the steps to be shuffled changes implementation would be in the for loop the index that you set wouldn't be i, it would be a random location in the array /////////////////// # ALGO-CLUMP /////////////////// placing steps in clumps of 2 or more set amt of clumps and clump length /////////////////// # ALGO-TUPLE ////////////////// start by placing tuplets of different lengths then adding some variation ////////////// # ALGO-SPARSE ////////////// pattern with much more space and maybe 1 or 2 notes in it only then it can be clocked way faster and used like a polyrhythm/be way sloppier ///////////// # ALGO-BlOCKS ///////////// builds rhythms by randomly arranging 1 beat long blocks maybe 16 beats long, maybe random # of blocks etc. based on the rhythm trainer website - which would use 4 blocks, 1 'beat' each (we'll call it 4 steps, meaning 16 total) Those were: quarter rest 0000 quarter note 1000 two eights 1010 dotted eight sixteenth 1001 two eighths plus quarter 1110 quarter plus 2 eighths 1011 four sixteenths 1111 eigth rest, eigth 0010 // alt algo that is like blocks but with non even numbers of steps per block 216 ie you might add a 5 block step to a 3 block step etc. // Euclidean algo? // Algo that swaps between triplet placements and normal placements // ALGO-WONK 32 step arr, loops at 32 places beats by skipping steps ie skip some constrained random number of steps, place a 1, skip again until the index is greater than 31 or maybe theres a value thats percent to add a step every step walk trough the array if you do place a step, the random % chance goes way down then for every step passed that you don't place a step, add a little to the % to step that way you're less likely to get clumped steps, but it's not impossible // // ALGO-WONK alt 32 step pattern then place notes skipping 2 notes at a time (effectively a 16 step pattern, could also skip 4 and make an 8 step pattern) then go through, and move some of the placed steps one index forward or back var called steps to wonk, then randomly select steps, and if its a 1, wonk it and keep going until you hit max steps to wonk // ALGO arrange 4/4 time plays the pattern 3 times, then a flippy/altered variation through 4 times (if normal=n and fill=f, nnnf nnnf nnnf nnnf - with 4 diff fills) one fill is flipped one fill is everything moved over 1 beat etc could be a whole algorithm based on playing something, then playing the same thing beat shifted some number like normal X2 shifted -1 beat X2 normal X2 shifted +2 beat X2 these ones prob work better as 4/4 patterns more readable // Algo phase a sparse algo (non usual beat timing thing) but where the length of the sequence is always 1 step more or less than a normal amount ie 15 beats, 31 beats, 16 beats, 33 beats - etc. // ALGO binary algo based on complex number skipping binary behavior like the following idea from the xaos binary stuff ie skipping by more than +=1 for complex binary outputs "When operating alone, the state of Erfurt changes by 1 at each impulse from the clock inputs, so that it counts from 0 to 255 in a cycle (modulo 256). This yields the signal frequency divided by 2, 4, 8, etc. up to 128, available at individual bit outputs. Depending on which clock input is used, the clock patterns correspond to the so called mathematical or musical divisions of the rhythm. With two different clocks patched to the inputs, the counter alternately increases and decreases its state, and ultimately it counts with a rate proportional to the frequency difference between the clocks. A third clock patched to the Reset input may be used to shorten the sequence thus making the cycle incomplete for even more rhythmic diversity. When there is a Leibniz data source connected at the back (even as simple as Lipsk), the state increases or decreases in larger steps, depending on the data present at the Leibniz bus (eg. the value programmed by the Lipsk buttons). The counter overflows quicker, and produces more complex patterns." // sloppy noppy rhythm where part/half of it is pushed forward a 32nd note, the other part is straight tried it with some jd beck rhythms and it sounded sick //Halves algorithm that does something with halves ie splitting the rhythm in 2, then playing the first half once (2nd half rests) and then playing the first half rests, and the 2nd half ie pattern 1, rests rests, pattern 2 or probably better with repeats pattern 1, rests pattern 1, rests rests, pattern 2 rests, pattern 2 //ALGO phase algo based on my tests where I detect clock input with a delay, so that it catches only some clock in pulses at weird times/intervals // Plays itself Then repeats the second half Then starts over Or repeats not exactly the second half but the last quarter, last third etc // Fast tick sparse algo that plays with doing pattern repeats with some notes shifted one step // Algo like kick in the internet “something missing” Ie play something 3 times, play a variation the 4th time Sounds kind double timed/skewed last time Thing its 32 reso // Double dots algo 10000001 Kind of stuff Like 10011001 But stretched out Like Rossini double dots