# 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...`

``` python
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

``` python
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:

``` python
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.
``` python
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.

``` python
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

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

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

Vars can be named ...

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

And used later

``` python
b1 >> pluck(var.chords)
```

Any players using the named var will be updated

``` python
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

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

Run this multiple times to see the changes happening

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

Change the amp based off that linvar

``` python
p1 >> pads(a, amp=c)
```

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

``` python
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

``` python
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`

``` python
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:

``` python
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

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

Other types include "sinvar" and "expvar"

``` python
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:

``` python
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

``` python
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

``` python
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:

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