# Continuous Signals

Signals are patterns with continuous values, meaning they have theoretically infinite steps. They can provide streams of numbers that can be sampled at discrete points in time.

## saw

A sawtooth signal between 0 and 1.

`"c3 [eb3,g3] g2 [g3,bb3]".legato(saw.slow(4)).note()`
`saw.range(0,8).segment(8).scale('C major').slow(4).note()`

## sine

A sine signal between 0 and 1.

`sine.segment(16).range(0,15).slow(2).scale('C minor').note()`

## cosine

A cosine signal between 0 and 1.

`stack(sine,cosine).segment(16).range(0,15).slow(2).scale('C minor').note()`

## tri

A triangle signal between 0 and 1.

`tri.segment(8).range(0,7).scale('C minor').note()`

## square

A square signal between 0 and 1.

`square.segment(2).range(0,7).scale('C minor').note()`

## Ranges from -1 to 1

There is also `saw2`, `sine2`, `cosine2`, `tri2` and `square2` which have a range from -1 to 1!

## rand

A continuous pattern of random numbers, between 0 and 1.

```// randomly change the cutoff
s("bd sd,hh*4").cutoff(rand.range(500,2000))```

## perlin

Generates a continuous pattern of perlin noise, in the range 0..1.

```// randomly change the cutoff
s("bd sd,hh*4").cutoff(perlin.range(500,2000))```

## irand

A continuous pattern of random integers, between 0 and n-1.

• n (number): max value (exclusive)
```// randomly select scale notes from 0 - 7 (= C to C)
irand(8).struct("x(3,8)").scale('C minor').note()```

# Random Modifiers

## chooseCycles

Picks one of the elements at random each cycle.

`chooseCycles("bd", "hh", "sd").s().fast(4)`
`"bd | hh | sd".s().fast(4)`

Randomly removes events from the pattern by a given amount. 0 = 0% chance of removal 1 = 100% chance of removal

• amount (number): a number between 0 and 1
`s("hh*8").degradeBy(0.2)`
`s("[hh?0.2]*8")`

Randomly removes 50% of events from the pattern. Shorthand for `.degradeBy(0.5)`

`s("hh*8").degrade()`
`s("[hh?]*8")`

Inverse of Pattern#degradeBy: Randomly removes events from the pattern by a given amount. 0 = 100% chance of removal 1 = 0% chance of removal Events that would be removed by degradeBy are let through by undegradeBy and vice versa (see second example).

• amount (number): a number between 0 and 1
`s("hh*8").undegradeBy(0.2)`

## sometimesBy

Randomly applies the given function by the given probability. Similar to Pattern#someCyclesBy

• probability (number|Pattern): a number between 0 and 1
• function (function): the transformation to apply
`s("hh(3,8)").sometimesBy(.4, x=>x.speed("0.5"))`

## sometimes

Applies the given function with a 50% chance

• function (function): the transformation to apply
`s("hh*4").sometimes(x=>x.speed("0.5"))`

## someCyclesBy

Randomly applies the given function by the given probability on a cycle by cycle basis. Similar to Pattern#sometimesBy

• probability (number|Pattern): a number between 0 and 1
• function (function): the transformation to apply
`s("hh(3,8)").someCyclesBy(.3, x=>x.speed("0.5"))`

## someCycles

Shorthand for `.someCyclesBy(0.5, fn)`

`s("hh(3,8)").someCycles(x=>x.speed("0.5"))`

## often

Shorthand for `.sometimesBy(0.75, fn)`

`s("hh*8").often(x=>x.speed("0.5"))`

## rarely

Shorthand for `.sometimesBy(0.25, fn)`

`s("hh*8").rarely(x=>x.speed("0.5"))`

## almostNever

Shorthand for `.sometimesBy(0.1, fn)`

`s("hh*8").almostNever(x=>x.speed("0.5"))`

## almostAlways

Shorthand for `.sometimesBy(0.9, fn)`

`s("hh*8").almostAlways(x=>x.speed("0.5"))`

## never

Shorthand for `.sometimesBy(0, fn)` (never calls fn)

`s("hh*8").never(x=>x.speed("0.5"))`

## always

Shorthand for `.sometimesBy(1, fn)` (always calls fn)

`s("hh*8").always(x=>x.speed("0.5"))`

Next up: Conditional Modifiers