Tutorial 15: Patterns Generators Reference

There are several other Pattern classes in FoxDot that help you generate arrays of numbers but also behave in the same way as the base Pattern. To see what Patterns exist and have a go at using them, execute

print(classes(Patterns.Sequences))

PEuclid

PEuclid(n, k)

Returns the Euclidean rhythm which spreads 'n' pulses over 'k' steps as evenly as possible.

# 3 pulses over 8 steps
print(PEuclid(3, 8))

PDur

PDur(n, k, start=0, dur=0.25)

Returns the actual durations based on Euclidean rhythms (see PEuclid) where dur is the length of each step. Spreads 'n' pulses over 'k' steps as evenly as possible

print(PDur(3,8)) # P[0.75, 0.75, 0.5]

print(PDur(5,8))

# Gives a list of 3 dur, appened with a list of 5 dur
print(PDur([3,5],8))

d1 >> play("x", dur=PDur(5,8))

PIndex

Returns the index being accessed

print(PIndex())
print(PIndex()*4)

PSine

PSine(n=16)

Returns values of one cycle of sine wave split into 'n' parts

# Split into 5 parts
print(PSine(5))

# Split into 10
print(PSine(10))

PTri

PTri(start, stop=None, step=None)

Returns a Pattern equivalent to Pattern(range(start, stop, step)) with its reversed form appended. Think of it like a "Tri"angle.

# Up to 5 then down to 1
print(PTri(5))

# Up to 8 then down to 1
print(PTri(8))

# From 3 to 10, then down to 4
print(PTri(3,10))

# From 3 to 30, by 2, then down to 4
print(PTri(3,20,2))

# Up to 4, then down to 1, then up to 8, then down to 1
print(PTri([4,8]))

p1 >> pluck(PTri(5), scale=Scale.default.pentatonic)

# Same as
p1 >> pluck(PRange(5) | PRange(5,0,-1), scale=Scale.default.pentatonic)

PRand

PRand(start, stop=None)

Returns a random integer between start and stop.

# Returns a random integer between 0 and start.
print(PRand(8)[:5])

# Returns a random integer between start and stop.
print(PRand(8,16)[:5])

# If start is a container-type it returns a random item for that container.
print(PRand([1,2,3])[:5])

# You can supply a seed
print(PRand([1,2,3], seed=5)[:5])

# Keeps generating random tune
p1 >> pluck(PRand(8))

# Creates a random list, and iterates over that same list
p1 >> pluck(PRand(8)[:3])

PRhythm

PRhythm takes a list of single durations and tuples that contain values that can be supplied to the PDur

The following plays the hi hat with a Euclidean Rhythm of 3 pulses in 8 steps

d1 >> play("x-o-", dur=PRhythm([2,(3,8)]))

print(PRhythm([2,(3,8)]))

PSum

PSum(n, total)

Returns a Pattern of length 'n' that sums to equal 'total'

# Returns a pattern of length 2, with elements summed up to 8
print(PSum(3,8))

# Returns a pattern of length 5, with elements summed up to 4
print(PSum(5,4))

PStep

PStep(n, value, default=0)

Returns a Pattern that every n-term is 'value' otherwise 'default'

# Every 4, make it 1, otherwise default to 0
print(PStep(4,1))

# Every 8, make it 6, otherwise, 4
print(PStep(8,6,4))

# Every 5, make it 2, otherwise, 1
print(PStep(5,2,1))

PWalk

PWalk(max=7, step=1, start=0)

By default, returns a pattern with each element randomly 1 higher or lower than the previous

print(PWalk()[:16])

# Changing step
print(PWalk(step=2)[:16])

# With max
print(PWalk(max=2)[:16])

# Start at a non-zero number
print(PWalk(start=6)[:16])

PWhite

PWhite(lo=0, hi=1)

Returns random floating point values between 'lo' and 'hi'

# Lo defaults to 0, hi defaults to 1
print(PWhite()[:8])

# Returns random numbers between 1 and 5
print(PWhite(1,5)[:8])

Custom Generator Patterns

Custom generator patterns can be made by subclassing GeneratorPattern and overriding GeneratorPattern.func

class CustomGeneratorPattern(GeneratorPattern):
    def func(self, index):
        return int(index / 4)

print(CustomGeneratorPattern()[:10])

This can be done more consisely using GeneratorPattern.from_func, passing in a function which takes an index and returns some pattern item.

def some_func(index):
    return int(index / 4)

print(GeneratorPattern.from_func(some_func)[:10])

We can use lambdas too

print(GeneratorPattern.from_func(lambda index: int(index / 4))[:10])