195 lines
5.3 KiB
Markdown
195 lines
5.3 KiB
Markdown
# Randomness
|
|
|
|
Music needs surprise. A pattern that plays identically every time gets boring fast. Cagire has a rich set of words for injecting randomness and controlled variation into your sequences.
|
|
|
|
## Random Numbers
|
|
|
|
`coin` pushes 0 or 1 with equal probability:
|
|
|
|
```forth
|
|
;; sometimes, reverb
|
|
sine sound
|
|
( 0.5 verb ) coin ?
|
|
1 decay
|
|
.
|
|
```
|
|
|
|
`rand` takes a range and returns a random value. If both bounds are integers, the result is an integer. If either is a float, you get a float:
|
|
|
|
```forth
|
|
60 72 rand note sine snd 0.5 decay . ;; random MIDI note from 60 to 72
|
|
0.3 0.9 rand gain sine snd 0.5 decay . ;; random gain between 0.3 and 0.9
|
|
```
|
|
|
|
`exprand` and `logrand` give you weighted distributions. `exprand` is biased toward the low end, `logrand` toward the high end:
|
|
|
|
```forth
|
|
200.0 8000.0 exprand freq sine snd 0.5 decay . ;; mostly low frequencies
|
|
200.0 8000.0 logrand freq sine snd 0.5 decay . ;; mostly high frequencies
|
|
```
|
|
|
|
These are useful for parameters where perception is logarithmic, like frequency and duration.
|
|
|
|
## Conditional Execution
|
|
|
|
The probability words take a quotation and execute it with some chance. `chance` takes a float from 0.0 to 1.0, `prob` takes a percentage from 0 to 100:
|
|
|
|
```forth
|
|
( hat snd . ) 0.25 chance ;; 25% chance
|
|
( kick snd . ) 75 prob ;; 75% chance
|
|
```
|
|
|
|
Named probability words save you from remembering numbers:
|
|
|
|
| Word | Probability |
|
|
|------|------------|
|
|
| `always` | 100% |
|
|
| `almostAlways` | 90% |
|
|
| `often` | 75% |
|
|
| `sometimes` | 50% |
|
|
| `rarely` | 25% |
|
|
| `almostNever` | 10% |
|
|
| `never` | 0% |
|
|
|
|
```forth
|
|
( hat snd . ) often ;; 75%
|
|
( snare snd . ) sometimes ;; 50%
|
|
( clap snd . ) rarely ;; 25%
|
|
```
|
|
|
|
`always` and `never` are useful when you want to temporarily mute or unmute a voice without deleting code. Change `sometimes` to `never` to silence it, `always` to bring it back.
|
|
|
|
Use `?` and `!?` with `coin` for quick coin-flip decisions:
|
|
|
|
```forth
|
|
( hat snd . ) coin ? ;; execute if coin is 1
|
|
( rim snd . ) coin !? ;; execute if coin is 0
|
|
```
|
|
|
|
## Selection
|
|
|
|
`choose` picks randomly from n items on the stack:
|
|
|
|
```forth
|
|
kick snare hat 3 choose snd . ;; random drum hit
|
|
60 64 67 72 4 choose note sine snd 0.5 decay . ;; random note from a set
|
|
```
|
|
|
|
When a chosen item is a quotation, it gets executed:
|
|
|
|
```forth
|
|
( 0.1 decay ) ( 0.5 decay ) ( 0.9 decay ) 3 choose
|
|
sine snd .
|
|
```
|
|
|
|
`wchoose` lets you assign weights to each option. Push value/weight pairs:
|
|
|
|
```forth
|
|
kick 0.5 snare 0.3 hat 0.2 3 wchoose snd .
|
|
```
|
|
|
|
Kick plays 50% of the time, snare 30%, hat 20%. Weights don't need to sum to 1 -- they're normalized automatically.
|
|
|
|
`shuffle` randomizes the order of n items on the stack:
|
|
|
|
```forth
|
|
60 64 67 72 4 shuffle ;; stack now has the same 4 values in random order
|
|
```
|
|
|
|
Combined with `note`, this gives you a random permutation of a chord every time the step runs.
|
|
|
|
## Periodic Execution
|
|
|
|
`every` runs a quotation once every n pattern iterations:
|
|
|
|
```forth
|
|
( crash snd . ) 4 every ;; crash cymbal every 4th iteration
|
|
```
|
|
|
|
`except` is the inverse -- it runs a quotation on all iterations *except* every nth:
|
|
|
|
```forth
|
|
( 2 distort ) 4 except ;; distort on all iterations except every 4th
|
|
```
|
|
|
|
`every+` and `except+` take an extra offset argument to shift the phase:
|
|
|
|
```forth
|
|
( snare snd . ) 4 2 every+ ;; fires at iter 2, 6, 10, 14...
|
|
( snare snd . ) 4 2 except+ ;; skips at iter 2, 6, 10, 14...
|
|
```
|
|
|
|
Without the offset, `every` fires at 0, 4, 8... The offset shifts that by 2, so it fires at 2, 6, 10... This lets you interleave patterns that share the same period:
|
|
|
|
```forth
|
|
( kick snd . ) 4 every ;; kick at 0, 4, 8...
|
|
( snare snd . ) 4 2 every+ ;; snare at 2, 6, 10...
|
|
```
|
|
|
|
`bjork` and `pbjork` use Bjorklund's algorithm to distribute k hits across n positions as evenly as possible. Classic Euclidean rhythms:
|
|
|
|
```forth
|
|
( hat snd . ) 3 8 bjork ;; tresillo: x..x..x. (by step runs)
|
|
( hat snd . ) 5 8 pbjork ;; cinquillo: x.xx.xx. (by pattern iterations)
|
|
```
|
|
|
|
`bjork` counts by step runs (how many times this particular step has played). `pbjork` counts by pattern iterations. Some classic patterns:
|
|
|
|
| k | n | Name |
|
|
|---|---|------|
|
|
| 3 | 8 | tresillo |
|
|
| 5 | 8 | cinquillo |
|
|
| 5 | 16 | bossa nova |
|
|
| 7 | 16 | samba |
|
|
|
|
## Seeding
|
|
|
|
By default, every run produces different random values. Use `seed` to make randomness reproducible:
|
|
|
|
```forth
|
|
42 seed
|
|
60 72 rand note sine snd . ;; always the same "random" note
|
|
```
|
|
|
|
The seed is set at the start of the script. Same seed, same sequence. Useful when you want a specific random pattern to repeat.
|
|
|
|
## Combining Words
|
|
|
|
The real power comes from mixing techniques. A hi-hat pattern with ghost notes:
|
|
|
|
```forth
|
|
hat snd
|
|
( 0.3 0.6 rand gain ) ( 0.8 gain ) 2 cycle
|
|
.
|
|
```
|
|
|
|
Full volume on even runs, random quiet on odd runs.
|
|
|
|
A bass line that changes every 4 bars:
|
|
|
|
```forth
|
|
( c2 note ) ( e2 note ) ( g2 note ) ( a2 note ) 4 pcycle
|
|
( 0.5 decay ) often
|
|
sine snd .
|
|
```
|
|
|
|
Layered percussion with different densities:
|
|
|
|
```forth
|
|
( kick snd . ) always
|
|
( snare snd . ) 2 every
|
|
( hat snd . ) 5 8 bjork
|
|
( rim snd . ) rarely
|
|
```
|
|
|
|
A melodic step with weighted note selection and random timbre:
|
|
|
|
```forth
|
|
c4 0.4 e4 0.3 g4 0.2 b4 0.1 4 wchoose note
|
|
0.3 0.7 rand decay
|
|
1.0 4.0 exprand harmonics
|
|
add snd .
|
|
```
|
|
|
|
The root note plays most often. Higher chord tones are rarer. Decay and harmonics vary continuously.
|