Pattern

superclass: AbstractFunction

Patterns versus Streams

Pattern is an abstract class that is the base for the Patterns library. These classes form a

rich and concise score language for music. The series of help files entitled Streams-Patterns-Events

gives a detailed introduction. This attemps a briefer characterization.

A Stream is an object that responds to next, reset, and embedInStream. Streams

represent sequences of values that are obtained one at a time by with message next. A reset

message will cause the stream to restart (many but not all streams actually repeat themselves.)

If a stream runs out of values it returns nil in response to next. The message embedInStream

allows a stream definition to allow another stream to "take over control" of the stream.

All objects respond to next and reset, most by returning themselves in response to next.

Thus, the number 7 defines a Stream that produces an infinite sequence of 7's. Most objects

respond to embedInStream with a singleton Stream that returns the object once.

A Pattern is an object that responds to asStream and embedInStream. A Pattern

defines the behavior of a Stream and creates such streams in response to the messages asStream.

The difference between a Pattern and a Stream is similar to the difference between a score and a

performance of that score or a class and an instance of that class. All objects respond to this interface,

most by returning themselves. So most objects are patterns that define streams that are an infinite

sequence of the object and embed as singleton streams of that object returned once.

Patterns are defined in terms of other Patterns rather than in terms of specific

values. This allows a Pattern of arbitrary complexity to be substituted for a

single value anywhere within a Pattern definition. A comparison between a Stream

definition and a Pattern will help illustrate the usefulness of Patterns.

example 1 - Pseq vs. Routine

The Pattern class Pseq(array, repetitions) defines a Pattern that will create a Stream that iterates

an array. The class Routine(func, stackSize) defines a single Stream, the function that runs within

that stream is defined to perform the array iteration.

Below a stream is created with Pseq and an asStream message and an identical stream is

created directly using Routine.

// a Routine vs a Pattern

(

a = [-100, 00, 300, 400]; // the array to iterate

p = Pseq(a); // make the Pattern

q = p.asStream; // have the Pattern make a Stream

r = Routine({ a.do({ arg v; v.yield}) }) ; // make the Stream directly

5.do({ Post << Char.tab << r.next << " " << q.next << Char.nl; });

)

example 2 - Nesting patterns

In example 1, there is little difference between using Pseq and Routine. But Pseq actually

iterates its array as a collection of patterns to be embedded, allowing another Pseq to replace any

of the values in the array. The Routine, on the other hand, needs to be completely

redefined.

(

var routinesA;

a = [3, Pseq([-100, 00, 300, 400]), Pseq([-100, 00, 300, 400].reverse) ];

routinesA = [[3], [-100, 00, 300, 400], [-100, 00, 300, 400].reverse];

p = Pseq(a);

q = p.asStream;

r = Routine({

routinesA.do({ arg v;

v.do({ arg i; i.yield})

}) ;

});

10.do({ Post << Char.tab << r.next << " " << q.next << Char.nl; });

)

example 3 - Stream-embedInStream

The message embedInStream is what allows Patterns to do this kind of nesting. Most objects

(such as the number 3 below) respond to embedInStream by yielding themselves once and returning.

Streams respond to embedInStream by iterating themselves to completion, effectively "taking over" the

calling stream for that time.

A Routine can perform a pattern simply by replacing calls to yield with calls to embedInStream.

(

a = [3, Pseq([-100, 00, 300, 400]), Pseq([-100, 00, 300, 400].reverse) ];

r = Routine({ a.do({ arg v; v.embedInStream}) }) ;

p = Pseq(a);

q = p.asStream;

10.do({ Post << Char.tab << r.next << " " << q.next << Char.nl; });

)

Of course, there is no concise way to define this stream without using Pseq.

note: For reasons of efficiency, the implementation of embedInStream assumes that it is called from

within a Routine. Consequently, embedInStream should never be called from within the function that

defines a FuncStream or a Pfunc (the pattern that creates FuncStreams).

Event Patterns

An Event is a Environment with a 'play' method. Typically, an Event consists of

a collection of key/value pairs that determine what the play method actually does.

The values may be any object including functions defined in terms of other named attributes.

Changing those values can generate a succession of sounds sometimes called 'music'...

The pattern Pbind connects specific patterns with specific names. Consult its help page for

details.

Playing Event Patterns

play(clock, protoEvent, quant)

clock - The tempo clock that will run the pattern. If omitted, TempoClock.default is used.

protoEvent - The event prototype that will be fed into the pattern stream on each iteration. If omitted, event.default is used.

quant - see the Quant helpfile

The play method does not return the pattern itself. Instead, it returns the EventStreamPlayer object that actually runs the pattern. Control instructions -- stop, pause, resume, play, reset -- should be addressed to the EventStreamPlayer. (The same pattern can play many times simultaneously, using different EventStreamPlayers.)

p = Pbind(...);

p.play;

p.stop; // does not stop because p is not the EventStreamPlayer that is actually playing

p = Pbind(...).play;

p.stop; // DOES stop because p is the EventStreamPlayer

Recording Event Patterns

Patterns may be recorded in realtime or non-realtime.

Realtime:

record(path, headerFormat, sampleFormat, numChannels, dur, fadeTime, clock, protoEvent, server, out)

Opens a disk file for recording and plays the pattern into it.

path - Disk location for the recorded file. If not given, a filename is generated for you and placed in the default recording directory: thisProcess.platform.recordingsDir.

headerFormat - File format, default "AIFF" - see SoundFile for supported header and sample formats.

sampleFormat - Sample format, default "float"

numChannels - Number of channels to recorde, default 2

dur - How long to run the pattern before stopping. If nil (default), the pattern will run until it finishes on its own; then recording stops. Or, use cmd-period to stop the recording. If a number is given, the pattern will run for that many beats and then stop (using Pfindur), ending the recording as well.

fadeTime - How many beats to allow after the last event before stopping the recording. Default = 0.2.

clock - Which clock to use for play. Uses TempoClock.default if not otherwise specified.

protoEvent - Which event prototype to use for play. Falls back to Event.default if not otherwise specified.

server - Which server to play and record. Server.default if not otherwise specified.

out - Output bus to hear the pattern while recording, default = 0.

Non-realtime: See the Score helpfile, especially "creating Score from a pattern." It can be tricky, because NRT recording launches a new server instance. That server instance is not aware of buffers or other resources loaded into the realtime server you might have been using for tests. The pattern is responsible for (re)loading any resources (buffers, effects etc.). Pfset or Pproto may be useful.

A Summary of Pattern classes

Below are brief examples for most of the classes derived from Pattern. These examples

all rely on the patterns assigned to the Interpreter variable p, q, and r in the first block of code.

(

SynthDef(\cfstring1.postln, { arg i_out, freq = 360, gate = 1, pan, amp=0.1;

var out, eg, fc, osc, a, b, w;

fc = LinExp.kr(LFNoise1.kr(Rand(0.25, 0.4)), -1, 1, 500, 2000);

osc = Mix.fill(8, {LFSaw.ar(freq * [Rand(0.99, 1.01), Rand(0.99, 1.01)], 0, amp) }).distort * 0.2;

eg = EnvGen.kr(Env.asr(1, 1, 1), gate, doneAction:2);

out = eg * RLPF.ar(osc, fc, 0.1);

#a, b = out;

Out.ar(i_out, Mix.ar(PanAz.ar(4, [a, b], [pan, pan+0.3])));

}).add;

SynthDef("sinegrain2",

{ arg out=0, freq=440, sustain=0.05, pan;

var env;

env = EnvGen.kr(Env.perc(0.01, sustain, 0.3), doneAction:2);

Out.ar(out, Pan2.ar(SinOsc.ar(freq, 0, env), pan))

}).add;

p = Pbind(

[\degree, \dur], Pseq([[0, 0.1], [2, 0.1], [3, 0.1], [4, 0.1], [5, 0.8]], 1),

\amp, 0.05, \octave, 6, \instrument, \cfstring1, \mtranspose, 0);

q = Pbindf(p, \instrument, \default );

r = Pset(\freq, Pseq([500, 600, 700], 2), q);

)

// EVENT PATTERNS - patterns that generate or require event streams

// Pbind( ArrayOfPatternPairs )

p = Pbind(

[\degree, \dur], Pseq([[0, 0.1], [2, 0.1], [3, 0.1], [4, 0.1], [5, 0.8]], 1),

\amp, 0.05, \octave, 6, \instrument, \cfstring1, \mtranspose, 0);

p.play;

//Ppar(arrayOfPatterns, repeats) - play in parallel

Ppar([Pseq([p], 4), Pseq([Pbindf(q, \ctranspose, -24)], 5)]).play

//Ptpar(arrayOfTimePatternPairs, repeats) - play in parallel at different times

Ptpar([1, Pseq([p], 4), 0, Pseq([Pbindf(q, \ctranspose, -24)], 5)]).play

// Pbindf( pattern, ArrayOfNamePatternPairs )

q = Pbindf(p, \instrument, \default );

q.play;

//Pfset(function, pattern)

// function constructs an event that is passed to the pattern.asStream

Pfset({ ~freq = Pseq([500, 600, 700], 2).asStream }, q).play;

//Pset(name, valPattern, pattern)

// set one field of the event on an event by event basis (Pmul, Padd are similar)

Pset(\freq, Pseq([500, 600, 700], 2), q).play;

//Psetp(name, valPattern, pattern)

// set once for each iteration of the pattern (Pmulp, Paddp are similar)

r = Pset(\freq, Pseq([500, 600, 700], 2), q);

Psetp(\legato, Pseq([0.01, 1.1], inf), r).play;

//Psetpre(name, valPattern, pattern)

// set before passing the event to the pattern (Pmulpre, Paddpre are similar)

r = Psetpre(\freq, Pseq([500, 600, 700], 2), q);

Psetp(\legato, Pseq([0.01, 1.1], inf), r).play;

//Pstretch(valPattern, pattern)

// stretches durations after

r = Psetpre(\freq, Pseq([500, 600, 700], 2), q);

Pstretch(Pn(Env([0.5, 2, 0.5], [10, 10])), Pn(r)).play;

Pset(\stretch, Pn(Env([0.5, 2, 0.5], [10, 10]) ), Pn(r)).play

//Pstretchp(valPattern, pattern)

// stretches durations after

r = Psetpre(\freq, Pseq([500, 600, 700], 2), q);

Pstretchp(Pn(Env([0.5, 2, 0.5], [10, 10])), r).play;

// Pfindur( duration, pattern ) - play pattern for duration

Pfindur(2, Pn(q, inf)).play;

// PfadeIn( pattern, fadeTime, holdTime, tolerance )

PfadeIn(Pn(q), 3, 0).play(quant: 0);

// PfadeOut( pattern, fadeTime, holdTime, tolerance )

PfadeOut(Pn(q), 3, 0).play(quant: 0);

// Psync( pattern, quantization, dur, tolerance )

// pattern is played for dur seconds (within tolerance), then a rest is played so the next pattern

Pn(Psync(

Pbind( \dur, Pwhite(0.2, 0.5).round(0.2),

\db, Pseq([-10, -15, -15, -15, -15, -15, -30])

), 2, 3

)).play

//Plag(duration, pattern)

Ppar([Plag(1.2, Pn(p, 4)), Pn(Pbindf(q, \ctranspose, -24), 5)]).play

// GENERAL PATTERNS that work with both event and value streams

//Ptrace(pattern, key, printStream) - print the contents of a pattern

r = Psetpre(\freq, Pseq([500, 600, 700], 2), q);

Ptrace(r).play;

Ptrace(r, \freq).play;

(

{ var printStream;

printStream = CollStream.new;

Pseq([Ptrace(r, \freq, printStream), Pfunc({printStream.collection.dump; nil }) ]).play;

}.value;

)

//Pseed(seed, pattern) - set the seed of the random number generator

// to force repetion of pseudo-random patterns

Pn(Pseed(44, Pbindf(q, \ctranspose, Pbrown(-3.0, 3.0, 10) ) ) ).play;

//Proutine(function) - on exit, the function must return the last value returned by yield

// (otherwise, the pattern cannot be reliably manipulated by other patterns)

Proutine({ arg inval;

inval = p.embedInStream(inval);

inval = Event.silent(4).yield;

inval = q.embedInStream(inval);

inval = r.embedInStream(inval);

inval;

}).play

//Pfunc(function) - the function should not have calls to embedInStream, use Proutine instead.

Pn(Pbindf(q, \legato, Pfunc({ arg inval; if (inval.at(\degree)== 5) {4} {0.2}; })) ).play

// the following patterns control the sequencing and repetition of other patterns

//Pseq(arrayOfPatterns, repeats) - play as a sequence

Pseq([Pseq([p], 4), Pseq([Pbindf(q, \ctranspose, -24)], 5)]).play

//Pser(arrayOfPatterns, num) - play num patterns from the arrayOfPatterns

Pser([p, q, r], 5).play

//Place(arrayOfPatterns, repeats) - similar to Pseq

// but array elements that are themselves arrays are iterated

// embedding the first element on the first repetition, second on the second, etc

Place([[p, q, r], q, r], 5).play

// Pn( pattern, patternRepetitions ) - repeat the pattern n times

Pn(p, 2).play;

// Pfin( eventcount, pattern ) - play n events from the pattern

Pfin(12, Pn(p, inf)).play;

// Pstutter( eventRepetitions, pattern ) - repeat each event from the pattern n times

Pstutter(4, q).play

//Pwhile(function, pattern)

Pwhile({coin(0.5).postln;}, q).play

// Pswitch( patternList, selectPattern ) - when a pattern ends, switch according to select

Pswitch([p, q, r], Pwhite(0, 100)).play

// Pswitch1( patternList, selectPattern ) - on each event switch according to select

Pn(Pswitch1([p, q, r], Pwhite(0, 2))).play

// Prand( patternList, repeats ) - random selection from list

Prand([p, q, r], inf).play

// Pxrand( patternList, repeats ) - random selection from list without repeats

Pxrand([p, q, r], inf).play

// Pwrand( patternList, weights, repeats ) - weighted random selection from list

Pwrand([p, q, r], #[1, 3, 5].normalizeSum, inf).play

// Pwalk( patternList, stepPattern, directionPattern ) - walk through a list of patterns

Pwalk([p, q, r], 1, Pseq([-1, 1], inf)).play

// Pslide(list, repeats, length, step, start)

Pbind(\degree, Pslide(#[1, 2, 3, 4, 5], inf, 3, 1, 0), \dur, 0.2).play

// Pshuf( patternList, repeats ) - random selection from list

Pn(Pshuf([p, q, r, r, p])).play

// Ptuple(list, repeats)

Pbind(\degree, Ptuple([Pwhite(1, -6), Pbrown(8, 15, 2)]),

\dur, Pfunc({ arg ev; ev.at(\degree).last/80 round: 0.1}),

\db, Pfunc({ if (coin(0.8)) {-25} {-20} })

).play

// the following patterns can alter the values returned by other patterns

//Pcollect(function, pattern)

Pcollect({ arg inval; inval.use({ ~freq = 1000.rand }); inval}, q).play

//Pselect(function, pattern)

Pselect({ arg inval; inval.at(\degree) != 0 }, q).play(quant: 0)

//Preject(function, pattern)

Preject({ arg inval; inval.at(\degree) != 0 }, q).play(quant: 0)

//Ppatmod(pattern, function, repeats) -

// function receives the current pattern as an argument and returns the next pattern to be played

Ppatmod(p, { arg oldPat; [p, q, r].choose }, inf).play

// VALUE PATTERNS: these patterns define or act on streams of numbers

// Env as a pattern

Pbindf(Pn(q, inf), \ctranspose, Pn(Env.linen(3, 0, 0.3, 20), inf) ).play;

// Pwhite(lo, hi, length)

Pbindf(Pn(q, inf), \ctranspose, Pwhite(-3.0, 3.0) ).play;

// Pbrown(lo, hi, step, length)

Pbindf(Pn(q, inf), \ctranspose, Pbrown(-3.0, 3.0, 2) ).play;

// Pseries(start, step, length)

Pbindf(Pn(q, inf), \ctranspose, Pseries(0, 0.1, 10) ).play;

// Pgeom(start, step, length)

Pbindf(Pn(q, inf), \ctranspose, Pgeom(1, 1.2, 20) ).play;

// Pwrap(pattern, lo, hi)

Pbind(\note, Pwrap(Pwhite(0, 128), 10, 20).round(2), \dur, 0.05).play;

// PdegreeToKey(pattern, scale, stepsPerOctave)

// this reimplements part of pitchEvent (see Event)

Pbindf(Pn(q, inf), \note, PdegreeToKey(Pbrown(-8, 8, 2), [0, 2, 4, 5, 7, 9, 11]) ).play;

// Prewrite(pattern, dict, levels) - see help page for details.

// (notice use of Env to define a chord progression of sorts...

Pbind(\degree,

Prewrite(0, ( 0: #[2, 0],

1: #[0, 0, 1],

2: #[1, 0, 1]

), 4

) + Pn(Env([4, 0, 1, 4, 3, 4], [6.4, 6.4, 6.4, 6.4, 6.4], 'step')),

\dur, 0.2).play

// PdurStutter( repetitionPattern, patternOfDurations ) -

Pbindf(Pn(q), \dur, PdurStutter(

Pseq(#[1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 4, 5, 7, 15], inf),

Pseq(#[0.5], inf)

)

).play;

// Pstep2add( pat1, pat2 )

// Pstep3add( pat1, pat2, pat3 )

// PstepNadd(pat1, pat2, ...)

// PstepNfunc(function, patternArray )

// combine multiple patterns with depth first traversal

Pbind(

\octave, 4,

\degree, PstepNadd(

Pseq([1, 2, 3]),

Pseq([0, -2, [1, 3], -5]),

Pshuf([1, 0, 3, 0], 2)

),

\dur, PstepNadd(

Pseq([1, 0, 0, 1], 2),

Pshuf([1, 1, 2, 1], 2)

).loop * (1/8),

\legato, Pn(Pshuf([0.2, 0.2, 0.2, 0.5, 0.5, 1.6, 1.4], 4), inf),

\scale, #[0, 1, 3, 4, 5, 7, 8]

).play;