Tutorial 10: Using Vars

A TimeVar is an abbreviation of "Time Dependent Variable" and is a key feature of FoxDot. A TimeVar has a series of values that it changes between after a pre-defined number of beats and is created using a var object with the syntax var([list_of_values],[list_of_durations]).

Generates the values: 0,0,0,0,3,3,3,3...

a = var([0,3],4)            # Duration can be single value
print(int(Clock.now()), a)  # 'a' initally has a value of 0
# >>> 0, 0                  # The first value may differ...

print(int(Clock.now()), a)   # After 4 beats, the value changes to 3
# >>> 4, 3

print(int(Clock.now()), a)   # After another 4 beats, the value changes to 0
# >>> 8, 0

Duration can also be a list

a = var([0,3],[4,2])
print(int(Clock.now()), a)

When a TimeVar is used in a mathematical operation, the values it affects also become TimeVars that change state when the original TimeVar changes state – this can even be used with patterns:

a = var([0,3], 4)
print(int(Clock.now()), a + 5)   # When beat is 0, a is 5
# >>> 5

print(int(Clock.now()), a + 5)   # When beat is 4, a is 8
# >>> 8

b = PRange(4) + a
print(int(Clock.now()), b)   # After 8 beats, the value changes to 0
# >>> P[0, 1, 2, 3]

print(int(Clock.now()), b)   # After 12 beats, the value changes to 3
# >>> P[3, 4, 5, 6]

Use 'var' with your Player objects to create chord progressions.

a = var([0,4,5,3], 4)
b1 >> bass(a, dur=PDur(3,8))
p1 >> pads(a + (0,2), dur=PDur(7,16))

You can add a 'var' to a Player object or a var.

b1 >> bass(a, dur=PDur(3,8)) + var([0,1],[3,1])

b = a + var([0,10],8)

print(int(Clock.now()), (a, b))

Updating the values of one 'var' will update it everywhere else

a.update([1,4], 8)

print(int(Clock.now()), (a, b))

Vars can be named ...

var.chords = var([0,4,5,4],4)

And used later

b1 >> pluck(var.chords)

Any players using the named var will be updated

var.chords = var([0,1,5,3],4)

You can also use a linvar that changes its values gradually over time Change the value from 0 to 1 over 16 beats

c = linvar([0,1],16)

Run this multiple times to see the changes happening

print(int(Clock.now()), c)

Change the amp based off that linvar

p1 >> pads(a, amp=c)

a Pvar is a var that can store patterns (as opposed to say, integers)

d = Pvar([P[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], P[0, 1, 2, 3, 4, 5, 4, 3, 2, 1]], 8)

print(int(Clock.now()), d)

p1 >> pads(a, amp=c, dur=1/4) + d

Change the scale every 16 beats

Scale.default = Pvar([Scale.major, Scale.minor],16)

You even set the value to last forever once it is reached using a special value called inf

x = var([0, 1, 2, 3], [4, 4, 4, inf])

print(x) # Keep pressing - it will eventually stop at 3

Other types of "var"

There are several sub-classes of "var" that return values between the numbers specified. For example a "linvar" gradually change values in a linear fashion:

print(linvar([0,1],8)) # keep running to see the value change between 0 and 1

Example: increase the high-pass filter cutoff over 32 beats

p1 >> play("x-o-", hpf=linvar([0,4000],[32,0]))

Other types include "sinvar" and "expvar"

print("Linear:", linvar([0, 1], 8))
print("Sinusoidal:", sinvar([0, 1], 8))
print("Exponential:", expvar([0, 1], 8))

Pattern TimeVar

Sometimes we might want to store whole patterns within a var but if we try to do so, they are automatically laced:

pattern1 = P[0, 1, 2, 3]
pattern2 = P[4, 5, 6, 7]

print(var([pattern1, pattern2], 4))

To store whole patterns, you need to use a Pvar which does not lace the values, but stores the patterns instead

print(Pvar([pattern1, pattern2], 4))

p1 >> pluck(Pvar([pattern1, pattern2], 4), dur=1/4)

Offsetting the start time

Another useful trick is offsetting the start time for the var. By default it is when the Clock time is 0 but you can specify a different value using the "start" keyword

print(linvar([0, 1], 8))
print(linvar([0, 1], 8, start=2))

This can be combined with Clock.mod() to start a ramp at the start of the next 32 beat cycle:

d1 >> play("x-o-", hpf=linvar([0,4000],[32,inf], start=Clock.mod(32)))