Scalesmith

Chuck a little bit more, now

2007-12-03T21:37:00.000-08:00

The sound of it now (hope the link works)

The objective: a 16-step sampler sequencer using udderbot sounds, that doesn't sound too dippy or too boring. Oh, and the rhythm is dictated by a moment-of-symmetry/generator-period setup.

So I made 20 wav files of various udderbot sounds, and actually made the ChucK do exactly what I wanted it to, hooray. The trick is putting them into an initial rhythm that grooves - I don't quite have it yet. Also my samples aren't all perfectly trimmed such that the start of each file is perceived as the downbeat of the sample.

To keep it from being boring, every period it switches two randomly chosen samples in the sequence, so after awhile it really morphs, nice.

The rhythmic MOS movement I have a problem with, and the problem/solution lies in the delta function. In this example I'm going from 3/16 to 3/17 by way of 2/11, but 2/11, being of lower cardinality, hogs a lot of time and paradigm; this is because if g is changing by a constant (here, 0.0005), the smaller fractions make the overall rhythm slow down, so what you get is MoRE of the boring stuff and less of the intriguing stuff. I plan to fight this with some sort of exponential curve that makes the delta dependent on proximity to small-number ratios. Hmm, maybe harmonic entropy can help, hehe.

The other question is the compositional question of what a transition of 3/16-2/11-3/17 does, requires, implies. In my 16-beat paradigm, the 17 side of things has a hole in it, and it's noticeable. But the 11-dominated middle is ponderously slow at period=24bpm.

I wonder about secondary beats, whose rhythms are simply halfway between the MOS rhythms'.

// kleismic joy.ck
// 20 soundfiles, in default folder
["00.wav", "01.wav", "02.wav", "03.wav", "04.wav", "05.wav",
"06.wav", "07.wav", "08.wav", "09.wav", "10.wav", "11.wav",
"12.wav", "13.wav", "14.wav", "15.wav", "16.wav", "17.wav",
"18.wav", "19.wav"] @=> string samps[];
SndBuf bufs[20];
for(0=>int i; i<20; i++)
{
samps[i] => bufs[i].read;
bufs[i] => dac;
0.0 => bufs[i].gain;
}
// wait for the air to clear - else they all play at once.
1::second => now;
// now turn 'em up
for(0=>int i; i<20; i++)
1.0 => bufs[i].gain;
// MOS rhythm stuff
//period (tempo)
(4./96.)::minute => dur p;
//generator (initial value, fraction of 1)
3./16. => float g;
//number of notes patterning
16 => int n;
-1 => int tch; // triangel wave
//the change to g and/or p each iteration of period
fun void delta()
{
(tch) * 0.0005 +=> g;
if( g > 3./16. g <= 3./17.)
-1 *=> tch;
}
//
0 => int z;
// make an all-positive MOS
fun float[] makeMOS()
{
float temp;
float r[n];
for(0=>int j; jj)
(g*j) % 1 => r[j];
for(0=>int i; ii) {
for(i+1=>int j; jj) {
if( r[i] > r[j]) {
r[i] => temp; r[j] => r[i]; temp => r[j];
}
}
}
return r;
}
// calculate array of (time) intervals between adjacent values
fun float[] diffs( float zop[])
{
float zip[n];
for(n-1=>int i; i>0; 1-=>i)
{
zop[i]-zop[i-1] => zip[i];
}
1.-zop[n-1] => zip[0];
return zip;
}
// switch a random pair of values in an array
fun void swertch(int oots[])
{
int lars, larsa, temp;
Math.rand2(0, oots.cap()) => lars;
Math.rand2(0, oots.cap()) => larsa;
oots[larsa] => temp;
oots[lars] => oots[larsa];
temp => oots[lars];
}
// initialize MOS array
float doit[n];
diffs(makeMOS()) @=> doit;
//for(0=>int i; ii)
// <<>>;
// seq[] is sequence of samples
// play seq[] in order, to MOS rhythm, but swertch each period
// problem: if multiples of these are sporked, it will update
// the MOS multiple times!
// problem: still hard-wired to 16!
fun void liftme(int seq[]) {
0 => int i;
while(true)
{
while(z<16)
{
if( z>-1 )
{
0 => bufs[seq[z]].pos;
}
doit[z]*p => now;
z++;
}
delta(); diffs(makeMOS()) @=> doit;
swertch(seq);
0 => z;
}
}
// not using 0, 1, 6, 11, 18
[17,12,3,8,19,15,13,9,10,9,7,2,14,4,5,16] @=> int ooks[];
spork ~ liftme(ooks);
while(1)
{
2::second => now;

2007-07-15T20:37:00.000-07:00

ChucK poke: Rhythmic generator/period explorer

For hearing Moment-of-symmetry rhythms and rhythms otherwise defined by a three values: the period (an interval of time), generator (a fraction of that duration), and...well, the third value doesn't have a standard name; I'll say n. N is the number of notes you're using. Because, depending on the exact ratio of generator/period, the pattern can be calculated sometimes to infinite density.

Traditionally the n notes are defined by the number of iterations g's they are defined by (I'm calling this the multiplier, m), always modulo by p. For example, say p = 1 second, and g = 5/12 of that, and n = 7. To get a 7-note scale generated by these values, you could take g*m where m runs from 0 to 6:

0/12
5/12
10/12
3/12
8/12
1/12
6/12

(if we were speaking of scales, this is Locrian) these define a rhythm that repeats every second. As an additive pattern, this will sound like 1-2-2-1-2-2-2. However, in the ChucK code presented, which centers the multiples on zero, this would run from m = -3 to 3:

9/12
2/12
7/12
0/12
5/12
10/12
3/12

(Rhythmically these are the same, but with an offset "downbeat".) At any rate, what interested me enough in this process was an understanding of the Scale Tree (see Erv Wilson) and a desire to watch one rhythm (tree) change into another. So the code is equipped with a delta function that might slowly (or rapidly) alter the value of g and/or p and let us hear slow and creepy paradigm shift.

On my Lombard laptop I can only get 7 notes before ChucK becomes annoyed; I am unsure if this is a processor or a ChucK limitation.


//mosmando.ck
//rhythm mos explorer
// manifestation 0: equal-tuned mando-handbells

//period (tempo)
.56::second => dur p;

//generator (initial value, fraction of 1)
1. => float g;

//number of notes patterning (also tones per octave)
7 => int e;

//the change to g and/or p each iteration of period
fun void delta()
{
 0.01 +=> g;
}

//each boop sporked plays one multiplier (m) of the period...
// only activates notes (no noteOff)
//  queries global variables g and p each time anew
fun void boop( float m, float freq, StkInstrument v)
{
 //Std.fabs(m)*p => now;
 v => dac;
 
 freq => v.freq;
 dur begin;

 while ( true )
 {
  if ( m < 0 )
  {
   (1+ (g*m%1) % 1) *p => begin;
  } else {
   if ( m == 0 )
   { 0::second => begin; }
   else {
   g*m%1 * p => begin; } }
  begin => now;
  v.noteOn(0.6);
  p - begin => now;
 }
}

// make a Mandolin with random timbre, chuck to dac
fun StkInstrument mandome()
{
 Mandolin m;
 Std.rand2f( 0, 1 ) => m.bodySize;
    Std.rand2f( 0, 1 ) => m.pluckPos;
 0.3 => m.stringDamping;
 m => dac;
 return m;
}

// iterative version.
fun void multispork(int n)
{
 for(0=>int i; i < n; i++)
 {
  spork ~ boop( i-(n/2), Std.mtof(57.+(12.*i/n)), mandome());
 }
}

// sequence-of-notes version (make sure size is the same as n!)
[ 57., 59., 61., 57., 59., 57., 53. ]@=> float arr[];
fun void multispork2(int n)
{
 for(0=>int i; i < n; i++)
 {
  spork ~ boop( i-(n/2), Std.mtof(arr[i]), mandome());
 }
}

multispork(e);

while (true)
{ 
 delta();
 p => now; }

// a favorite: g-delta = 2/9., eq5

2007-01-08T21:40:00.000-08:00

Supercollider Stabs

Recent attempts to learn the language of Supercollider finally yield elementarily fruitful results. Behold.

1) Vari-loop allows me to sing a round with myself at any interval up to 6 seconds - the exact interval is determined by the amount of time between the two most recent clicks of the mouse!

({
var max, trig, time;
max = 5;                          //maximum delay interval, in seconds
trig = MouseButton.kr(-1,1);
o = AudioIn.ar(1);                // microphone
time = Timer.kr(trig);
v = DelayN.ar(o, max, time, 0.2); // first delay
w = DelayN.ar(v, max, time, 1);   // second delay follows first, etc.
x = DelayN.ar(w, max, time, 1);   // for less than 4 delays, comment out some
y = DelayN.ar(x, max, time, 1);   // just don't forget to change the next line
m = v+w+x+y;                      // mix
[m,m]                             //out to left and right
}.play)

This plans to flourish into a full loop/delay laptop interface; now it's a start. Sound examples may come in time.

2. Simple 31-EDO ear training. Drone e; moving the mouse left to right gives the octave above it quantized to 31; moving the mouse up and down controls the volume of the second voice.

({Formant.ar({ 2 ** ( floor(MouseX.kr(0, 32, 0, 0.1))/31.0 ) * 160.0}, //32 steps of 31st root of 2
           1000, 500,                                               //formant parameters
           MouseY.kr(0.4, 0, 0),                                    //0-0.4 mul
           Formant.ar(160, 1000, 600, 0.2)                          //da drone
         )}.play)

This can be easily changed to any other equal tuning. I personally see 31 as a gateway tuning to the more heavy, trippy, life-threatening tunings...

I don't claim to know much more about Supercollider than how to get these things running (and every red herring function tried in the meantime), but if that's all you'd like to do, I could might help.

2007-01-06T23:15:00.000-08:00

Circles tied in knots

Here is a nice look that would work on a variety of systems; it is particularly useful in ultrachromatic (lots of small steps) scales for drawing out characteristic intervals that aren't the basic tiny step. It is based on the MOS look at equal temperaments, which requires you to choose an interval whose index is coprime with the size of the scale. But it could work equally well in an unequal scale for mixing things up.

The look itself notices that the easiest way not to get lost on a keyboard is to play it linearly. Especially if you've found a nice juicy chord and you want to try it in various transpositions; you don't want to jump around a lot, but moving up or down by a "semitone" is manageable. Therefore, re-order the notes in a scale to that of a circle (of fifths, of anything), but keep it in the right order (2/1). The distance on the keyboard becomes a harmonic distance in relation to the generating interval chosen. One has an easy look at the related MOS structures, and as an added bonus the intervals move up or down (to stay in the 2/1) in exciting ways.

I already is not saying what I wants to because of a lack of terminology, dang. Today I did it this way: I chose an interval in 31, made a one-note scale with that interval, extended it to 31 notes, and reduced it into an octave. Some pretty things I've found:

• When generating interval is a fifth and the compass is limited to the octave, playing a descending figure of four adjacent "semitones" and descending that figure by a "semitone" each iteration.

• When g = 12/31-oct, playing on the black keys.

• When g = 7/31-oct (orwell!), find a 4:5:6:7 tetrad and modulate it by single steps! Juicy common tone AND diesis movement!