HelpSource/Classes/Pdefn.schelp

   1 class:: Pdefn
   2 summary:: non event stream reference definition
   3 categories:: Libraries>JITLib>Patterns
   4 related:: Classes/Pdef
   5
   6 description::
   7 Pdefn provides an interface to its superclass link::Classes/PatternProxy::, keeping a reference to a stream that can be replaced while playing. One pattern may be used in many streams in different places. A change in the pattern definition propagates through all streams.
   8
   9 Pdef and Pdefn use separate global collections.
  10
  11 code::
  12 Pdefn(key)      //returns the instance
  13 Pdefn(key, pat) //defines the pattern and returns the instance, like Pdef, Tdef and Ndef.
  14 ::
  15
  16 It is very similar to link::Classes/PatternProxy::.
  17
  18 Pdefn can be used to store value patterns globally (for strong::event patterns::, see link::Classes/Pdef::). Overview: link::Overviews/JITLib::
  19
  20 subsection::First Example
  21
  22 code::
  23 s.boot;
  24
  25 Pdefn(\x, Pbrown(0, 6, 0.1, inf));
  26 Pbind(\note, Pdefn(\x), \dur, 0.3).play;
  27 Pbind(\note, Pdefn(\x), \dur, 0.1, \ctranspose, 15).play;
  28 // now change the definition
  29 Pdefn(\x, Pseq([0, 3, 5, 7, 9, 11], inf));
  30 Pdefn(\x, Pseq([0, 3, 3, 7], inf) + Pseq([0, [0, 3], [0, 5, 7]], inf));
  31 ::
  32
  33 ClassMethods::
  34
  35 private::initClass
  36
  37 subsection::Creation
  38
  39 method::new
  40 Store the pattern in a global dictionary under key, replacing its pattern with the new one. If the pattern is a strong::function::, Pdefn creates a link::Classes/Prout:: with this function, passing in the envir, if given(see below).
  41
  42 Using strong::*new(key):: you can access the pattern at that key (if none is given, a default silent event is created)
  43
  44 method::default
  45 Default source, if none is given. The default is a Pattern that returns 1.0 (This is 1 and not 0 to avoid deadlocks when used as a duration pattern. In a sense, 1 is just as generic as 0).
  46
  47 method::removeAll
  48 Remove all proxies from the global dictionary ( link::#*all::)
  49
  50 method::clear
  51 Clear all proxies, setting their source to silence.
  52
  53 method::all
  54 Set or return the environment ( link::Classes/IdentityDictionary:: ) that stores all Pdefns.
  55
  56 InstanceMethods::
  57
  58 private::prAdd
  59
  60 Examples::
  61
  62 subsection::Pdefn in expressions
  63
  64 code::
  65 Pdefn(\c, Pdefn(\a) + Pdefn(\b));
  66
  67 t = Pdefn(\c).asStream; // create a stream from Pdefn(\c)
  68
  69 t.value; // default value for a Pdefn is 1, so that it is a good time value default.
  70
  71 Pdefn(\a, 100); // (re)define Pdefn(\a) as 100
  72
  73 t.value;
  74
  75 Pdefn(\b, Pseq([1, 2, 3], inf)); // (re)define Pdefn(\b) as Pseq([1, 2, 3], inf)
  76
  77 3.do { t.value.postln };
  78
  79 Pdefn(\c, Pdefn(\a) * Pdefn(\b) - Pdefn(\a)); // (re)define Pdefn(\c)
  80
  81 8.do { t.value.postln };
  82
  83 Pdefn(\a, Prand([1, 4, 2], inf)); // (re)define Pdefn(\a)
  84 ::
  85
  86 subsection::Embedding Pdefn in other patterns
  87
  88 code::
  89 Pdefn(\x, Pseq([1, 2, 3], inf));
  90
  91 x = Pseq([0, 0, Pdefn(\x)], inf).asStream;
  92
  93 t = Task({ loop({ x.next.postln; 0.3.wait }) }).play;
  94
  95
  96 Pdefn(\x, Pseq([55, 66, 77],inf));
  97 Pdefn(\x, Pseq([55, 66, 77],1));
  98
  99 t.stop;
 100
 101
 102
 103 // Pdefn can be accessed in multiple streams
 104
 105 (
 106 SynthDef("Pdefhelp", { arg out, freq, sustain=1, amp=1, pan;
 107         var env, u=1;
 108         env = EnvGen.kr(Env.perc(0.03, sustain), 1, doneAction:2);
 109         5.do { var d; d = exprand(0.01, 1); u = SinOsc.ar(d * 300, u, rrand(0.1,1.2) * d, 1) };
 110         Out.ar(out, Pan2.ar(SinOsc.ar(u + 1 * freq, 0, amp * env), pan));
 111
 112 }).add;
 113 s.boot;
 114 )
 115
 116 (
 117 Pdefn(\deg, Pseq([0, 3, 2],inf));
 118
 119 Pset(\instrument, \Pdefhelp,
 120         Ppar([
 121                 Pbind(\degree, Pdefn(\deg), \pan, -0.8),
 122                 Pbind(\degree, Pdefn(\deg), \dur, 1/3, \pan, 0.8)
 123 ])
 124 ).play;
 125 )
 126
 127 Pdefn(\deg, Prand([0, 3, [1s, 4]],inf));
 128
 129 Pdefn(\deg, Pn(Pshuf([0, 3, 2, 7, 6],2),inf));
 130
 131 (
 132 Pdefn(\deg, Plazy { var pat;
 133         pat = [Pshuf([0, 3, 2, 7, 6],2), Pseries(0, 1, 11), Pseries(11, -1, 11)].choose;
 134         Pn(pat, inf)
 135 });
 136 )
 137 ::
 138
 139 subsection::Timing
 140
 141 When does the definition change?
 142
 143 If quant is set, the update is done at the next beat or whatever is specified:
 144
 145 code::
 146 Pdefn(\deg).quant = 4;
 147 Pdefn(\deg, Pn(Pseries(0, 1, 8),inf));
 148
 149 Pdefn(\deg).quant = nil; // activate immediately again
 150
 151 (
 152 Pdefn(\deg, {
 153         loop {
 154         5.do { |i|
 155                 #[1, 3, 4].choose.yield;
 156                 #[5, 0, 12].choose.yield;
 157                 #[14, 3, 4].choose.do { |j| (i % j).postln.yield };
 158         }
 159         }
 160 })
 161 )
 162 ::
 163
 164 subsection::update condition
 165
 166 In order to be able to switch to a new pattern under a certain condition, the instance variable strong::condition:: can be set to a function that returns a boolean. Value and a count index are passed to the function. The condition is always valid for the strong::next pattern:: inserted. For stuck conditions, the strong::reset:: message can be used.
 167
 168 As counting up (such as emphasis::"every nth event, a swap can happen"::) is a common task, there is a method for this, called strong::count(n)::.
 169
 170 code::
 171 z = Pbind(\degree, Pdefn(\x, \), \dur, 0.25).play;
 172 Pdefn(\x, Pseq((0..5), inf)).condition_({ |val, i| i.postln % 6 == 0 });
 173 Pdefn(\x, Pseq((7..0), inf)).condition_({ |val, i| i.postln % 8 == 0 });
 174
 175
 176 // the above is equvalent to:
 177 Pdefn(\x, Pseq((7..0), inf)).count(8);
 178 ::
 179
 180 subsection::Reset
 181
 182 code::
 183 // reset to change immediately:
 184 Pdefn(\x).reset;
 185
 186 Pdefn(\x).stop;
 187 ::
 188
 189 subsection::Functions as arguments to Pdefn
 190
 191 code::
 192 Pdefn(\deg, { loop { yield(0.1.rand.round(0.01) + [2, 3, 9].choose) } });
 193
 194 // equivalent to:
 195
 196 Pdefn(\deg, Proutine { loop { yield(0.1.rand.round(0.01) + [2, 3, 9].choose) } });
 197
 198 // this is not exactly true, see below..
 199 ::
 200
 201 subsection::The (inner) environment
 202
 203 code::
 204 // set() creates a local environment that overrides the outer currentEnvironment
 205
 206 Pdefn(\z).set(\a, 1, \b, 5);
 207 (
 208 Pdefn(\z, { |e|
 209         loop { yield((e.a + e.b) + 0.1.rand.round(0.01)) }
 210 })
 211 ); // [1]
 212
 213 t = Pdefn(\z).asStream;
 214
 215 t.nextN(3);
 216
 217 (
 218 Pdefn(\z, { |e|
 219         //(e.a + e.b) + 0.1.rand.round(0.01) 1
 220         Pseq([1, 2, e.a], 1)
 221 })
 222 );
 223
 224 Pdefn(\z, Pseq([1, 2, 3], 1));
 225
 226 e = Pdefn(\z).envir
 227
 228
 229 Pdefn(\z).set(\a, 3);
 230
 231 t.next;
 232
 233 Pdefn(\z).set(\a, Pseq([1, 2, 3], inf));
 234
 235 t.reset;
 236 t.nextN(3);
 237
 238 Pdefn(\z).envir; // post the envir
 239
 240
 241
 242 // if you want to keep using the currentEnvironment at the same time,
 243 // assign the currentEnvironment to the envir's parent (or proto) field
 244 // (this shouldn't be a proxy space of course.)
 245
 246 Pdefn(\z).envir.parent = currentEnvironment;
 247 ~a = 9;
 248 ~b = 10;
 249
 250 t.nextN(3);
 251 ::