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

                These methods add random behavior to your Patterns.

                chooseCycles

                Picks one of the elements at random each cycle.

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

                  degradeBy

                  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")

                  degrade

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

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

                    undegradeBy

                    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