Packages

package ugen

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. Protected

Package Members

  1. package impl

Type Members

  1. final case class A2K(in: GE) extends SingleOut with ControlRated with Product with Serializable

    A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling.

    A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling. The sample is always taken at the beginning of each control-block, while all other samples of the audio-rate input within that block are ignored.

    in

    audio-rate signal to convert

    See also

    K2A

    T2K

  2. final case class APF(rate: MaybeRate, in: GE, freq: GE = 440.0f, radius: GE = 0.8f) extends SingleOut with Product with Serializable
  3. final case class AllpassC(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable

    All pass delay line with cubic interpolation.

    All pass delay line with cubic interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    AllpassN

    AllpassL

  4. final case class AllpassL(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable

    All pass delay line with linear interpolation.

    All pass delay line with linear interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    AllpassN

    AllpassC

  5. final case class AllpassN(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable

    All pass delay line with no interpolation.

    All pass delay line with no interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    AllpassL

    AllpassC

  6. final case class AmpComp(rate: Rate, freq: GE = 261.626f, root: GE = 261.626f, expon: GE = 0.3333f) extends SingleOut with Product with Serializable

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.

    Implements the formula: (root / freq).pow(exp)

    Higher frequencies are normally perceived as louder, therefore AmpComp outputs lower values for them. For example, with default parameters, the pitch C4 (frequency 262 Hz) produces the base factor of 1.0, whereas a pitch one octave up, C5 (or 523 Hz) produces a factor of 0.793719 (an attenuation of -2 dB).

    An alternative is AmpCompA that better models the bell-shaped equal loudness contours of the hearing system. Especially note that the output of this UGen can become very high for frequencies much lower than the root parameter.

    freq

    the frequency in Hertz for which to determine the compensation factor

    root

    the base frequency corresponding to a compensation factor of 1.0

    expon

    the exponent determines how steep the compensation curve decreases for increasing frequencies. In general, the louder a signal is played, the shallower the equal loudness contours become.

    See also

    AmpCompA

  7. final case class AmpCompA(rate: Rate, freq: GE = 1000.0f, root: GE = 0.0f, minAmp: GE = 0.32f, rootAmp: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency. It uses the A-weighting curve that is based on the Fletcher-Munson curve for rather low volume sounds (40 phon).

    Only the freq parameter can be modulated, the other parameters are read at initialization time only.

    freq

    the frequency in Hertz for which to determine the compensation factor

    root

    the root frequency in Hertz, relative to which the curve is calculated. This is usually lowest expected frequency. (init-time only)

    minAmp

    amplitude at the minimum point of the curve. This is the factor output when freq is approx. 2512 Hz. (init-time only)

    rootAmp

    amplitude at the root frequency of the curve. This is the factor output when freq == root . (init-time only)

    See also

    AmpComp

  8. final case class Amplitude(rate: MaybeRate, in: GE, attack: GE = 0.01f, release: GE = 0.01f) extends SingleOut with Product with Serializable

    An amplitude follower UGen.

    An amplitude follower UGen. Tracks and reports the peak amplitude of its input signal.

    in

    input signal to be analyzed

    attack

    60 dB convergence time in for following attacks, in seconds

    release

    60 dB convergence time in for following decays, in seconds

    See also

    DetectSilence

  9. final case class ArrayMax(rate: Rate, in: GE) extends MultiOut with Product with Serializable

    A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.

    A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.

    This is a third-party UGen (MCLDUGens).

    in

    multi-channel signal to analyze

    See also

    ArrayMin

    BufMax

  10. final case class ArrayMin(rate: Rate, in: GE) extends MultiOut with Product with Serializable

    A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.

    A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.

    This is a third-party UGen (MCLDUGens).

    in

    multi-channel signal to analyze

    See also

    ArrayMax

    BufMin

  11. final case class AudioControl(values: IndexedSeq[Float], ctrlName: Option[String]) extends MultiOut with AudioRated with Product with Serializable
  12. final case class AudioControlProxy(values: IndexedSeq[Float], name: Option[String]) extends ControlProxyLike with AudioRated with Product with Serializable
  13. final case class BAllPass(in: GE, freq: GE = 500.0f, rq: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable

    An all pass filter UGen.

    An all pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    cutoff frequency.

    rq

    the reciprocal of Q, hence bandwidth / cutoffFreq.

  14. final case class BBandPass(in: GE, freq: GE = 500.0f, bw: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable

    An band pass filter UGen.

    An band pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    center frequency.

    bw

    the bandwidth in octaves between -3 dB frequencies

  15. final case class BBandStop(in: GE, freq: GE = 500.0f, bw: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable

    An band stop (reject) filter UGen.

    An band stop (reject) filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    center frequency.

    bw

    the bandwidth in octaves between -3 dB frequencies

  16. final case class BHiPass(in: GE, freq: GE = 500.0f, rq: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable

    A 2nd order (12db per oct roll-off) resonant high pass filter UGen.

    A 2nd order (12db per oct roll-off) resonant high pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    cutoff frequency.

    rq

    the reciprocal of Q, hence bandwidth / cutoffFreq.

  17. final case class BHiShelf(in: GE, freq: GE = 500.0f, rs: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable

    A high shelf equalizer UGen.

    A high shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    cutoff frequency.

    rs

    the reciprocal of the slope S (Shell boost/cut slope). When S = 1 , the shelf slope is as steep as it can be and remain monotonically increasing or decreasing gain with frequency. The shelf slope, in dB/octave, remains proportional to S for all other values for a fixed freq/sample-rate and gain .

    gain

    boost/cut at the cutoff frequency (in decibels).

  18. final case class BLowPass(in: GE, freq: GE = 500.0f, rq: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable

    A 2nd order (12db per oct roll-off) resonant low pass filter UGen.

    A 2nd order (12db per oct roll-off) resonant low pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    cutoff frequency.

    rq

    the reciprocal of Q, hence bandwidth / cutoffFreq.

  19. final case class BLowShelf(in: GE, freq: GE = 500.0f, rs: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable

    A low shelf equalizer UGen.

    A low shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    cutoff frequency.

    rs

    the reciprocal of the slope S (Shell boost/cut slope). When S = 1 , the shelf slope is as steep as it can be and remain monotonically increasing or decreasing gain with frequency. The shelf slope, in dB/octave, remains proportional to S for all other values for a fixed freq/sample-rate and gain .

    gain

    boost/cut at the cutoff frequency (in decibels).

  20. final case class BPF(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f) extends SingleOut with Product with Serializable

    A second order band pass filter UGen.

    A second order band pass filter UGen.

    in

    input signal to be filtered

    freq

    center frequency in Hertz

    rq

    reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq  = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter.

    See also

    HPF

    LPF

    BRF

    Resonz

    MidEQ

  21. final case class BPZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    a special fixed band-pass filter UGen.

    a special fixed band-pass filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) - in(i-2))

    This filter cuts out frequencies around zero Hertz and Nyquist.

    in

    input signal to be filtered

    See also

    HPZ2

    LPZ2

    BRZ2

    BPF

  22. final case class BPeakEQ(in: GE, freq: GE = 500.0f, rq: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable

    An parametric equalizer UGen.

    An parametric equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

    in

    input signal to be processed.

    freq

    center frequency.

    rq

    the reciprocal of Q, hence bandwidth / cutoffFreq.

    gain

    boost/cut at the center frequency (in decibels).

  23. final case class BRF(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f) extends SingleOut with Product with Serializable

    A second order band reject (notch) filter UGen.

    A second order band reject (notch) filter UGen.

    in

    input signal to be filtered

    freq

    center frequency in Hertz

    rq

    reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq  = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter. Too high values for rq may blow the filter up!

    See also

    HPF

    LPF

    BPF

    MidEQ

  24. final case class BRZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    a special fixed band-reject filter UGen.

    a special fixed band-reject filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) + in(i-2))

    This filter cuts out frequencies around half of the Nyquist frequency.

    in

    input signal to be filtered

    See also

    HPZ1

    HPZ2

    BRF

  25. final case class Balance2(rate: Rate, inL: GE, inR: GE, pos: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable

    An equal power two channel balancing UGen.

    An equal power two channel balancing UGen. It takes a left and right input signal and attenuates them according to the pos value, producing again a stereophonic output.

    inL

    The left input signal

    inR

    The right input signal

    pos

    The balance position from -1 (left only, right muted) to +1 (right only, left muted). The curve follows an equal power law, such that left.squared + right.squared == 1 , e.g. at the middle position 0 , both channels are multiplied with factor sqrt(0.5) = 0.707 = -3 dB .

    See also

    XFade2

    Pan2

  26. final case class Ball(rate: MaybeRate, in: GE, g: GE = 1.0f, damp: GE = 0.0f, friction: GE = 0.01f) extends SingleOut with Product with Serializable
  27. final case class BeatTrack(chain: GE, lock: GE = 0.0f) extends SingleOut with ControlRated with IsIndividual with Product with Serializable

    An autocorrelation based beat tracker UGen.

    An autocorrelation based beat tracker UGen.

    The underlying model assumes 4/4, but it should work on any isochronous beat structure, though there are biases to 100-120 bpm; a fast 7/8 may not be tracked in that sense. There are four control-rate outputs, being ticks at quarter, eighth and sixteenth level from the determined beat, and the current detected tempo. Note that the sixteenth note output won't necessarily make much sense if the music being tracked has swing; it is provided just as a convenience.

    This beat tracker determines the beat, biased to the mid-tempo range by weighting functions. It does not determine the measure level, only a tactus. It is also slow reacting, using a 6 second temporal window for its autocorrelation maneuvres. Don't expect human musician level predictive tracking.

    On the other hand, it is tireless, relatively general (though obviously best at transient 4/4 heavy material without much expressive tempo variation), and can form the basis of computer processing that is decidedly faster than human.

    Warning: This UGen only works properly at 44.1 or 48.0 kHz.

    chain

    the output (buffer) of an FFT UGen which transforms the audio input to track. The expected size of FFT is 1024 for 44100 and 48000 sampling rate, and 2048 for double those. No other sampling rates are supported.

    lock

    If this argument is greater than 0.5, the tracker will lock at its current periodicity and continue from the current phase. Whilst it updates the model's phase and period, this is not reflected in the output until lock goes back below 0.5. Can be control-rate modulated.

  28. final case class BeatTrack2(bus: GE, numChannels: GE, winSize: GE = 2, phaseSpacing: GE = 0.02f, lock: GE = 0, weighting: GE = -2.1f) extends MultiOut with ControlRated with IsIndividual with Product with Serializable

    A template matching beat tracker UGen.

    A template matching beat tracker UGen. This beat tracker is based on exhaustively testing particular template patterns against feature streams; the testing takes place every 0.5 seconds. The two basic templates are a straight (groove=0) and a swung triplet (groove=1) pattern of 16th notes; this pattern is tried out at scaling factors corresponding to the tempi from 60 to 180 bpm. This is the cross-correlation method of beat tracking. A majority vote is taken on the best tempo detected, but this must be confirmed by a consistency check after a phase estimate. Such a consistency check helps to avoid wild fluctuating estimates, but is at the expense of an additional half second delay. The latency of the beat tracker with default settings is thus at least 2.5 seconds; because of block-based amortisation of calculation, it is actually around 2.8 seconds latency for a 2.0 second temporal window.

    This beat tracker is designed to be flexible for user needs; you can try out different window sizes, tempo weights and combinations of features. However, there are no guarantees on stability and effectiveness, and you will need to explore such parameters for a particular situation.

    The UGen has six outputs corresponding to beat-tick, eighth-tick, groove-tick, tempo, phase, and groove. Warning: it reads from input control bus instead of taking a regular control input signal as its first argument!

    bus

    index of a control bus to read from. the number of channels of that bus are expected to match the numChannels argument. To track a particular audio signal, analyse it first into numChannels features, that is onset-detection-triggers, as generated by Onsets , and write the trigger-output to this control bus.

    numChannels

    (scalar) How many features (ie how many control bus channels) are provided (init-time only)

    winSize

    (scalar) Size of the temporal window desired (2.0 to 3.0 seconds models the human temporal window). You might use longer values for stability of estimate at the expense of reactiveness.

    phaseSpacing

    (scalar) Relates to how many different phases to test. At the default of 0.02 seconds, 50 different phases spaced by those 0.02 seconds would be tried out for 60bpm; 16 would be trialed for 180 bpm. Larger phaseSpacing means more tests and more CPU cost.

    lock

    If this argument is greater than 0.5, the tracker will lock at its current periodicity and continue from the current phase. Whilst it updates the model's phase and period, this is not reflected in the output until lock goes back below 0.5. Can be control-rate modulated.

    weighting

    (scalar) Use (-2.5) for flat weighting of tempi, (-1.5) for compensation weighting based on the number of events tested (because different periods allow different numbers of events within the temporal window). If an integer from 0 upwards is given, this is specifying the id of a buffer containing 120 frames which represent individual tempo weights; tempi go from 60 to 179 bpm in steps of one bpm, so you make sure the buffer has 120 frames.

  29. final case class BiPanB2(rate: Rate, inA: GE, inB: GE, azimuth: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable

    A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal.

    A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal. ambisonic B-format. It places the two input channels at opposite poles of the 2D (W, X, Y) Ambisonics field. It is equivalent to:

    PanB2(_, inA, azimuth, level) + PanB2(_, inB, azimuth + 1, level)
    inA

    the first (monophonic) input signal, which will appear opposite to the first second signal

    inB

    the second (monophonic) input signal, which will appear opposite to the first input signal

    See also

    PanB2

    DecodeB2

  30. abstract class BinaryOpUGen extends SingleOut
  31. final case class Blip(rate: Rate, freq: GE = 440.0f, numHarm: GE = 200) extends SingleOut with Product with Serializable

    Band Limited ImPulse generator UGen.

    Band Limited ImPulse generator UGen. All harmonics have equal amplitude. This is the equivalent of 'buzz' in Music-N languages. It is capable of cross-fading during a control period block if the number of harmonics changes, avoiding audible pops.

    freq

    Fundamental frequency in Hertz

    numHarm

    Number of harmonics. This will be automatically limited to avoid aliasing.

    See also

    Impulse

  32. final case class BrownNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable

    A noise generator UGen whose spectrum falls off in power by 6 dB per octave.

    A noise generator UGen whose spectrum falls off in power by 6 dB per octave. The values produced by this UGen lie between -1 and +1 , the RMS is approx. -4.8 dB (the same as white noise).

    mul

    Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel mul argument will cause the generation of multiple independent noise generators.

    See also

    WhiteNoise

    PinkNoise

    GrayNoise

    ClipNoise

    RandSeed

  33. final case class BufAllpassC(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    All pass delay line with cubic interpolation which uses a buffer for its internal memory.

    All pass delay line with cubic interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    BufAllpassN

    BufAllpassL

  34. final case class BufAllpassL(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    All pass delay line with linear interpolation which uses a buffer for its internal memory.

    All pass delay line with linear interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    BufAllpassN

    BufAllpassC

  35. final case class BufAllpassN(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    All pass delay line with no interpolation which uses a buffer for its internal memory.

    All pass delay line with no interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    BufAllpassL

    BufAllpassC

  36. final case class BufChannels(rate: Rate, buf: GE) extends SingleOut with Product with Serializable

    Returns the current number of channels of the buffer at the provided index.

    Returns the current number of channels of the buffer at the provided index.

    buf

    Buffer id.

    See also

    BufFrames

    BufSamples

  37. final case class BufCombC(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    Comb delay line with cubic interpolation which uses a buffer for its internal memory.

    Comb delay line with cubic interpolation which uses a buffer for its internal memory.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower. Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    See also

    BufCombN

    BufCombL

  38. final case class BufCombL(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    Comb delay line with linear interpolation which uses a buffer for its internal memory.

    Comb delay line with linear interpolation which uses a buffer for its internal memory.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower. Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    See also

    BufCombN

    BufCombC

  39. final case class BufCombN(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    Comb delay line with no interpolation which uses a buffer for its internal memory.

    Comb delay line with no interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    BufCombL

    BufCombC

  40. final case class BufDelayC(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    Simple delay line with cubic interpolation which uses a buffer for its internal memory.

    Simple delay line with cubic interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    See also

    BufDelayN

    BufDelayL

  41. final case class BufDelayL(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    Simple delay line with linear interpolation which uses a buffer for its internal memory.

    Simple delay line with linear interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    See also

    BufDelayN

    BufDelayC

  42. final case class BufDelayN(rate: Rate, buf: GE, in: GE, delayTime: GE = 0.2f) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    Simple delay line with no interpolation which uses a buffer for its internal memory.

    Simple delay line with no interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    buf

    Buffer id.

    in

    The input signal.

    delayTime

    Delay time in seconds.

    See also

    BufDelayL

    BufDelayC

  43. final case class BufDur(rate: Rate, buf: GE) extends SingleOut with Product with Serializable

    Returns the current duration of the buffer at the provided index.

    Returns the current duration of the buffer at the provided index.

    buf

    Buffer id.

    See also

    BufFrames

    BufRateScale

    SampleDur

  44. final case class BufFrames(rate: Rate, buf: GE) extends SingleOut with Product with Serializable

    Returns the number of allocated frames of the buffer at the provided index.

    Returns the number of allocated frames of the buffer at the provided index.

    buf

    Buffer id.

    See also

    BufSamples

    BufChannels

    BufDur

  45. final case class BufMax(rate: Rate, buf: GE, gate: GE = 1) extends MultiOut with IsIndividual with Product with Serializable

    A UGen that finds the largest value in a buffer, providing both the value and the index.

    A UGen that finds the largest value in a buffer, providing both the value and the index.

    This is a third-party UGen (MCLDUGens).

    buf

    identifier of the buffer containing the values to analyze. It treats multi-channel buffers as monophonic, and indices will refer to the de-interleaved frames and channels.

    gate

    when closed (zero), holds the last output value.

    See also

    BufMin

    ArrayMax

  46. final case class BufMin(rate: Rate, buf: GE, gate: GE = 1) extends MultiOut with IsIndividual with Product with Serializable

    A UGen that finds the smallest value in a buffer, providing both the value and the index.

    A UGen that finds the smallest value in a buffer, providing both the value and the index.

    This is a third-party UGen (MCLDUGens).

    buf

    identifier of the buffer containing the values to analyze. It treats multi-channel buffers as monophonic, and indices will refer to the de-interleaved frames and channels.

    gate

    when closed (zero), holds the last output value.

    See also

    BufMax

    ArrayMin

  47. final case class BufRateScale(rate: Rate, buf: GE) extends SingleOut with Product with Serializable

    Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.

    Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.

    buffer sample rate / server sample rate
    buf

    Buffer id.

    See also

    BufSampleRate

    SampleRate

    PlayBuf

  48. final case class BufRd(rate: Rate, numChannels: Int, buf: GE, index: GE = 0.0f, loop: GE = 1, interp: GE = 2) extends MultiOut with IsIndividual with HasDoneFlag with Product with Serializable

    A UGen which reads the content of a buffer, using an index pointer.

    A UGen which reads the content of a buffer, using an index pointer.

    Warning: if the supplied buf refers to a buffer whose number of channels differs from numChannels , the UGen will fail silently.

    An alternative to BufRd is PlayBuf . While PlayBuf plays through the buffer by itself, BufRd only moves its read point by the index input and therefore has no pitch input. PlayBuf uses cubic interpolation, while BufRd has variable interpolation. PlayBuf can determine the end of the buffer and issue a done-action.

    numChannels

    number of channels that the buffer will be. Since this is an integer constant, a change in the number of channels must be reflected by creating different SynthDefs.

    buf

    the identifier of the buffer to use

    index

    audio rate frame-index into the buffer. Can be fractional.

    loop

    1 to enable looping, 0 to disable looping. this can be modulated.

    interp

    1 for no interpolation, 2 for linear, and 4 for cubic interpolation. (init-time only)

    See also

    PlayBuf

    BufWr

    Phasor

    BufFrames

    BufRateScale

  49. final case class BufSampleRate(rate: Rate, buf: GE) extends SingleOut with Product with Serializable

    Returns the buffer's current sample rate.

    Returns the buffer's current sample rate.

    buf

    Buffer id.

    See also

    SampleRate

    BufRateScale

  50. final case class BufSamples(rate: Rate, buf: GE) extends SingleOut with Product with Serializable

    Returns the current number of allocated samples in the Buffer at the provided index.

    Returns the current number of allocated samples in the Buffer at the provided index. A sample is not the same as a frame (compare with BufFrames ); a frame includes the samples in each channel of the buffer. Only for a mono buffer are samples the same as frames.

    samples = frames * numChannels
    buf

    Buffer id.

    See also

    BufFrames

    BufChannels

    BufDur

  51. final case class BufWr(rate: Rate, in: GE, buf: GE, index: GE = 0.0f, loop: GE = 1) extends SingleOut with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable

    A UGen that writes a signal to a buffer, using an index pointer.

    A UGen that writes a signal to a buffer, using an index pointer.

    Warning: if the supplied buf refers to a buffer whose number of channels differs from those of the input signal, the UGen will fail silently.

    An alternative to BufWr is RecordBuf . While RecordBuf advances the index into the buffer by itself, BufWr only moves its write point by the index input, making it possible to adjust the writing speed or to access the buffer in a non-linear way. RecordBuf can determine the end of the buffer and issue a done-action.

    in

    input signal to record

    buf

    the identifier of the buffer to use

    index

    audio rate frame-index into the buffer.

    loop

    1 to enable looping, 0 to disable looping. this can be modulated.

    See also

    RecordBuf

    BufRd

    Phasor

    BufFrames

    BufRateScale

  52. final case class COsc(rate: Rate, buf: GE, freq: GE = 440.0f, beats: GE = 0.5f) extends SingleOut with IsIndividual with Product with Serializable
  53. final case class ChannelIndices(in: GE) extends SingleOut with ScalarRated with Product with Serializable

    A graph element that produces an integer sequence from zero until the number-of-channels of the input element.

    A graph element that produces an integer sequence from zero until the number-of-channels of the input element.

    Examples
    // cross-faded select
    play {
      val sines: GE = Seq.fill(4)(SinOsc.ar(ExpRand(200, 2000)))
      val index   = MouseX.kr(lo = 0, hi = NumChannels(sines) - 1)
      val indices = ChannelIndices(sines)
      indices.poll(0, "indices")
      val select  = 1 - (indices absdif index).min(1)
      val sig     = Mix(sines * select)
      sig * 0.2
    }
    in

    the element whose indices to produce

    See also

    NumChannels

  54. final case class ChannelProxy(elem: GE, index: Int) extends GE.Lazy with Product with Serializable

    A helper graph element that selects a particular output channel of another element.

    A helper graph element that selects a particular output channel of another element. The index is an Integer and thus cannot be determined at graph expansion time. If this is desired, the Select UGen can be used.

    Usually the graph element operator \ (backlash) can be used instead of explicitly writing ChannelProxy. Thus elem \ index is equivalent to ChannelProxy(elem, index). UGens with a fixed number of outputs often have auxiliary methods to access the channels in meaningful way, e.g. Pitch has method freq and hasFreq, which are equivalent to pitch \ 0 and pitch \ 1.

    Because ScalaCollider allows late-expanding graph elements, we have no direct way to get some array of a UGen's outputs.

    Examples
    // frequency of a pitch estimator
    play {
      val sin = SinOsc.ar(MouseX.kr(10, 10000, warp = 1))
      val pch = Pitch.kr(sin)
      val freq = pch \ 0  // same as pch.freq
      freq.poll(label = "freq")
      ()
    }
    elem

    a multi-channel element from which to select a channel.

    index

    channel index starting at zero. It automatically wraps around the actual number of channels the input elem expands to.

    See also

    NumChannels

    Select

  55. final case class ChannelRangeProxy(elem: GE, from: Int, until: Int, step: Int) extends GE.Lazy with Product with Serializable

    A helper graph element that selects a particular range of output channel of another element.

    A helper graph element that selects a particular range of output channel of another element. The range is specified with integers and thus cannot be determined at graph expansion time. If this is desired, the Select UGen can be used.

    Usually the graph element operator out along with a standard Scala Range argument can be used instead of explicitly writing ChannelRangeProxy. Thus elem out (0 until 4) selects the first four channels and is equivalent to ChannelRangeProxy(elem, from = 0, until = 4, step = 1).

    Behind the scene, ChannelProxy instances are created, thus ChannelRangeProxy(x, a, b) is the same as (a until b).map(ChannelProxy(x, _)): GE.

    Because ScalaCollider allows late-expanding graph elements, we have no direct way to get some array of a UGen's outputs.

    elem

    a multi-channel element from which to select channels.

    from

    the first index (inclusive) of the channel range, counting from zero.

    until

    the end index (exclusive) of the channel range, counting from zero.

    step

    the increment from index to index in the range. A value of one means all channels from from until until will be selected. A value of two means, every second channel will be skipped. A negative value can be used to count down from high to low indices.

    See also

    NumChannels

    Select

    ChannelProxy

    RepeatChannels

  56. final case class CheckBadValues(rate: Rate, in: GE, id: GE = 0, post: GE = 2) extends SingleOut with HasSideEffect with Product with Serializable

    A UGen to test for infinity, not-a-number (NaN), and denormal numbers.

    A UGen to test for infinity, not-a-number (NaN), and denormal numbers. Its output is as follows: 0 = a normal float, 1 = NaN, 2 = infinity, and 3 = a denormal. According to the post settings it will print the information to the console along with a given identifier.

    in

    the signal to be tested

    id

    an identifier showing up with the values in the console

    post

    One of three post modes: 0 = no posting; 1 = post a line for every bad value; 2 = post a line only when the floating-point classification changes (e.g., normal -> NaN and vice versa)

  57. final case class CircleRamp(rate: MaybeRate, in: GE, dur: GE = 0.1f, lo: GE = -180, hi: GE = 180) extends SingleOut with Product with Serializable

    This is a UGen like Ramp , but it always takes the shortest way around a defined circle, wrapping values where appropriate.

    This is a UGen like Ramp , but it always takes the shortest way around a defined circle, wrapping values where appropriate. This can be useful when smoothing panning signals for speaker rings, for instance in Vector Base Amplitude Panning.

    This is a third-party UGen (VBAPUGens).

    in

    The signal to be smoothed.

    dur

    Ramp duration in seconds

    lo

    The lower wrap value

    hi

    The upper wrap value

    See also

    VBAP

    Ramp

    Lag

  58. final class ClassGenerator extends AnyRef
  59. final case class ClearBuf(buf: GE) extends SingleOut with ScalarRated with HasSideEffect with IsIndividual with Product with Serializable

    A scalar (init-time) UGen that fills the contents of a buffer with zeroes.

    A scalar (init-time) UGen that fills the contents of a buffer with zeroes.

    buf

    the buffer to clear

    See also

    LocalBuf

    SetBuf

  60. final case class Clip(rate: Rate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins.

    A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins. This is similar to the clip2 binary operator but permits both a lower range value lo and an upper range value hi .

    Mathematically, this is equivalent to in.max(lo).min(hi).

    Be aware that there seems to be an initialization bug. The following crashes, indicating that Clip.ar outputs a zero initially:

    {{ play { val bar = Integrator.ar(DC.ar(0), coeff = 0.999) val foo = Clip.ar(bar, lo = 1.0, hi = 44100.0) // .max(1.0) val sum = RunningSum.ar(DC.ar(0), length = foo) sum.poll(1, "sum") () } }}

    in

    input signal to constrain

    lo

    lower margin of clipping

    hi

    upper margin of clipping

    See also

    Wrap

    Fold

  61. final case class ClipNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable

    A noise generator UGen whose values are either -1 or +1 (before being multiplied by mul ).

    A noise generator UGen whose values are either -1 or +1 (before being multiplied by mul ). This produces the maximum energy (an RMS of 0 dB) for the least peak to peak amplitude.

    mul

    Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel mul argument will cause the generation of multiple independent noise generators.

    See also

    LFClipNoise

    WhiteNoise

    PinkNoise

    BrownNoise

    GrayNoise

    RandSeed

    LFNoise0

    Dust

  62. final case class CoinGate(rate: MaybeRate, in: GE, prob: GE = 0.5f) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that randomly filters an input trigger signal.

    A UGen that randomly filters an input trigger signal. When a trigger arrives, it may pass with a probability given by the prob argument.

    in

    the input triggers to filter

    prob

    the probability between zero (no trigger passed) and 1 (all triggers passed)

    Note

    The argument order is different from its sclang counterpart.

    See also

    Gate

    PulseDivider

    TRand

  63. final case class CombC(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable

    Comb delay line with cubic interpolation.

    Comb delay line with cubic interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    CombN

    CombL

  64. final case class CombL(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable

    Comb delay line with linear interpolation.

    Comb delay line with linear interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    CombN

    CombC

  65. final case class CombN(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f) extends SingleOut with Product with Serializable

    Comb delay line with no interpolation.

    Comb delay line with no interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. If this time is negative then the feedback coefficient will be negative, thus emphasizing only odd harmonics at an octave lower.

    See also

    CombL

    CombC

  66. final case class Compander(rate: Rate, in: GE, ctrl: GE, thresh: GE = 0.5f, ratioBelow: GE = 1.0f, ratioAbove: GE = 1.0f, attack: GE = 0.01f, release: GE = 0.1f) extends SingleOut with Product with Serializable

    A compressor, expander, limiter, gate and ducking UGen.

    A compressor, expander, limiter, gate and ducking UGen. This dynamic processor uses a hard-knee characteristic. All of the thresholds and ratios are given as direct values, not in decibels!

    in

    The signal to be compressed / expanded / gated.

    ctrl

    The signal whose amplitude controls the processor. Often the same as in, but one may wish to apply equalization or delay to it to change the compressor character (side-chaining), or even feed a completely different signal, for instance in a ducking application.

    thresh

    Control signal amplitude threshold, which determines the break point between slopeBelow and slopeAbove. Usually 0..1. The control signal amplitude is calculated using RMS.

    ratioBelow

    Slope of the amplitude curve below the threshold. If this slope > 1.0, the amplitude will drop off more quickly the softer the control signal gets; when the control signal is close to 0 amplitude, the output should be exactly zero -- hence, noise gating. Values < 1.0 are possible, but it means that a very low-level control signal will cause the input signal to be amplified, which would raise the noise floor.

    ratioAbove

    Slope of the amplitude curve above the threshold. Values < 1.0 achieve compression (louder signals are attenuated); > 1.0, you get expansion (louder signals are made even louder). For 3:1 compression, you would use a value of 1/3 here.

    attack

    The amount of time it takes for the amplitude adjustment to kick in fully. This is usually pretty small, not much more than 10 milliseconds (the default value). I often set it as low as 2 milliseconds (0.002).

    release

    The amount of time for the amplitude adjustment to be released. Usually a bit longer than attack; if both times are too short, you can get some (possibly unwanted) artifacts.

    See also

    Limiter

    Normalizer

  67. final case class ComplexRes(rate: Rate, in: GE, freq: GE = 440.0f, decay: GE = 0.2f) extends SingleOut with Product with Serializable

    A resonating filter UGen which can be modulated in its resonating frequency at audio rate.

    A resonating filter UGen which can be modulated in its resonating frequency at audio rate.

    Implements the filter structure found in Julian Parker and Till Bovermann (2013): Dynamic FM synthesis using a network of complex resonator filters

    This is a third-party UGen (DEINDUGens).

    in

    input signal to be filtered

    freq

    resonating frequency in Hz, can be modulated at audio rate

    decay

    decay time in seconds

    See also

    Resonz

    Formlet

    RHPF

    RLPF

    Ringz

  68. final case class Constant(value: Float) extends UGenIn with ScalarRated with Product with Serializable

    A scalar constant used as an input to a UGen.

    A scalar constant used as an input to a UGen. These constants are stored in a separate table of the synth graph.

  69. final case class Control(rate: Rate, values: IndexedSeq[Float], ctrlName: Option[String]) extends MultiOut with Product with Serializable
  70. final case class ControlDur() extends SingleOut with ScalarRated with Product with Serializable

    A UGen that reports the server's current control period in seconds.

    A UGen that reports the server's current control period in seconds. This is equivalent to the reciprocal of ControlRate

    See also

    ControlRate

    SampleDur

  71. final class ControlFactory extends ControlFactoryLike
  72. trait ControlFactoryLike extends AnyRef
  73. final case class ControlProxy(rate: Rate, values: IndexedSeq[Float], name: Option[String]) extends ControlProxyLike with Product with Serializable
  74. final class ControlProxyFactory extends AnyVal
  75. trait ControlProxyLike extends GE
  76. final case class ControlRate() extends SingleOut with ScalarRated with Product with Serializable

    A UGen that reports the server's current control rate.

    A UGen that reports the server's current control rate. This is equivalent to the reciprocal of ControlDur

    See also

    ControlDur

    SampleRate

  77. final case class ControlUGenOutProxy(source: ControlProxyLike, outputIndex: Int) extends UGenIn with Product with Serializable

    A ControlOutProxy is similar to a UGenOutProxy in that it denotes an output channel of a control UGen.

    A ControlOutProxy is similar to a UGenOutProxy in that it denotes an output channel of a control UGen. However it refers to a control-proxy instead of a real control ugen, since the proxies are synthesized into actual ugens only at the end of a synth graph creation, in order to clump several controls together. ControlOutProxy instance are typically returned from the ControlProxyFactory class, that is, using the package implicits, from calls such as "myControl".kr.

  78. final case class ControlValues(seq: IndexedSeq[Float]) extends Product with Serializable
  79. final case class Convolution(rate: Rate, in: GE, kernel: GE, frameSize: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that performs a convolution with an continuously changing kernel.

    A UGen that performs a convolution with an continuously changing kernel. If the kernel is static or must only change occasionally, Convolution2 will be a more CPU friendly alternative. The process introduces a delay of frameSize - blockSize .

    in

    first operand of the convolution

    kernel

    second operand of the convolution

    frameSize

    convolution size in sample frames, which is half of the FFT size. Must be a power of two. There is maximum frame-size of 16384 (if exceeded, the server may crash). (init-time only)

    See also

    PartConv

    Convolution2L

    Convolution2

  80. final case class Convolution2(rate: Rate, in: GE, kernel: GE, trig: GE = 1, frameSize: GE) extends SingleOut with IsIndividual with Product with Serializable

    A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal.

    A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal. The delay caused by the convolution when the kernel is a dirac impulse is equal to frameSize - controlBlockSize , so for a frameSize of 2048 and a control-block size of 64, this is 1984 sample frames.

    in

    the realtime input to be convolved

    kernel

    buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even a trigger input of zero is used, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.

    trig

    updates the kernel on a change from non-positive to positive (<= 0 to >0)

    frameSize

    size of the kernel. this must be a power of two. the FFT calculated internally by the UGen has a size of twice this value. The maximum allowed frameSize is 16384. (init-time only)

    See also

    PartConv

    Convolution2L

    Convolution

  81. final case class Convolution2L(rate: Rate, in: GE, kernel: GE, trig: GE = 1, frameSize: GE, fadePeriods: GE = 1) extends SingleOut with IsIndividual with Product with Serializable

    A frequency-domain convolution UGen using two linearly interpolated fixed kernels.

    A frequency-domain convolution UGen using two linearly interpolated fixed kernels. When a trigger is received, a linear fade will be performed from the previously used kernel (internally stored by the UGen) towards the snapshot of the current kernel content upon receiving the trigger.

    The delay caused by the convolution when the kernel is a dirac impulse is equal to frameSize - controlBlockSize , so for a frameSize of 2048 and a control-block size of 64, this is 1984 sample frames.

    Note: If a trigger is received before the previous fade is complete, the interpolation is broken and the kernel instead jumps straight to one of the two buffers.

    in

    the realtime input to be convolved

    kernel

    buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even if the trigger input is initially zero, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.

    trig

    begins a fade to update the kernel on a change from non-positive to positive (<= 0 to >0).

    frameSize

    size of the kernel. this must be a power of two. the FFT calculated internally by the UGen has a size of twice this value. The maximum allowed frameSize is 16384. (init-time only)

    fadePeriods

    fade duration expressed as number of convolved blocks. If the desired duration in seconds is dur , then the number of periods can be calculated as fadePeriods = dur * SampleRate.ir / frameSize . (init-time only)

    See also

    PartConv

    Convolution2

    Convolution

  82. final case class Convolution3(rate: Rate, in: GE, kernel: GE, trig: GE = 1, frameSize: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen for triggered convolution in the time domain.

    A UGen for triggered convolution in the time domain.

    Warning: This UGen seems currently broken (SC 3.6.3)

    in

    the realtime input to be convolved

    kernel

    buffer identifier for the fixed kernel, which may be modulated in combination with the trigger. Even a trigger input of zero is used, upon UGen initialization the kernel must point to a valid buffer, otherwise the UGen aborts.

    frameSize

    (init-time only)

    See also

    PartConv

    Convolution2

    Convolution

    Convolution2L

  83. final case class Crackle(rate: Rate, chaos: GE = 1.5f) extends SingleOut with IsIndividual with Product with Serializable

    A noise generator UGen based on a chaotic function.

    A noise generator UGen based on a chaotic function. Output values lie between zero and one. Although this is a deterministic process, it is randomly seeded.

    chaos

    A parameter of the chaotic function with useful values from just below 1.0 to just above 2.0. Towards 2.0 the sound crackles. Values greater than 2.01 are not safe, as the UGen can switch to outputting NaNs. A early more crackling sound appears with a value of 1.33 .

    See also

    Dust

    LatoocarfianN

    Logistic

  84. final case class Crest(rate: Rate, in: GE, length: GE = 400, gate: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that measures the "crest factor" of a time-domain signal.

    A UGen that measures the "crest factor" of a time-domain signal. The "crest factor" is the ratio of the absolute peak to the absolute mean over a certain time period. In pseudocode:

    crest = (samples.abs.max) / (samples.abs.mean)

    For Pulse waves the value will be 1, because the mean and the maximum are the same. For SinOsc , the theoretical value is 2.sqrt . For Saw it is 3.sqrt . These exact values might not occur in practice, because of anti-aliasing and other sampling factors.

    This is not to be confused with FFTCrest which does the same thing for spectral data.

    This is a third-party UGen (MCLDUGens).

    in

    signal to analyze, can be audio rate or control rate

    length

    number of samples over which to take the measurement. A buffer of this size is created internally (so be careful about specifying a massive number here). (init-time only)

    gate

    normally the statistic is calculated on every control block cycle. If one wants it less often (e.g. to reduce CPU usage), one can modulate this – calculation only occurs if gate is greater than zero.

  85. final case class CuspL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 1.9f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+1] = a - b * sqrt(abs(x[n]))
    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    xi

    Initial value of x

    See also

    CuspN

  86. final case class CuspN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 1.9f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+1] = a - b * sqrt(abs(x[n]))
    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    xi

    Initial value of x

    See also

    CuspL

  87. final case class DC(rate: Rate, in: GE) extends SingleOut with Product with Serializable

    A UGen that creates a constant signal at a given calculation rate.

    A UGen that creates a constant signal at a given calculation rate.

    in

    constant value to output, fixed at initialisation time. (init-time only)

    See also

    LeakDC

  88. final case class DFM1(rate: Rate, in: GE, freq: GE = 440, res: GE = 0.1f, gain: GE = 1.0f, mode: GE = 0, noise: GE = 3.0E-4f) extends SingleOut with Product with Serializable

    A digital filter UGen which aims at accurately modeling an analog filter.

    A digital filter UGen which aims at accurately modeling an analog filter. It provides low-pass and high-pass modes, and the filter can be overdriven and will self-oscillate at high resonances.

    This is a third-party UGen (TJUGens).

    in

    Input signal to filter.

    freq

    Cutoff frequency in Hertz.

    res

    Resonance of the filter. Resonance is minimal at 0.0 and high at 1.0 , above which the filter starts overdrive and sound saturated (e.g. 1.2 ).

    gain

    Linear gain applied to the input signal.

    mode

    The filter can be used in low-pass ( 0 ) or high-pass ( 1 ) mode.

    noise

    Amount (amplitude) of noise added to the model.

  89. final case class DNoiseRing(change: GE = 0.5f, chance: GE = 0.5f, shift: GE = 1, numBits: GE = 8, init: GE = 0) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    Demand rate UGen implementing a Wiard noise ring.

    Demand rate UGen implementing a Wiard noise ring.

    "In latter model synthesizers, digital noise sources began to appear in place of analog ones. Traditionally, a pseudo-random shift register set up for optimal length. By optimal length, it is meant that every state of all available bits will appear at some time, but the order is unknown. Essentially a counter that counts in an unknown order. This represents the maximum state of information "entropy" available for that number of bits. But music has close self-similarity over short periods of time. That is, it repeats itself with changes appearing slowly. This shift register generator is designed to give control of the rate of appearance of new information. It has a tight set of controls over how random it actually is and how fast change occurs." (source: http://mamonu.weebly.com/wiard-noisering.html)

    This is a third-party UGen (DEINDUGens).

    change

    probability of changing to a new value

    chance

    probability of the new value becoming HIGH

    init

    initial internal state

    See also

    Duty

    Demand

  90. final case class Dbrown(lo: GE = 0.0f, hi: GE = 1.0f, step: GE = 0.01f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.

    A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.

    lo

    minimum value (inclusive)

    hi

    minimum value (inclusive)

    step

    the maximum step a value can take from the previous value

    length

    length of the sequence or inf

    See also

    Dwhite

    Dibrown

    BrownNoise

    Demand

  91. final case class Dbufrd(buf: GE, index: GE = 0, loop: GE = 1) extends SingleOut with DemandRated with IsIndividual with HasDoneFlag with Product with Serializable

    A demand-rate UGen that reads out a buffer.

    A demand-rate UGen that reads out a buffer. All inputs can be either demand UGens or any other UGens.

    buf

    the identifier of the buffer to read out

    index

    the frame index into the buffer

    loop

    whether to wrap an exceeding phase around the buffer length (1) or not (0)

    See also

    BufRd

    Dbufwr

  92. final case class Dbufwr(in: GE, buf: GE, index: GE = 0, loop: GE = 1) extends SingleOut with DemandRated with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable
  93. final case class Dconst(sum: GE, in: GE, tolerance: GE = 0.001f) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total.

    A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total. The last value will be truncated so that the sum of Dconst 's output values will match the total exactly.

    sum

    the sum to reach. This may be a number, demand UGen or any other UGen. When a Dconst instance resets, one value will be taken for the sum, and it can't be modulated until the next reset.

    in

    a demand-rate stream, providing the output values

    tolerance

    how close the running sum can get to stop the output: abs(running-sum - sum) <= tolerance. This is to avoid the problem of floating point rounding error preventing reaching the exact target sum.

  94. final case class Decay(rate: MaybeRate, in: GE, time: GE = 1.0f) extends SingleOut with Product with Serializable

    An integrator UGen with exponential decay of past values.

    An integrator UGen with exponential decay of past values. This is essentially the same as Integrator except that instead of supplying the coefficient directly, it is calculated from a 60 dB decay time. This is the time required for the integrator to lose 99.9 % of its value or -60dB.

    Note: This should not be confused with Lag which does not overshoot due to integration, but asymptotically follows the input signal.

    in

    input signal to be processed

    See also

    Integrator

    Decay2

    Lag

  95. final case class Decay2(rate: MaybeRate, in: GE, attack: GE = 0.01f, release: GE = 1.0f) extends SingleOut with Product with Serializable

    A integrator UGen with controllable attack and release times.

    A integrator UGen with controllable attack and release times. While Decay has a very sharp attack and can produce clicks, Decay2 rounds off the attack by subtracting one Decay from another. It can be seen as equivalent to

    Decay.ar(in, release) - Decay.ar(in, attack)

    Note: This should not be confused with LagUD which does not overshoot due to integration, but asymptotically follows the input signal.

    in

    input signal to be processed

    See also

    Decay

    Integrator

    LagUD

  96. final case class DecodeB2(rate: Rate, numChannels: Int, w: GE, x: GE, y: GE, orient: GE = 0.5f) extends MultiOut with Product with Serializable

    A two dimensional Ambisonics B-format decoding UGen.

    A two dimensional Ambisonics B-format decoding UGen. It assumes a set of speakers in a regular polygon. The output channels are in clockwise order. The position of the first speaker is specified by the orient argument.

    numChannels

    the number of output channels to produce

    w

    W (first) channel of B-format input signal

    x

    X (second) channel of B-format input signal

    y

    Y (third) channel of B-format input signal

    orient

    orientation of the first channel. If zero, the first channel corresponds to the front vertex of the polygon. If the polygon does not have an edge at the front but a vertex, then an orient of 0.5 indicates that the first channel corresponds to the speaker left of the center.

    See also

    PanB

    PanB2

  97. final case class DegreeToKey(rate: Rate, buf: GE, in: GE, octave: GE = 12) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that uses an input signal as an index into an octave repeating table of pitch classes.

    A UGen that uses an input signal as an index into an octave repeating table of pitch classes. The input is truncated to an integer, and indices wrap around the table and shift octaves as they do.

    buf

    buffer which contains the steps for each scale degree.

    in

    input index signal

    octave

    number of steps per octave in the scale.

    See also

    WrapIndex

  98. final case class DelTapRd(rate: Rate, buf: GE, phase: GE, delayTime: GE, interp: GE = 1) extends SingleOut with IsIndividual with Product with Serializable

    Tap a delay line from a DelTapWr UGen.

    Tap a delay line from a DelTapWr UGen.

    buf

    Buffer where DelTapWr has written signal. Max delay time is based on buffer size.

    phase

    the current phase of the DelTapWr UGen. This is the output of DelTapWr.

    delayTime

    Delay time in seconds.

    interp

    The kind of interpolation to be used. 1 is none, 2 is linear, 4 is cubic..

    See also

    DelTapWr

  99. final case class DelTapWr(rate: Rate, buf: GE, in: GE) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    Write to a buffer for a DelTapRd UGen

    Write to a buffer for a DelTapRd UGen

    buf

    The buffer to write signal into. Max delay time is based on buffer size. DelTapWr outputs its current sample value for use in the phase argument of DelTapRd .

    in

    The input signal.

    See also

    DelTapRd

  100. final case class Delay1(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    A UGen that delays the input by 1 audio frame or control period.

    A UGen that delays the input by 1 audio frame or control period.

    For audio-rate signals the delay is 1 audio frame, and for control-rate signals the delay is 1 control period.

    Note: The first value output is not zero but the same as the first input value! In this respect the UGen behaves different than DelayN .

    in

    input to be delayed

    See also

    Delay2

    DelayN

  101. final case class Delay2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    A UGen that delays the input by 2 audio frames or control periods.

    A UGen that delays the input by 2 audio frames or control periods.

    For audio-rate signals the delay is 2 audio frames, and for control-rate signals the delay is 2 control periods.

    Warning: the The first value output is zero, while both the second and the third value output equal the first input value! In this respect the UGen behaves different than DelayN .

    in

    input to be delayed

    See also

    Delay1

    DelayN

  102. final case class DelayC(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f) extends SingleOut with Product with Serializable

    Simple delay line with cubic interpolation.

    Simple delay line with cubic interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    See also

    DelayN

    DelayL

  103. final case class DelayL(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f) extends SingleOut with Product with Serializable

    Simple delay line with linear interpolation.

    Simple delay line with linear interpolation.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    See also

    DelayN

    DelayC

  104. final case class DelayN(rate: Rate, in: GE, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f) extends SingleOut with Product with Serializable

    Simple delay line with no interpolation.

    Simple delay line with no interpolation. The initial buffer contents is zero.

    in

    The input signal.

    maxDelayTime

    The maximum delay time in seconds. used to initialize the delay buffer size. (init-time only)

    delayTime

    Delay time in seconds.

    See also

    DelayL

    DelayC

  105. final case class Demand(rate: MaybeRate, trig: GE, in: GE, reset: GE = 0) extends MultiOut with HasDoneFlag with Product with Serializable

    A UGen which polls results from demand-rate ugens when receiving a trigger.

    A UGen which polls results from demand-rate ugens when receiving a trigger. When there is a trigger at the trig input, a value is demanded from each ugen in the in input and output. The unit generators in the list should be demand-rate. When there is a trigger at the reset input, the demand rate ugens in the list are reset.

    Note: By design, a reset trigger only resets the demand ugens; it does not reset the value at Demand's output. Demand continues to hold its value until the next value is demanded, at which point its output value will be the first expected item in the in argument.

    Note: One demand-rate ugen represents a single stream of values, so that embedding the same ugen twice calls this stream twice per demand, possibly yielding different values. To embed the same sequence twice, either make sure the ugen is demanded only once, or create two instances of the ugen.

    Warning: Demand currently seems to have problems with infinite sequences. As a workaround use a very large length instead. E.g. instead of Dbrown(0, 1, inf) use Dbrown(0, 1, 0xFFFFFFFF) !

    Warning: Demand seems to have a problem with initial triggers. For example Demand.kr(Impulse.kr(0), 1) will have a spurious zero value output first.

    trig

    trigger. Can be any signal. A trigger happens when the signal changes from non-positive to positive.

    in

    a demand-rate signal (possibly multi-channel) which is read at each trigger

    reset

    trigger. Resets the list of ugens (in) when triggered.

    Note

    The argument order is different from its sclang counterpart.

    See also

    Duty

    TDuty

  106. final case class DemandEnvGen(rate: Rate, levels: GE, durs: GE, shapes: GE = 1, curvatures: GE = 0.0f, gate: GE = 1.0f, reset: GE = 1.0f, levelScale: GE = 1.0f, levelBias: GE = 0.0f, timeScale: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with Product with Serializable

    An envelope generator UGen using demand-rate inputs for the envelope segments.

    An envelope generator UGen using demand-rate inputs for the envelope segments. For each parameter of the envelope (levels, durations and shapes), values are polled every time a new segment starts.

    levels

    demand-rate ugen (or other ugen) returning level values

    durs

    demand-rate ugen (or other ugen) returning duration values

    shapes

    demand-rate ugen (or other ugen) returning shape number for the envelope segment.

    curvatures

    demand-rate ugen (or other ugen) returning curvature values. these are used for curveShape segments (shape number 5) and should be zero for other shapes.

    gate

    a control rate gate: if gate is x >= 1, the ugen runs. if gate is 0 > x > 1, the ugen is released at the next level (according to doneAction). if gate is x <= 0, the ugen is sampled and held.

    reset

    a trigger signal. a trigger occurs when passing from non-positive to positive. when the trigger amplitude is < 1, the input ugens (those that are demand-rated) are reset when the current segment ends. if the trigger amplitude is > 1, the reset is performed immediately.

    levelScale

    demand-rate ugen returning level scaling values

    levelBias

    demand-rate ugen returning level offset values

    timeScale

    demand-rate ugen returning time scaling values

    doneAction

    a done action performed when one of the demand-rated series ends

    See also

    EnvGen

    Env

    DoneAction

  107. final case class DetectIndex(rate: Rate, buf: GE, in: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen which determines the index in a buffer at which the value matches a given input signal.

    A UGen which determines the index in a buffer at which the value matches a given input signal. If the input value is not found, it outputs -1.

    For example, if the buffer contains values 5, 3, 2, 8, and the input signal is 3, the output will be 1. If the input is 3.001, the output will be -1. Unlike IndexInBetween , this UGen always searches through the entire buffer until the value is found or the end has been reached (returning -1).

    See also

    Index

    IndexInBetween

  108. final case class DetectSilence(rate: MaybeRate, in: GE, amp: GE = 1.0E-4f, dur: GE = 0.1f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with Product with Serializable

    A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent").

    A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent"). A silence is detected if the absolute sample values of the input remain less than or equal to the amp threshold for a consecutive amount of time given by the dur argument.

    A value of 1 is output when this condition is met, and a value of 0 is output when the condition is not met (i.e. at least one sample occurs in the input whose absolute value is greater than amp ). Besides, when the output changes from zero to one, the doneAction is executed (unless it is doNothing ).

    A special case is the initial condition of the UGen: It will begin with an output value of 0 (no silence detected), even if the input signal is below the amplitude threshold. It is only after the first input sample rising above the threshold that the actual monitoring begins and a trigger of 1 or the firing of the done-action may occur.

    in

    input signal to be measured.

    amp

    minimum amplitude threshold which must be exceeded for the input signal to be considered non-silent. (init-time only)

    dur

    The duration in seconds for which the input signal must be continuously smaller than or equal to the threshold to be considered silent. (init-time only)

    doneAction

    an action to be performed when the output changes from zero to one (silence detected).

    See also

    Amplitude

  109. final case class Dgeom(start: GE = 1.0f, grow: GE = 2.0f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen that produces a geometric series.

    A demand-rate UGen that produces a geometric series. Each value is calculated as

    x[t] = x[t-1] * grow

    With x[0] given as argument start.

    start

    initial value

    grow

    factor (multiplier) by which values grow

    length

    length of the sequence or inf

    See also

    Dseries

    Demand

  110. final case class Dibrown(lo: GE = 0, hi: GE = 1, step: GE = 1, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the drunk object in Max.

    A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the drunk object in Max.

    Note: The length parameter seems currently broken.

    lo

    minimum value (inclusive)

    hi

    maximum value (inclusive)

    step

    the maximum step a value can take from the previous value

    length

    length of the sequence or inf . This is currently (SuperCollider 3.7.2) broken, and the sequence always has infinite length.

    See also

    Diwhite

    Dbrown

    BrownNoise

    Demand

  111. final case class DiodeRingMod(rate: Rate, car: GE, mod: GE) extends SingleOut with Product with Serializable

    Ring modulation UGen based on a physical model of a diode.

    Ring modulation UGen based on a physical model of a diode.

    This is a third-party UGen (DEINDUGens).

    car

    carrier signal

    mod

    modulator signal

    See also

    BinaryOpUGen

  112. final case class DiskIn(rate: Rate, numChannels: Int, buf: GE, loop: GE = 0) extends MultiOut with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable

    A UGen to stream in a signal from an audio file.

    A UGen to stream in a signal from an audio file. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.

    Note: The buffer size must be a multiple of (2 * the server's block size). See Buffer#cue for details.

    numChannels

    the amount of channels the file and the buffer will have. This is an Int and hence must be pre-determined. Different SynthDefs must be created for different numbers of channels.

    buf

    the id of the buffer with the correct number of channels and frames

    loop

    whether the file should loop when its end is reached

    See also

    Buffer#cue

    VDiskIn

    PlayBuf

  113. final case class DiskOut(rate: Rate, buf: GE, in: GE) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    A UGen which writes a signal to a sound file on disk.

    A UGen which writes a signal to a sound file on disk. To achieve this efficiently, a buffer is needs to be provides which is used to buffer the incoming signal.

    Note: It might be that the buffer size must be a multiple of (2 * the server's block size). We haven't currently verified this, but to be safe, you should make sure this property is met.

    The signal output by the UGen represents the number of frames written.

    buf

    the buffer used internally by the UGen. this number of frames in the buffer must be a power of two (this is currently not checked!). The buffer must have been initialized with a write command whose leaveOpen argument is true. Note that the number of channels of the buffer and of the input signal must be the same, otherwise DiskOut will fail silently (and not write anything to the file). Warning: Crashes the server if the number of channels exceeds 32.

    in

    the signal to be recorded

    See also

    Buffer#write

    DiskIn

    RecordBuf

  114. final case class Diwhite(lo: GE = 0, hi: GE = 1, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen that produces equally distributed random integer numbers.

    A demand-rate UGen that produces equally distributed random integer numbers.

    lo

    minimum value (inclusive)

    hi

    maximum value (inclusive)

    length

    length of the sequence or inf

    See also

    Dwhite

    Dibrown

    IRand

    TIRand

    Demand

  115. final case class Donce(in: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
  116. final case class Done(src: GE with HasDoneFlag) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable

    A UGen which monitors another UGen to see when it is finished.

    A UGen which monitors another UGen to see when it is finished. Some UGens, such as PlayBuf , RecordBuf , Line , XLine , EnvGen , Linen , BufRd , BufWr , DbufRd , and the Buffer delay UGens set a 'done' flag when they are finished playing. This UGen echoes that flag as an explicit output signal when it is set to track a particular UGen. When the tracked UGen changes to done, the output signal changes from zero to one.

    src

    the UGen to track

    See also

    PlayBuf

    Line

    EnvGen

  117. final case class Dpoll(in: GE, label: String = "poll", run: GE = 1, trigId: GE = -1) extends SingleOut with DemandRated with HasSideEffect with IsIndividual with Product with Serializable

    A demand rate UGen printing the current output value of its input to the console when polled.

    A demand rate UGen printing the current output value of its input to the console when polled.

    in

    the signal you want to poll

    label

    a string or symbol to be printed with the polled value (init-time only)

    run

    if 1 the polling is active, if 0 it is inactive.

    trigId

    if greater then 0, a "/tr" OSC message is sent back to the client (similar to SendTrig )

    See also

    SendTrig

    Poll

  118. final case class Drand(seq: GE, length: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen which outputs random elements from a sequence.

    A demand-rate UGen which outputs random elements from a sequence. Drand allows duplicate elements to appear, whereas Dxrand forbids repetitions.

    seq

    A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.

    length

    The number of items polled from the sequence

    See also

    Demand

    Dser

    Dxrand

    Diwhite

  119. final case class Dreset(in: GE, reset: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen that, when triggered, resets the state of its in argument.

    A demand-rate UGen that, when triggered, resets the state of its in argument.

    in

    a demand-rate UGen, producing values which are passed through, and which will be reset by this UGen

    reset

    a demand-rate or any other UGen. When crossing from non-positive to positive, Dreset resets its in argument.

    See also

    Demand

    Duty

  120. final case class Dseq(seq: GE, repeats: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen which reproduces and repeats a sequence of values.

    A demand-rate UGen which reproduces and repeats a sequence of values.

    The arguments can be constant or any other ugens, where demand rate UGens are normally polled, proceeding to the next value when the sub-sequence ends.

    seq

    A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.

    repeats

    The number of repetitions of the entire sequence

    See also

    Demand

    Dser

  121. final case class Dser(seq: GE, length: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen which reproduces and repeats values of a sequence.

    A demand-rate UGen which reproduces and repeats values of a sequence. It is very similar to Dseq , the difference being that the length parameter specifies the length of output sequence, not the number of repetitions of the input sequence. The input sequence is repeated if length is greater than the length of the input sequence.

    The arguments can be constant or any other ugens, where demand rate UGens are normally polled, proceeding to the next value when the sub-sequence ends.

    seq

    A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.

    length

    The number of items polled from the sequence

    See also

    Demand

    Dseq

  122. final case class Dseries(start: GE = 0.0f, step: GE = 1.0f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen which produces an arithmetic (linear) series.

    A demand-rate UGen which produces an arithmetic (linear) series.

    The arguments can be constant or any other ugens.

    start

    the start value of the series

    step

    the incremental step by which the series changes. the step is added to the previous value on each demand.

    length

    the number of elements to produces (maybe be infinite)

    See also

    Dgeom

    Dseq

  123. final case class Dshuf(seq: GE, repeats: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen which outputs a randomly shuffled version of an input sequence.

    A demand-rate UGen which outputs a randomly shuffled version of an input sequence. The sequence is only shuffled once, thus when repeats is greater than one, the same randomized sequence will be repeated, until the UGen is reset. This happens for example, when it is nested inside a Dseq , as shown in the example "reshuffle".

    seq

    A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.

    repeats

    The number of repetitions of the entire sequence

    See also

    Demand

    Dser

    Drand

    Dshuf

  124. final case class Dstutter(n: GE, in: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
  125. final case class Dswitch(seq: GE, index: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
  126. final case class Dswitch1(seq: GE, index: GE) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
  127. final case class Dust(rate: Rate, density: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable

    A UGen generating random impulses with values ranging from 0 to +1 .

    A UGen generating random impulses with values ranging from 0 to +1 . The pulse duration is one sample for audio-rate and one block for control-rate operation.

    The approximate RMS energy is (density/sr).log2 * 3 - 4.8 where sr is the sample-rate. For example, at 44.1 kHz, a density of 1000 Hz yields an RMS of approx. -21.2 dB.

    density

    the average number of impulses per second

    See also

    Dust2

    TRand

    RandSeed

    ClipNoise

    GrayNoise

    CoinGate

  128. final case class Dust2(rate: Rate, density: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable

    A UGen generating random impulses with values ranging from -1 to +1 .

    A UGen generating random impulses with values ranging from -1 to +1 . The pulse duration is one sample for audio-rate and one block for control-rate operation.

    density

    the average number of impulses per second

    See also

    Dust

    TRand

    RandSeed

    ClipNoise

    CoinGate

  129. final case class Duty(rate: Rate, dur: GE = 1.0f, level: GE, reset: GE = 0, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with Product with Serializable

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input.

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input. A value from the level ugen is demanded and output according to a stream of duration values. When there is a trigger at the reset input, the level and the dur input are reset.

    dur

    the provider of time values. Can be a demand-rate ugen or any signal. The next poll is acquired after the previous duration.

    level

    a demand-rate ugen providing the output values.

    reset

    a trigger which resets the dur input (if demand-rated) and the the level input ugen. The reset input may also be a demand-rate ugen, in this case providing a stream of reset times.

    doneAction

    a doneAction that is evaluated when the duration stream ends.

    Note

    The argument order is different from its sclang counterpart.

    See also

    TDuty

    Demand

    DoneAction

  130. final case class Dwhite(lo: GE = 0.0f, hi: GE = 1.0f, length: GE = inf) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen that produces random decimal numbers with a constant spectral density, equivalent to WhiteNoise for audio- or control-rate.

    A demand-rate UGen that produces random decimal numbers with a constant spectral density, equivalent to WhiteNoise for audio- or control-rate.

    lo

    minimum value (inclusive)

    hi

    maximum value (inclusive)

    length

    length of the sequence or inf

    See also

    Diwhite

    Dbrown

    WhiteNoise

    Demand

  131. final case class Dxrand(seq: GE, length: GE = 1) extends SingleOut with DemandRated with IsIndividual with Product with Serializable

    A demand-rate UGen which outputs random elements from a sequence.

    A demand-rate UGen which outputs random elements from a sequence. Dxrand forbid repetitions, whereas Drand allows duplicate elements to appear.

    seq

    A multi-channel signal providing the values at each step of the sequence. Typically (but not necessarily) a sequence of constant values.

    length

    The number of items polled from the sequence

    See also

    Demand

    Dser

    Drand

    Dshuf

  132. final case class Env(startLevel: GE, segments: Seq[Segment], releaseNode: GE = -99, loopNode: GE = -99) extends EnvLike with Product with Serializable
  133. sealed trait EnvFactory[V] extends ProductReader[V]
  134. final case class EnvGen(rate: Rate, envelope: GE, gate: GE = 1, levelScale: GE = 1.0f, levelBias: GE = 0.0f, timeScale: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with HasDoneFlag with Product with Serializable

    An envelope generator UGen.

    An envelope generator UGen. It uses a break point description in its envelope input, typically coming from an Env object. The envelope may be re-triggered using the gate input. Upon start and upon re-triggering, the envelope , levelScale , levelBias and timeScale parameters are polled and remain constant for the duration of the envelope.

    To construct a manual envelope without the use of the Env class, the format should be as follows:

    val env = Seq[GE](startLevel, numSegments, releaseNode, loopNode,
    targetLevel1, duration1, curveType1, curvature1,
    targetLevel2, duration2, curveType2, curvature2,
    ...)

    Where the curve-type is one of Curve.step.id , Curve.lin.id , Curve.exp.id , etc. The curvature values are only relevant for the parametric curve type. The releaseNode and loopNode parameters are segment indices or the special value -99 indicating that there are no release or loop segments.

    Note: The actual minimum duration of a segment is not zero, but one sample step for audio rate and one block for control rate. This may result in asynchronicity when in two envelopes of different number of levels, the envelope times add up to the same total duration. Similarly, when modulating times, the new time is only updated at the end of the current segment; this may lead to asynchronicity of two envelopes with modulated times.

    envelope

    the description of the envelope break-points. Typically you pass an instance of Env which will then automatically expand to the correct format.

    gate

    triggers the envelope and holds it open while greater than zero. If the envelope is of fixed duration (e.g. Env.linen , Env.perc ), the gate argument is used as a simple trigger. If it contains a sustained segment (e.g. Env.adsr , Env.asr ), the envelope is held open until the gate becomes 0, at which point is released. If gate is less than zero, a release is enforced with duration -1.0 - gate .

    levelScale

    amplitude factor with which the nominal envelope is multiplied.

    levelBias

    amplitude offset which is added to the nominal envelope.

    timeScale

    time scale factor with which the envelope segment durations are multiplied.

    doneAction

    action to be performed when the envelope reaches its end point.

    See also

    Env

    IEnvGen

    Line

    XLine

    Linen

    Decay

  135. sealed trait EnvLike extends GE
  136. final case class ExpRand(lo: GE = 0.01f, hi: GE = 1.0f) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable

    A scalar UGen that generates a single random decimal value, using an exponential distribution from lo to hi .

    A scalar UGen that generates a single random decimal value, using an exponential distribution from lo to hi . Values lo and hi must both have the same sign and be non-zero.

    lo

    lower limit of the output range

    hi

    upper limit of the output range

    See also

    Rand

    TExpRand

    RandSeed

  137. final case class FBSineC(rate: Rate, freq: GE = Nyquist(), im: GE = 1.0f, fb: GE = 0.1f, a: GE = 1.1f, c: GE = 0.5f, xi: GE = 0.1f, yi: GE = 0.1f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = sin(im * y[n] + fb * x[n])
    y[n+1] = (a * y[n] + c) % 2pi

    This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0 , and a = 1 a normal sine wave results.

    freq

    Iteration frequency in Hertz

    im

    Index multiplier amount

    fb

    Feedback amount

    a

    Phase multiplier amount

    c

    Phase increment amount

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    FBSineN

    FBSineL

  138. final case class FBSineL(rate: Rate, freq: GE = Nyquist(), im: GE = 1.0f, fb: GE = 0.1f, a: GE = 1.1f, c: GE = 0.5f, xi: GE = 0.1f, yi: GE = 0.1f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = sin(im * y[n] + fb * x[n])
    y[n+1] = (a * y[n] + c) % 2pi

    This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.

    freq

    Iteration frequency in Hertz

    im

    Index multiplier amount

    fb

    Feedback amount

    a

    Phase multiplier amount

    c

    Phase increment amount

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    FBSineN

    FBSineC

  139. final case class FBSineN(rate: Rate, freq: GE = Nyquist(), im: GE = 1.0f, fb: GE = 0.1f, a: GE = 1.1f, c: GE = 0.5f, xi: GE = 0.1f, yi: GE = 0.1f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = sin(im * y[n] + fb * x[n])
    y[n+1] = (a * y[n] + c) % 2pi

    This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.

    freq

    Iteration frequency in Hertz

    im

    Index multiplier amount

    fb

    Feedback amount

    a

    Phase multiplier amount

    c

    Phase increment amount

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    FBSineL

    FBSineC

  140. final case class FFT(buf: GE, in: GE, hop: GE = 0.5f, winType: GE = 0, active: GE = 1, winSize: GE = 0) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A UGen performing short-time forward fourier transformations.

    A UGen performing short-time forward fourier transformations. In order to properly link the spectral ugens ( PV_... ), you should begin by using the output of each UGen (which is just the fft buffer identifier), and use that as buffer input of the next UGen. That way, the UGen graph is correctly sorted. E.g. IFFT(PV_...(FFT(buf, in))) .

    The UGen will initially output zero until the first FFT can be performed. This is the case after hop * fftSize . Thus, for a default fft buffer size of 1024 and a hop of 0.5, and for a default control block size of 64, for the first 1024*0.5/64 = 8 control blocks the UGen will output zero. This also implies that the first FFT in this case is performed on the first 512 samples of the in signal (prepended by 512 zeros). In other words, the first 'full' FFT of the input happens after fftSize/controlBlockSize cycles, no matter what hop size was chosen.

    If you use FFT for performing signal analysis and not phase vocoder effects, make sure you change the window type accordingly.

    buf

    The buffer to use for writing the FFT to. The size must be a power of two. Since FFT operates at control rate (also being a power of two), the buffer should probably be at least as long as the control block size. (init-time only)

    in

    The time domain signal to be transformed into the spectral domain.

    hop

    A factor determining the step size between successive FFTs. That is, FFTs are performed every fftSize * hop sample frames. The default of 0.5 means thus a 50% overlap, while a hope of 1.0 means no overlapping. Choosing 0.0 will most likely crash the server! (init-time only)

    winType

    The window function applied before each FFT is taken. The default of 0 is a sine window which is good for phase vocoder applications (using the PV_... UGens). For analysis applications, you may want to use -1 which is a rectangle window (effectively no windowing) or 1 which is a Hann window. A Hann window gives perfect overlap-add reconstruction for a hope size of 0.5 (or 0.25 etc.) (init-time only)

    active

    This parameter can be temporarily set to <= 0 to pause the FFT operation.

    winSize

    With the default value of zero, the window size equals the fft size. If you wish to perform zero padding, an explicit window size can be specified. (init-time only)

    See also

    IFFT

    FFTTrigger

  141. final case class FFTTrigger(buf: GE, hop: GE = 0.5f, polar: GE = 0) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal.

    A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal. This is useful if you want to provide a buffer whose content had already been transformed into the Fourier domain.

    buf

    the identifier of the buffer to use (init-time only)

    hop

    the hop size for timing triggers (init-time only)

    polar

    whether the complex buffer content is given in cartesian coordinates (0) or in polar coordinates (1) (init-time only)

  142. final case class FOS(rate: MaybeRate, in: GE, a0: GE = 0.0f, a1: GE = 0.0f, b1: GE = 0.0f) extends SingleOut with Product with Serializable

    A first order filter section UGen.

    A first order filter section UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:

    out(i) = a0 * in(i) + a1 * in(i-1) + b1 * out(i-1)

    Warning: there are bugs when the coefficients are modulated

    in

    input signal to be filtered

    See also

    SOS

    OnePole

    OneZero

  143. final case class FSinOsc(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable

    A sine oscillator UGen using a fast approximation.

    A sine oscillator UGen using a fast approximation. It uses a ringing filter and is less CPU expensive than SinOsc . However, the amplitude of the wave will vary with frequency. Generally the amplitude will go down when the frequency rises and it will go up as if the frequency is lowered.

    Warning: In the current implementation, the amplitude can blow up if the frequency is modulated by certain alternating signals (e.g. abruptly by TRand ).

    freq

    frequency in Hertz

    iphase

    initial phase of the oscillator in radians. This cannot be modulated. A value of 0.5 Pi means the output starts at +1. A value of 1.5 Pi means the output starts at -1, (init-time only)

    See also

    SinOsc

    SinOscFB

  144. final case class Flatten(elem: GE) extends GE.Lazy with Product with Serializable

    A graph element that flattens the channels from a nested multi-channel structure.

    A graph element that flattens the channels from a nested multi-channel structure.

    elem

    the element to flatten

  145. final case class Fold(rate: Rate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that constrains a signal to a given range, by "folding" values outside the range.

    A UGen that constrains a signal to a given range, by "folding" values outside the range. This is similar to the fold2 binary operator but permits both a lower range value lo and an upper range value hi .

    Folding can be understood as "reflecting" around the boundaries. For example, if the upper margin is 3, then if an input value exceeds 3, the excess is negatively reflected; 3.1 becomes 2.9, 3.2 becomes 2.8, etc. until the lower margin is reached again where another reflection occurs. Likewise, if the lower margin is 1, then if an input value falls below 1, the undershoot is reflected; 0.9 becomes 1.1, 0.8 becomes 1.2, etc. until the upper margin is reached again where another reflection occurs.

    in

    input signal to constrain

    lo

    lower margin of folding

    hi

    upper margin of folding

    See also

    Wrap

    Clip

  146. final case class FoldIndex(rate: Rate, buf: GE, in: GE = 0) extends SingleOut with IsIndividual with Product with Serializable

    A UGen which reads a single sample value from a buffer at a given index.

    A UGen which reads a single sample value from a buffer at a given index.

    It uses the in argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are "folded" inside the valid range. Folding means reflecting the excess at the valid range's boundaries.

    For example, if the buffer has four samples, index 4 is wrapped to index 2 (the excess beyond the maximum index of 3 is 4 - 3 = 1, and the excess is folded so that and 3 - 1 = 2), index 5 is folded to index 1, index -1 is folded to index 1, index -2 is folded to index 2, etc.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the Index UGen for details.

    buf

    The buffer to read from.

    in

    The sample index into the buffer. This is truncated to an integer automatically.

    See also

    Index

    WrapIndex

    IndexL

  147. final case class Formant(rate: Rate, fundFreq: GE = 440.0f, formFreq: GE = 1760.0f, bw: GE = 880.0f) extends SingleOut with Product with Serializable

    A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.

    A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.

    fundFreq

    Fundamental frequency in Hertz. Read at control-rate, so if input is audio-rate, it will be sub-sampled.

    formFreq

    Formant frequency in Hertz. This determines the overtone(s) most prominently perceived. Read at control-rate, so if input is audio-rate, it will be sub-sampled.

    bw

    Pulse width frequency in Hertz. Controls the bandwidth of the formant. Must be greater than or equal to fundFreq . Read at control-rate, so if input is audio-rate, it will be sub-sampled.

  148. final case class Formlet(rate: MaybeRate, in: GE, freq: GE = 440.0f, attack: GE = 1.0f, decay: GE = 1.0f) extends SingleOut with Product with Serializable

    A FOF-like resonant filter UGen.

    A FOF-like resonant filter UGen. Its impulse response is like that of a sine wave with a Decay2 envelope over it. It is possible to control the attack and decay times.

    Formlet is equivalent to:

    Ringz(in, freq, decay) - Ringz(in, freq, attack)

    The great advantage to this filter over FOF (Fonction d'onde formantique) is that there is no limit to the number of overlapping grains since the grain is just the impulse response of the filter.

    Note: Ringz and derived UGens Klank and Formlet produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.

    in

    input signal to be filtered

    freq

    resonant frequency in Hertz

    attack

    the 60 dB attack time in seconds

    decay

    the 60 dB decay time in seconds

    See also

    Ringz

    Resonz

    RLPF

    RHPF

  149. final case class Free(trig: GE, node: GE) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable

    A UGen that, when triggered, frees a given node.

    A UGen that, when triggered, frees a given node.

    This UGen outputs its trig input signal for convenience.

    trig

    the trigger to cause the action

    node

    the id of the target node to free upon receiving the trigger

    See also

    Pause

    FreeSelf

  150. final case class FreeSelf(trig: GE) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable

    A UGen that, when triggered, frees enclosing synth.

    A UGen that, when triggered, frees enclosing synth. It frees the enclosing synth when the input signal crosses from non-positive to positive.

    Note that if the trigger is initially high the UGen will not react. For example, FreeSelf.kr("foo".kr) will not work if the control is initially 1 . A work-around is to wrap the input in this case in a Trig object: FreeSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.

    This UGen outputs its input signal for convenience.

    trig

    the input signal which will trigger the action.

    See also

    Free

    PauseSelf

  151. final case class FreeSelfWhenDone(src: GE with HasDoneFlag) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable

    A UGen that, when its input UGen is finished, frees enclosing synth.

    A UGen that, when its input UGen is finished, frees enclosing synth. This is essentially a shortcut for FreeSelf.kr(Done.kr(src)) , so instead of providing a trigger signal it reads directly the done flag of an appropriate ugen (such as Line or PlayBuf ).

    This UGen outputs its input signal for convenience.

    src

    the input UGen which when finished will trigger the action.

    See also

    Free

    FreeSelf

    PauseSelfWhenDone

    Done

  152. final case class FreeVerb(in: GE, mix: GE = 0.33f, room: GE = 0.5f, damp: GE = 0.5f) extends SingleOut with AudioRated with Product with Serializable

    A monophonic reverb UGen.

    A monophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator.

    in

    input signal to reverberate

    mix

    dry/wet balance from zero (only dry) to one (only wet)

    room

    room size

    damp

    high frequency attenuation (1 is maximum attenuation)

    See also

    FreeVerb2

    GVerb

  153. final case class FreeVerb2(inL: GE, inR: GE, mix: GE = 0.33f, room: GE = 0.5f, damp: GE = 0.5f) extends MultiOut with AudioRated with Product with Serializable

    A stereophonic reverb UGen.

    A stereophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator. However, if the same input is used for left and right channel, the output channels are different and uncorrelated. There is also some cross-feed between the two channels.

    inL

    left channel of input signal to reverberate

    inR

    right channel of input signal to reverberate

    mix

    dry/wet balance from zero (only dry) to one (only wet)

    room

    room size

    damp

    high frequency attenuation (1 is maximum attenuation)

    See also

    FreeVerb

    GVerb

  154. final case class FreqShift(rate: Rate, in: GE, freq: GE = 0.0f, phase: GE = 0.0f) extends SingleOut with Product with Serializable

    A frequency shifting UGen.

    A frequency shifting UGen. It implements single sideband (SSB) amplitude modulation, also known as frequency shifting, but not to be confused with pitch shifting. Frequency shifting moves all the components of a signal by a fixed amount but does not preserve the original harmonic relationships.

    freq

    the shift amount in Hertz. Positive values shift upwards, negative values shift downwards.

    phase

    a phase parameter in radians (0 to 2 Pi).

    See also

    Hilbert

    PV_MagShift

  155. final case class Friction(rate: MaybeRate, in: GE, friction: GE = 0.5f, spring: GE = 0.414f, damp: GE = 0.313f, mass: GE = 0.1f, beltMass: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen implementing a physical model of a system with dry-friction.

    A UGen implementing a physical model of a system with dry-friction. A chaotic filter.

    The input is treated as the driving force in a physical model of a mass resting on a belt, which can stick or slip relative to the belt (depending on the friction between the two). The input represents the position of the belt, and the mass is held approximately in place by a spring and a damper. The output is the position of the mass, which in very high-friction situations will be exactly the same as the input – but when the other forces can overcome the friction then stick-and-slip alternations will typically occur.

    Note that DC offset will have a qualitative effect on the system's behaviour (because of the spring being stretched), so feel free to experiment with adding/removing DC.

    The model is inspired by the one considered in this research article: A. Luo and B. Gegg, Dynamics of a harmonically excited oscillator with dry-friction on a sinusoidally time-varying, traveling surface, International Journal of Bifurcation and Chaos, 16 (2006), pp. 3539–3566.

    To create the system studied in that paper (which analyses chaotic stick-and-slip oscillations), the input should be a sinusoid added to an ever-increasing ramp value. But for musical effects you can do different things.

    This is a third-party UGen (MCLDUGens).

  156. final case class GESeq(elems: IndexedSeq[GE]) extends GE with Product with Serializable
  157. final case class GVerb(in: GE, roomSize: GE = 10.0f, revTime: GE = 3.0f, damping: GE = 0.5f, inputBW: GE = 0.5f, spread: GE = 15.0f, dryLevel: GE = 1.0f, earlyRefLevel: GE = 0.7f, tailLevel: GE = 0.5f, maxRoomSize: GE = 300.0f) extends MultiOut with AudioRated with Product with Serializable

    A stereophonic reverb UGen.

    A stereophonic reverb UGen. It is based on the GVerb LADSPA effect by Juhana Sadeharju.

    Note: A CPU spike may occur when the synth is instantiated. Warning: The UGen has a bug which results in loud noise if the room size is increased during playback. It seems safe to start with a large room size and decrease the value during playing. Warning: The UGen may crash the server if roomSize becomes larger than maxRoomSize .

    roomSize

    Size of the virtual room in meters. It must not be greater than maxRoomSize . Note that quick changes in roomSize may result in zipper noise and an audible Doppler effect.

    revTime

    reverberation time in seconds.

    damping

    high frequency attenuation (1 is maximum attenuation)

    inputBW

    high frequency attenuation of the input signal (0 to 1)

    spread

    stereo spread of the reverb signal. Units?

    dryLevel

    amount of dry signal

    earlyRefLevel

    amount of early reflections

    tailLevel

    amount of late reverberation

    maxRoomSize

    maximum value that roomSize can take. This is used for the early reflection delay lines and is only read at initialization time. (init-time only)

    See also

    FreeVerb

    FreeVerb2

  158. final case class Gate(rate: MaybeRate, in: GE, gate: GE) extends SingleOut with Product with Serializable

    A gate or hold UGen.

    A gate or hold UGen. It allows the input signal value to pass when the gate argument is positive, otherwise it holds last value.

    Before the first high gate value is registered, this UGen outputs zero.

    in

    the input signal to gate

    gate

    the signal specifying whether to pass the input signal (when greater than zero) or whether to close the gate and hold the last value (when less than or equal to zero)

    See also

    Latch

  159. final case class GbmanL(rate: Rate, freq: GE = Nyquist(), xi: GE = 1.2f, yi: GE = 2.1f) extends SingleOut with Product with Serializable

    freq

    Iteration frequency in Hertz

    yi

    Initial value of y

  160. final case class GbmanN(rate: Rate, freq: GE = Nyquist(), xi: GE = 1.2f, yi: GE = 2.1f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = 1 - y[n] + abs(x[n])
    y[n+1] = x[n]

    The behavior of the system is only dependent on its initial conditions. Reference: Devaney, R. L. "The Gingerbreadman." Algorithm 3, 15-16, Jan. 1992.

    freq

    Iteration frequency in Hertz

    yi

    Initial value of y

    See also

    GbmanL

  161. final case class Gendy1(rate: Rate, ampDist: GE = 1.0f, durDist: GE = 1.0f, adParam: GE = 1.0f, ddParam: GE = 1.0f, minFreq: GE = 440.0f, maxFreq: GE = 660.0f, ampScale: GE = 0.5f, durScale: GE = 0.5f, initCPs: GE = 12, kNum: GE = 12) extends SingleOut with IsIndividual with Product with Serializable
  162. final case class Gendy2(rate: Rate, ampDist: GE = 1.0f, durDist: GE = 1.0f, adParam: GE = 1.0f, ddParam: GE = 1.0f, minFreq: GE = 440.0f, maxFreq: GE = 660.0f, ampScale: GE = 0.5f, durScale: GE = 0.5f, initCPs: GE = 12, kNum: GE = 12, a: GE = 1.17f, c: GE = 0.31f) extends SingleOut with IsIndividual with Product with Serializable
  163. final case class Gendy3(rate: Rate, ampDist: GE = 1.0f, durDist: GE = 1.0f, adParam: GE = 1.0f, ddParam: GE = 1.0f, freq: GE = 440.0f, ampScale: GE = 0.5f, durScale: GE = 0.5f, initCPs: GE = 12, kNum: GE = 12) extends SingleOut with IsIndividual with Product with Serializable
  164. final case class Goertzel(rate: Rate, in: GE, length: GE = 1024, freq: GE, hop: GE = 1.0f) extends MultiOut with Product with Serializable

    A UGen implementing the Goertzel algorithm which is a way to calculate the magnitude and phase of a signal's content at a single specified frequency.

    A UGen implementing the Goertzel algorithm which is a way to calculate the magnitude and phase of a signal's content at a single specified frequency. It is the equivalent of running an FFT, and then only looking at the output corresponding to a single bin. If one is only interested in a small number of bins, then it is more efficient; if one is interested in the majority of bins, one typically wants to do an FFT instead.

    This is a third-party UGen (MCLDUGens).

    length

    used in the same way as an FFT buffer size: The larger this value, the better the frequency resolution, but the worse the time resolution.

    freq

    target frequency in Hertz. (init-time only)

    hop

    same meaning as in the FFT UGen. Supply a value between zero and one, for the amount of overlap between Goertzel "frames". The default is a hop of 1 (meaning no overlap between frames). If you specify 0.5, then the analysis value will be produced twice as often; 0.25, four times as often. (init-time only)

  165. final case class GrainBuf(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, buf: GE, speed: GE = 1.0f, pos: GE = 0.0f, interp: GE = 2, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable

    A granular synthesis UGen taking sound stored in a buffer.

    A granular synthesis UGen taking sound stored in a buffer. Another buffer can be used to provide an amplitude envelope. The input sound buffer must be monophonic, but output may be multi-channel, using a panorama control.

    All arguments except numChannels and maxGrain are polled at grain creation (trigger) time.

    numChannels

    the number of channels to output. If 1 , a monophonic signal is returned and the pan argument is ignored.

    trig

    a control- or audio-rate trigger to start a new grain. For audio-rate, timing is sample frame accurate.

    dur

    grain duration in seconds

    buf

    buffer holding a mono audio signal portions of which are read as grains

    speed

    playback speed of the grain, where 1.0 is original rate, 0.5 is half speed etc.

    pos

    grain start position, where 0 is beginning and 1 is the end of the input buffer

    interp

    interpolation type when using pitch-shifting via speed . 1 for no interpolation (nearest sample), 2 for linear interpolation, and 4 for cubic interpolation.

    pan

    panning position when numChannels is greater than one. Equivalent to the pan position of Pan2 (for stereo output) or PanAz (for more than two channels)

    envBuf

    identifier of a buffer containing a signal to use for the grain envelope. The default value of -1 means that a built-in Hann envelope is used.

    maxGrains

    maximum number of overlapping grains that can be used at a given time. This value is set at the UGens init time and cannot be modified later. Lower value mean that less memory is used.

    See also

    TGrains

    PlayBuf

    PanAz

  166. final case class GrainFM(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, carFreq: GE = 440.0f, modFreq: GE = 200.0f, index: GE = 1.0f, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
  167. final case class GrainIn(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, in: GE, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
  168. final case class GrainSin(numChannels: Int = 1, trig: GE, dur: GE = 1.0f, freq: GE = 440.0f, pan: GE = 0.0f, envBuf: GE = -1, maxGrains: GE = 512) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
  169. final case class GrayNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable

    A noise generator UGen which results from flipping random bits in a word.

    A noise generator UGen which results from flipping random bits in a word. The resulting waveform looks like a sample-and-hold function with values between -1 and +1 (before being multiplied by mul ).

    This type of noise has a high RMS level relative to its peak to peak level. With approx. -4.8 dB, the RMS is the same as white noise, but the spectrum is emphasized towards lower frequencies.

    mul

    Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel mul argument will cause the generation of multiple independent noise generators.

    See also

    WhiteNoise

    PinkNoise

    BrownNoise

    ClipNoise

    RandSeed

    LFNoise0

    Dust

  170. final case class Greyhole(rate: Rate, inL: GE, inR: GE, delayTime: GE = 2.0f, damp: GE = 0.0f, size: GE = 1.0f, diff: GE = 0.707f, feedback: GE = 0.9f, modDepth: GE = 0.1f, modFreq: GE = 2.0f) extends MultiOut with Product with Serializable

    A complex echo-like effect UGen, inspired by the classic Eventide effect of a similar name.

    A complex echo-like effect UGen, inspired by the classic Eventide effect of a similar name. The effect consists of a diffuser (like a mini-reverb) connected in a feedback system with a long modulated delay-line. Excels at producing spacey washes of sound.

    Note: You may need to increase the server's real-time memory

    This is a third-party UGen (DEINDUGens).

    inL

    left input signal

    inR

    right input signal

    delayTime

    approximate delay time in seconds. (0.1..60)

    damp

    damping of high-frequencies as the delay decays. 0 is no damping, 1 is very strong damping (0..1)

    size

    scales the size of delay-lines, producing the impression of a larger or smaller space. Values below 1 can sound quite metallic. (0.5..5)

    diff

    shape of echo patterns produced by the diffuser. At very low values, the diffuser acts like a delay-line whose length is controlled by the size parameter. Medium values produce a slow build-up of echoes, giving the sound a reversed-like quality. Values of 0.707 or greater than produce smooth exponentially decaying echoes. (0..1)

    feedback

    amount of feedback through the system. Sets the number of repeating echoes. A setting of 1.0 produces infinite sustain. (0..1)

    modDepth

    depth of delay-line modulation. Use in combination with modFreq to produce chorus and pitch-variations in the echoes. (0..1)

    modFreq

    frequency of delay-line modulation. Use in combination with modDepth to produce chorus and pitch-variations in the echoes. (0..10)

    See also

    JPverb

  171. final case class HPF(rate: MaybeRate, in: GE, freq: GE = 440.0f) extends SingleOut with Product with Serializable

    A second order high pass filter UGen.

    A second order high pass filter UGen.

    in

    input signal to be filtered

    freq

    cutoff frequency in Hertz

    See also

    LPF

    BPF

    BRF

    RHPF

    HPZ1

  172. final case class HPZ1(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    A two point difference filter UGen.

    A two point difference filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) - in(i-1))

    Note: the filter's memory is initialized with the first input sample, so for HPZ1.ar(DC.ar(x)) the output will be zero, even at the beginning.

    in

    input signal to be filtered

    See also

    OneZero

    LPZ1

    Delay1

  173. final case class HPZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    three point difference filter UGen.

    three point difference filter UGen. Implements the formula :

    out(i) = 0.25 * (in(i) - 2 * in(i-1) + in(i-2))
    in

    input signal to be filtered

    See also

    LPZ1

    HPZ2

    BPZ2

    BRZ2

  174. final case class Hasher(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    A UGen that returns a unique output value from -1 to +1 for each input value according to a hash function.

    A UGen that returns a unique output value from -1 to +1 for each input value according to a hash function. The same input value will always produce the same output value. The input values can have any range.

    in

    input to calculate the hash function for

  175. final case class HenonC(rate: Rate, freq: GE = Nyquist(), a: GE = 1.4f, b: GE = 0.3f, x0: GE = 0.0f, x1: GE = 0.0f) extends SingleOut with Product with Serializable

    A cubic-interpolating sound generator based on the difference equation:

    A cubic-interpolating sound generator based on the difference equation:

    x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]

    This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.

    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    x0

    Initial value of x

    x1

    Second value of x

    See also

    HenonL

    HenonC

  176. final case class HenonL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.4f, b: GE = 0.3f, x0: GE = 0.0f, x1: GE = 0.0f) extends SingleOut with Product with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]

    This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.

    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    x0

    Initial value of x

    x1

    Second value of x

    See also

    HenonL

    HenonC

  177. final case class HenonN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.4f, b: GE = 0.3f, x0: GE = 0.0f, x1: GE = 0.0f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]

    This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.

    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    x0

    Initial value of x

    x1

    Second value of x

    See also

    HenonL

    HenonC

  178. final case class Hilbert(rate: Rate, in: GE) extends MultiOut with Product with Serializable

    A Hilbert transform UGen.

    A Hilbert transform UGen. This transformation produces two signals from a given input with identical frequency content, but with their respective phases shifted to be 90 degrees apart (0.5 pi radians).

    The two signals output by Hilbert correspond to the real and imaginary part of the complex transformed signal. Due to the method used (an IIR filter), distortion occurs in the upper octave of the frequency spectrum.

    The transform can be used to implemented single-side-band (SSB) modulation, but a dedicated UGen FreqShift is already provided for this case.

    in

    input signal to be processed

    See also

    FreqShift

  179. final case class Hopf(rate: MaybeRate, in: GE, coupling: GE, radius: GE = 1.0f) extends MultiOut with Product with Serializable

    A UGen based on Hopf bifurcations that tries to synchronize to an input signal.

    A UGen based on Hopf bifurcations that tries to synchronize to an input signal.

    This is a third-party UGen (kuramoto).

    in

    Input signal (force) to track.

    coupling

    Strength of coupling.

    radius

    Limit cycle radius (amplitude attractor).

    See also

    Kuramoto

  180. final case class IEnv(startLevel: GE, segments: Seq[Segment], offset: GE = 0f) extends EnvLike with Product with Serializable
  181. final case class IEnvGen(rate: Rate, envelope: GE, index: GE) extends SingleOut with Product with Serializable

    Envelope generator UGen with random access index pointer into the break-point function.

    Envelope generator UGen with random access index pointer into the break-point function.

    Warning: The envelope must be generated using IEnv not Env . IEnv has a completely different format. Using the wrong format ( Env ) may crash the server.

    To construct a manual envelope without the use of the IEnv class, the format should be as follows:

    val env = Seq[GE](offset, startLevel, numSegments, totalDuration,
    duration1, curveType1, curvature1, targetLevel1,
    duration2, curveType2, curvature2, targetLevel2
    ...)
    envelope

    the description of the envelope break-points. Typically you pass an instance of IEnv which will then automatically expand to the correct format.

    index

    index point into the envelope, given as time in seconds

    See also

    IEnv

    EnvGen

  182. final case class IFFT(rate: Rate, chain: GE, winType: GE = 0, winSize: GE = 0) extends SingleOut with IsIndividual with Product with Serializable

    A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.

    A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.

    chain

    reference to the spectral signal, returned as a buffer-identifier from FFT or the PV_... UGens.

    winType

    The window function applied after each IFFT is taken. The default of 0 is a sine window, -1 is a rectangle window, and 1 is a Hann window. (init-time only)

    winSize

    With the default value of zero, the window size equals the fft size. If you wish to perform zero padding, an explicit window size can be specified. (init-time only)

    See also

    FFT

  183. final case class IRand(lo: GE = 0, hi: GE = 127) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable

    A scalar UGen that generates a single random integer value, using a uniform distribution from lo to hi .

    A scalar UGen that generates a single random integer value, using a uniform distribution from lo to hi .

    lo

    lower limit of the output range

    hi

    upper limit of the output range (inclusive)

    See also

    Rand

    TIRand

    ExpRand

    RandSeed

  184. final case class Impulse(rate: Rate, freq: GE = 440.0f, phase: GE = 0.0f) extends SingleOut with Product with Serializable

    A non-band-limited generator UGen for single sample impulses.

    A non-band-limited generator UGen for single sample impulses.

    freq

    frequency in Hertz. A value of zero can be used to generate a singular impulse.

    phase

    phase offset in cycles (0 to 1)

    See also

    LFPulse

    Dust

    Blip

  185. final case class In(rate: Rate, bus: GE, numChannels: Int = 1) extends MultiOut with IsIndividual with Product with Serializable

    A UGen that reads a signal from a bus.

    A UGen that reads a signal from a bus. Whether an audio- or control-bus is used depends on the rate of the UGen.

    In.ar and In.kr behave differently with respect to signals left on the bus in the previous calculation cycle (control block): In.ar can access audio signals that were generated in the current calculation cycle by synths appearing earlier in the node tree. It does not read signals produced by nodes in the previous calculation cycle (i.e. synths appearing later in the node tree), the input would instead be zero. To allow such "feedback", InFeedback can be used.

    In contrast, In.kr does not distinguish between "new" and "old" data: It will always read the most recent value found on the bus, whether it was generated earlier in this calculation cycle, left over from the last one, or set before by the client.

    Note: The server uses the first NumOutputBuses channels to write to the sound card, followed by another NumInputBuses to read from the sound card. For convenience, the pseudo-UGens PhysicalOut and PhysicalIn can be used.

    bus

    index of the bus to read from. When numChannels is greater than one, the other channels or read from the adjacent indices.

    numChannels

    number of channels to read

    See also

    Out

    PhysicalIn

    InFeedback

    LocalIn

    Bus

  186. final case class InFeedback(bus: GE, numChannels: Int = 1) extends MultiOut with AudioRated with IsIndividual with Product with Serializable

    A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.

    A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.

    Audio buses adhere to the concept of a cycle timestamp, which increases for each audio block calculated. When the various output ugens ( Out , OffsetOut , XOut ) write data to a bus, they mix it with any data from the current cycle, but overwrite any data from the previous cycle. ( ReplaceOut overwrites all data regardless.) Thus depending on node order and what synths are writing to the bus, the data on a given bus may be from the current cycle or be one cycle old at the time of reading.

    In.ar checks the timestamp of any data it reads in and zeros any data from the previous cycle (for use within that node; the data remains on the bus). This is fine for audio data, as it avoids feedback, but for control data it is useful to be able to read data from any place in the node order. For this reason In.kr also reads data that is older than the current cycle.

    In some cases one might also want to read audio from a node later in the current node order. This can be achieved with InFeedback . It reads from the previous cycle, and hence introduces a delay of one block size, which by default is 64 sample frames (equal to about 1.45 ms at 44.1 kHz sample rate).

    Note that no delay occurs when the bus contains a signal which has been written already in the current cycle. The delay is only introduced when no present signal exists.

    bus

    the index of the audio bus to read in from.

    numChannels

    the number of channels (i.e. adjacent buses) to read in. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs.

    See also

    In

    LocalIn

    ControlDur

  187. final case class InRange(rate: Rate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that tests if a signal is within a given range.

    A UGen that tests if a signal is within a given range. If in >= lo and in <= hi , outputs 1.0, otherwise outputs 0.0.

    in

    input signal to test

    lo

    lower margin of test range (inclusive)

    hi

    upper margin of test range (inclusive)

    See also

    InRect

    Clip

    Schmidt

  188. final case class InRect(rate: Rate, x: GE, y: GE, left: GE = 0.0f, top: GE = 0.0f, right: GE = 1.0f, bottom: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that tests if two signals lie both within a given ranges.

    A UGen that tests if two signals lie both within a given ranges. The two input signals can be understood as horizontal and vertical coordinates, therefore the test become one that determines whether the input is within a given "rectangle".

    If x >= left and x <= right and y > top and y <= bottom , outputs 1.0, otherwise outputs 0.0.

    x

    "horizontal" signal to test

    y

    "vertical" signal to test

    left

    lower margin of horizontal test range (inclusive)

    top

    lower margin of vertical test range (inclusive)

    right

    upper margin of horizontal test range (inclusive)

    bottom

    upper margin of vertical test range (inclusive)

    See also

    InRange

    Clip

  189. final case class InTrig(bus: GE, numChannels: Int = 1) extends MultiOut with ControlRated with IsIndividual with Product with Serializable

    A UGen which generates a trigger anytime a control bus is set.

    A UGen which generates a trigger anytime a control bus is set.

    Any time the bus is "touched" i.e. has its value set (using "/c_set" etc.), a single impulse trigger will be generated. Its amplitude is the value that the bus was set to. Note that if a signal is continuously written to that bus, for instance using Out.kr , only one initial trigger is generated once that ugen starts writing, but no successive triggers are generated.

    bus

    the index of the control bus to read in from.

    numChannels

    the number of channels (i.e. adjacent buses) to read in. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs.

    See also

    In

    TrigControl

  190. final case class Index(rate: Rate, buf: GE, in: GE = 0) extends SingleOut with IsIndividual with Product with Serializable

    A UGen which reads a single sample value from a buffer at a given index.

    A UGen which reads a single sample value from a buffer at a given index.

    It uses the in argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are clipped to the valid range.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, index 0 corresponds to frame 0, channel 0, index 1 correspond to frame 0, channel 1, index 2 corresponds to frame 1, channel 0, and index 3 corresponds to frame 1, channel 1.

    buf

    The buffer to read from.

    in

    The sample index into the buffer. This is truncated to an integer automatically.

    See also

    BufRd

    WrapIndex

    IndexL

    IndexInBetween

    DetectIndex

  191. final case class IndexInBetween(rate: Rate, buf: GE, in: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal.

    A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal. The output index is a decimal whose fractional part is suitable for linearly interpolating between the buffer slot values.

    For example, if the Buffer contains values 3, 21, 25, 26 and the input signal has the value 22, then the output will be 1.25, because the value 22 is in-between the values stored at indices 1 and 2 and the linear location of 22 is one-quarter of the way along the interval between them: 21 * (1 - 0.25) + 25 * (1 - 0.75) = 22.

    If the input value is smaller than the first sample, the output will be zero. If the input value is larger than any sample in the buffer, the output will be the buffer size minus one.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, and the algorithm finds the frame 1 in channel 0, the reported index is 2 (frame * numChannels + channel).

    IndexInBetween is the complement of the IndexL UGen.

    buf

    The buffer to search in.

    in

    The input signal whose value is looked up in the buffer.

    See also

    DetectIndex

    IndexL

  192. final case class IndexL(rate: Rate, buf: GE, in: GE = 0) extends SingleOut with IsIndividual with Product with Serializable

    A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.

    A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.

    It uses the in argument as index into the buffer. Out-of-range index values are clipped to the valid range. If the index has a fractional part, it is used to interpolate between the buffer index at the floor and the buffer index at the ceiling of the index argument.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the Index UGen for details.

    buf

    The buffer to read from.

    in

    The sample index into the buffer. This can have a fractional part.

    See also

    Index

    IndexInBetween

  193. final case class InsideOut(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    A UGen that produces distortion by subtracting the input signal's magnitude from 1.

    A UGen that produces distortion by subtracting the input signal's magnitude from 1.

    If the input is positive, it outputs (+1 - input). If the input is negative, it outputs (-1 - input).

    This is a third-party UGen (MCLDUGens).

    in

    input signal to be distorted

  194. final case class Integrator(rate: MaybeRate, in: GE, coeff: GE = 1.0f) extends SingleOut with Product with Serializable

    A filter UGen to integrate an input signal with a leak.

    A filter UGen to integrate an input signal with a leak. Implements the formula :

    out(i) = in(i) + (coef * out(i-1))

    Warning: there are bugs when the coefficient is modulated

    in

    input signal to be processed

    coeff

    the leak coefficient. Should be between -1 and +1

    See also

    OnePole

    HPZ1

    LPZ1

  195. final case class JPverb(rate: Rate, inL: GE, inR: GE, revTime: GE = 1.0f, damp: GE = 0.0f, size: GE = 1.0f, earlyDiff: GE = 0.707f, modDepth: GE = 0.1f, modFreq: GE = 2.0f, low: GE = 1.0f, mid: GE = 1.0f, high: GE = 1.0f, lowCut: GE = 500.0f, highCut: GE = 2000.0f) extends MultiOut with Product with Serializable

    An algorithmic reverb UGen, inspired by the lush chorused sound of certain vintage Lexicon and Alesis reverberation units.

    An algorithmic reverb UGen, inspired by the lush chorused sound of certain vintage Lexicon and Alesis reverberation units. Designed to sound great with synthetic sound sources, rather than sound like a realistic space.

    Note: You may need to increase the server's real-time memory

    This is a third-party UGen (DEINDUGens).

    inL

    left input signal to be reverberated

    inR

    right input signal to be reverberated

    revTime

    approximate reverberation time in seconds (T60 - the time for the reverberation to decay 60 dB). Does not effect early reflections. (0.1..60)

    damp

    damping of high-frequencies as the reverberation decays. 0 is no damping, 1 is very strong damping (0..1)

    size

    scales the size of delay-lines, producing the impression of a larger or smaller space. Values below 1 can sound quite metallic. (0.5..5)

    earlyDiff

    shape of early reflections. Values of > 0.707 produce smooth exponential decay. Lower values produce a slower build-up of echoes. (0..1)

    modDepth

    depth of delay-line modulation in sample frames. Use in combination with modFreq to set amount of chorusing within the structure. (0..50)

    modFreq

    frequency of delay-line modulation. Use in combination with modDepth to set amount of chorusing within the structure. (0..10)

    low

    multiplier for the reverberation time within the low band. (0..1)

    mid

    multiplier for the reverberation time within the mid band. (0..1)

    high

    multiplier for the reverberation time within the high band. (0..1)

    lowCut

    frequency in Hz at which the crossover between the low and mid bands of the reverberation occurs. (100..6000)

    highCut

    frequency in Hz at which the crossover between the mid and high bands of the reverberation occurs. (1000..10000)

    See also

    FreeVerb2

    GVerb

    Greyhole

  196. final case class K2A(in: GE) extends SingleOut with AudioRated with Product with Serializable

    A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation.

    A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation. The current control input value is always reached in at the beginning of the subsequent control block. A special case is the initialization which begins directly at the first control input value (therefore, the first control block of the audio-rate output is is always constant.)

    For example, if the block size is 64, and the first three input values are -0.5, 0.6, 0.3, then the output signal will be 65 samples of value -0.5, followed by a linear ramp of 64 samples towards 0.6, followed by a linear ramp of 64 samples to towards 0.3.

    in

    control-rate signal to convert

    See also

    A2K

    T2A

    DC

  197. final case class KeyState(keyCode: GE, lo: GE = 0.0f, hi: GE = 1.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable

    A UGen that detects a specific keyboard stroke.

    A UGen that detects a specific keyboard stroke. When the given key is not pressed, the lo value is output, while the key is pressed the hi value is output. If lag is greater than zero, a Lag -type operation is applied for a smoother transition between lo and hi .

    keyCode

    hardware code for the key to monitor. This is likely platform dependent. For example, on Linux, key-codes 24 to 29 correspond to 'Q', 'W', 'E', 'R', 'T', 'Y'.

    lo

    value output when the currently pressed does not match the code

    hi

    value output when the currently pressed does match the code

    lag

    60 dB lag time in seconds.

    See also

    MouseX

    MouseY

    MouseButton

  198. final case class KeyTrack(chain: GE, keyDecay: GE = 2.0f, chromaLeak: GE = 0.5f) extends SingleOut with ControlRated with IsIndividual with Product with Serializable

    A (12TET major/minor) key tracker UGen.

    A (12TET major/minor) key tracker UGen. It is based on a pitch class profile of energy across FFT bins and matching this to templates for major and minor scales in all transpositions. It assumes a 440 Hz concert A reference. Output is 0-11 C major to B major, 12-23 C minor to B minor.

    chain

    the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, with a standard hop of half FFT size, the FFT size should be 4096 at 44.1 or 48 kHz and 8192 at 88.2 or 96 kHz sampling rate.

    keyDecay

    Number of seconds for the influence of a window on the final key decision to decay by 40dB (to 0.01 its original value). Can be control-rate modulated.

    chromaLeak

    Each frame, the chroma values are set to the previous value multiplied by this chroma decay. 0.0 will start each frame afresh with no memory. Can be control-rate modulated.

  199. final case class Klang(specs: GE, freqScale: GE = 1.0f, freqOffset: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable
  200. final case class KlangSpec(freq: GE, amp: GE = 1, decay: GE = 0) extends GE with Product with Serializable
  201. final case class Klank(specs: GE, in: GE, freqScale: GE = 1.0f, freqOffset: GE = 0.0f, decayScale: GE = 1.0f) extends SingleOut with AudioRated with Product with Serializable

    Klank is a UGen of a bank of fixed frequency resonators which can be used to simulate the resonant modes of an object.

    Klank is a UGen of a bank of fixed frequency resonators which can be used to simulate the resonant modes of an object. Each mode is given a ring time, which is the time for the mode to decay by 60 dB.

    Note: Ringz and derived UGens Klank and Formlet produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.

    specs

    (init-time only)

    freqScale

    (init-time only)

    freqOffset

    (init-time only)

    decayScale

    (init-time only)

    See also

    Klang

    Ringz

  202. final case class Kuramoto(rate: Rate, mode: GE = 0.0, initPhase: GE = 0.0, incr: GE = 0.0, extPhase: GE = 0.0, intCoupling: GE, extCoupling: GE = 0.0) extends MultiOut with Product with Serializable

    A UGen that implements the Kuramoto model of synchronization of coupled oscillators.

    A UGen that implements the Kuramoto model of synchronization of coupled oscillators.

    mode

    0: all oscillators are coupled; 1: neighboring oscillators are coupled (they can be imagined to form a ring); 2: neighboring oscillators are negatively coupled; 3: like 2 but discarding current phases (?); 4: like 2 but using cosine instead of sine mapping

  203. final case class LFClipNoise(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument. The difference to LFClipNoise is that this UGen quantizes time to the nearest integer division of the sample-rate, and the frequency input is only polled at the moment a new output value is scheduled.

    freq

    rate at which to generate random values.

    See also

    ClipNoise

    LFNoise0

    LFDClipNoise

  204. final case class LFCub(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable

    A sine-like oscillator UGen with a shape made of two cubic pieces.

    A sine-like oscillator UGen with a shape made of two cubic pieces. It is smoother than LFPar .

    freq

    oscillator frequency in Hertz

    iphase

    initial phase in cycle (0 to 1) (init-time only)

    See also

    LFPar

  205. final case class LFDClipNoise(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument. The difference to LFClipNoise is that this UGen does not quantize time and recovers fast from frequency input changes.

    freq

    rate at which to generate random values.

    See also

    LFClipNoise

    LFNoise0

    LFNoise1

    CoinGate

    Schmidt

    GrayNoise

  206. final case class LFDNoise0(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A dynamic step noise UGen.

    A dynamic step noise UGen. Like LFNoise0 , it generates abruptly changing random values between -1 and +1 at a rate given by the freq argument, with two differences: There is no time quantization, and it there is fast recovery from low freq values.

    In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.

    If very high or very low frequencies are not needed, or fixed frequencies are used, LFNoise0 is more efficient.

    freq

    rate at which to generate random values.

    See also

    LFNoise0

    LFDNoise1

    LFDNoise3

    TRand

  207. final case class LFDNoise1(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A dynamic ramp noise UGen.

    A dynamic ramp noise UGen. Like LFNoise1 , it generates linearly interpolated random values between -1 and +1 at a rate given by the freq argument, with two differences: There is no time quantization, and it there is fast recovery from low freq values.

    In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.

    If very high or very low frequencies are not needed, or fixed frequencies are used, LFNoise1 is more efficient.

    freq

    rate at which to generate random values.

    See also

    LFNoise1

    LFDNoise0

    LFDNoise3

    Ramp

  208. final case class LFDNoise3(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A dynamic ramp noise UGen.

    A dynamic ramp noise UGen. It is similar to LFNoise2 , with three differences: It uses cubic instead of quadratic interpolation for the random values between -1 and +1 at a rate given by the freq argument. There is no time quantization, and it there is fast recovery from low freq values.

    In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.

    freq

    rate at which to generate random values.

    See also

    LFNoise2

    LFDNoise0

    LFDNoise1

  209. final case class LFGauss(rate: Rate, dur: GE = 1.0f, width: GE = 0.1f, phase: GE = 0.0f, loop: GE = 1, doneAction: GE = doNothing) extends SingleOut with Product with Serializable

    A non-band-limited gaussian function oscillator UGen.

    A non-band-limited gaussian function oscillator UGen. Output ranges from minVal to 1. It implements the formula:

    f(x) = exp((x - phase).squared / (-2 * width.squared))

    where x is to vary in the range -1 to 1 over the period dur . minVal is the initial value at -1. E.g. for default parameters, it is exp(-50) or roughly zero.

    dur

    duration in seconds of a full -1 <= x <= 1 cycle, or the reciprocal of the frequency

    width

    relative width of the bell. Best to keep below 0.25 when used as envelope.

    phase

    phase offset

    loop

    if greater than zero, the UGen oscillates. Otherwise it calls doneAction after one cycle.

    doneAction

    evaluated after cycle completes

  210. final case class LFNoise0(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A step noise UGen.

    A step noise UGen. It generates abruptly changing random values between -1 and +1 at a rate given by the freq argument.

    The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant LFDNoise0 has precise frequency and reacts to frequency changes instantly.

    freq

    rate at which to generate random values.

    See also

    LFDNoise0

    LFNoise1

    LFNoise2

    TRand

    WhiteNoise

    Dust

    RandSeed

  211. final case class LFNoise1(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A ramp noise UGen.

    A ramp noise UGen. It generates line segments whose start and end points are chosen randomly between -1 and +1 . New breakpoints are generated at a specified frequency.

    The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant LFDNoise1 has precise frequency and reacts to frequency changes instantly.

    freq

    rate at which to generate new breakpoints.

    See also

    LFDNoise1

    LFNoise0

    LFNoise2

    Ramp

  212. final case class LFNoise2(rate: Rate, freq: GE = 500.0f) extends SingleOut with IsIndividual with Product with Serializable

    A quadratically interpolating noise UGen.

    A quadratically interpolating noise UGen. This interpolation happens between breakpoints chosen randomly between -1 and +1 at a specified frequency.

    The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant LFDNoise3 has precise frequency and reacts to frequency changes instantly.

    Note: Due to the interpolation, the output values can occasionally extend beyond the normal range of -1 to +1, if the frequency varies in certain ways.

    freq

    rate at which to generate new breakpoints.

    See also

    LFDNoise3

    LFNoise0

    LFNoise1

  213. final case class LFPar(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable

    A sine-like oscillator UGen with a shape made of two parabolas.

    A sine-like oscillator UGen with a shape made of two parabolas. It has audible odd harmonics and is non-band-limited. Its output ranges from -1 to +1.

    freq

    oscillator frequency in Hertz

    iphase

    initial phase in cycle (0 to 1) (init-time only)

    See also

    LFCub

  214. final case class LFPulse(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f, width: GE = 0.5f) extends SingleOut with Product with Serializable

    A non-band-limited pulse oscillator UGen.

    A non-band-limited pulse oscillator UGen. Outputs a high value of one and a low value of zero.

    freq

    oscillator frequency in Hertz

    iphase

    initial phase offset in cycles ( 0..1 ). If you think of a buffer of one cycle of the waveform, this is the starting offset into this buffer. Hence, an iphase of 0.25 means that you will hear the first impulse after 0.75 periods! If you prefer to specify the perceived delay instead, you could use an iphase of -0.25 + 1 which is more intuitive. Note that the phase is not automatically wrapped into the range of 0..1 , so putting an iphase of -0.25 currently results in a strange initial signal which only stabilizes to the correct behaviour after one period! (init-time only)

    width

    pulse width duty cycle from zero to one. If you want to specify the width rather in seconds, you can use the formula width = freq * dur , e.g. for a single sample impulse use width = freq * SampleDur.ir .

    See also

    Pulse

  215. final case class LFSaw(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable

    A sawtooth oscillator UGen.

    A sawtooth oscillator UGen. The oscillator is creating an aliased sawtooth, that is it does not use band-limiting. For a band-limited version use Saw instead. The signal range is -1 to +1.

    freq

    oscillator frequency in Hertz

    iphase

    initial phase offset. For efficiency reasons this is a value ranging from -1 to 1 (thus equal to the initial output value). Note that a phase of zero (default) means the wave starts at 0 and rises to +1 before jumping down to -1. Use a phase of 1 to have the wave start at -1. (init-time only)

    See also

    Saw

  216. final case class LFTri(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable

    A triangle oscillator UGen designed for low frequency control signals (being non-band-limited).

    A triangle oscillator UGen designed for low frequency control signals (being non-band-limited). The output varies from -1 to 1.

    With an initial phase of zero, the oscillator begins at 0, rises to 1, then falls to -1 and goes back to zero after one complete phase. With an initial phase of 1 (corresponding to 90 degrees), the oscillator begins at 1 and then falls to -1. With an initial phase of 3 (or 270 degrees), the oscillator begins at -1 and then rises to 1.

    freq

    frequency in Hertz

    iphase

    initial phase of the oscillator. A full phase (2 Pi or 360 degrees) is represented by an iphase value of 4. The initial phase cannot be modulated. (init-time only)

  217. final case class LPF(rate: MaybeRate, in: GE, freq: GE = 440.0f) extends SingleOut with Product with Serializable

    A second order low pass filter UGen.

    A second order low pass filter UGen.

    in

    input signal to be filtered

    freq

    cutoff frequency in Hertz

    See also

    HPF

    BPF

    BRF

    RLPF

    LPZ1

  218. final case class LPZ1(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    two point average filter UGen.

    two point average filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) + in(i-1))
    in

    input signal to be filtered

    See also

    OnePole

    HPZ1

    LPZ2

    Integrator

    Delay1

  219. final case class LPZ2(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    three point average filter UGen.

    three point average filter UGen. Implements the formula :

    out(i) = 0.25 * (in(i) + 2 * in(i-1) + in(i-2))
    in

    input signal to be filtered

    See also

    LPZ1

    HPZ2

    BPZ2

    BRZ2

  220. final case class Lag(rate: MaybeRate, in: GE, time: GE = 0.1f) extends SingleOut with Product with Serializable

    An exponential lag UGen.

    An exponential lag UGen. This is essentially the same as OnePole except that instead of supplying the coefficient directly, it is calculated from a 60 dB lag time. This is the time required for the filter to converge to within 0.01 % of a value. This is useful for smoothing out control signals.

    in

    input signal.

    time

    60 dB lag time in seconds.

    See also

    OnePole

    LagUD

    Lag2

    Ramp

  221. final case class Lag2(rate: MaybeRate, in: GE, time: GE = 0.1f) extends SingleOut with Product with Serializable

    A cascaded exponential lag UGen.

    A cascaded exponential lag UGen. Lag2.kr(in, time) is equivalent to Lag.kr(Lag.kr(in, time), time) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factor once instead of twice.

    in

    input signal.

    time

    60 dB lag time in seconds.

    See also

    Lag

    Lag2UD

    Lag3

  222. final case class Lag2UD(rate: MaybeRate, in: GE, timeUp: GE = 0.1f, timeDown: GE = 0.1f) extends SingleOut with Product with Serializable

    A cascaded exponential lag UGen with separate inputs for up and down slope.

    A cascaded exponential lag UGen with separate inputs for up and down slope. Lag2UD.kr(in, up, down) is equivalent to LagUD.kr(LagUD.kr(in, up, down), up, down) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factors once instead of twice.

    in

    input signal.

    timeUp

    60 dB lag time in seconds effective during a rising slope in the input signal

    timeDown

    60 dB lag time in seconds effective during a falling slope in the input signal

    See also

    LagUD

    Lag2

    Lag3UD

  223. final case class Lag3(rate: MaybeRate, in: GE, time: GE = 0.1f) extends SingleOut with Product with Serializable

    A cascaded exponential lag UGen.

    A cascaded exponential lag UGen. Lag3.kr(in, time) is equivalent to Lag.kr(Lag.kr(Lag.kr(Lag.kr(in, time), time), time) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factor once instead of three times.

    in

    input signal.

    time

    60 dB lag time in seconds.

    See also

    Lag

    Lag3UD

    Lag2

  224. final case class Lag3UD(rate: MaybeRate, in: GE, timeUp: GE = 0.1f, timeDown: GE = 0.1f) extends SingleOut with Product with Serializable

    A cascaded exponential lag UGen with separate inputs for up and down slope.

    A cascaded exponential lag UGen with separate inputs for up and down slope. Lag3UD.kr(in, up, down) is equivalent to LagUD.kr(LagUD.kr(LagUD.kr(in, up, down), up, down), up, down) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factors once instead of three times.

    in

    input signal.

    timeUp

    60 dB lag time in seconds effective during a rising slope in the input signal

    timeDown

    60 dB lag time in seconds effective during a falling slope in the input signal

    See also

    LagUD

    Lag3

    Lag2UD

  225. final case class LagIn(rate: Rate, bus: GE, numChannels: Int = 1, time: GE = 0.1f) extends MultiOut with IsIndividual with Product with Serializable

    A UGen that reads a signal from a control bus and applies a lag filter to it.

    A UGen that reads a signal from a control bus and applies a lag filter to it. This is essentially the same as Lag.kr(In.kr(...), time) .

    bus

    index of the bus to read from. When numChannels is greater than one, the other channels or read from the adjacent indices.

    numChannels

    number of channels to read

    time

    60 dB lag time in seconds.

    See also

    In

    Out

    Lag

  226. final case class LagUD(rate: MaybeRate, in: GE, timeUp: GE = 0.1f, timeDown: GE = 0.1f) extends SingleOut with Product with Serializable

    An exponential lag UGen with separate inputs for up and down slope.

    An exponential lag UGen with separate inputs for up and down slope. This is essentially the same as Lag except that you can supply a different 60 dB time for when the signal goes up, from when the signal goes down.

    in

    input signal.

    timeUp

    60 dB lag time in seconds effective during a rising slope in the input signal

    timeDown

    60 dB lag time in seconds effective during a falling slope in the input signal

    See also

    Lag

    Lag2UD

  227. final case class LastValue(rate: Rate, in: GE, thresh: GE = 0.01f) extends SingleOut with Product with Serializable

    A sample-and-hold UGen that outputs the last value before the input changed more than a threshold.

    A sample-and-hold UGen that outputs the last value before the input changed more than a threshold. Change is based on the absolute of the differentiation of input signal.

    in

    input signal to analyze and filter

    thresh

    threshold below which the input sign

    See also

    Slew

  228. final case class Latch(rate: Rate, in: GE, trig: GE = 1) extends SingleOut with Product with Serializable

    A sample-and-hold UGen.

    A sample-and-hold UGen. When triggered, a new value is taken from the input and hold until the next trigger occurs.

    Before the first trigger is registered, this UGen outputs zero.

    in

    the input signal

    trig

    the trigger. The can be any signal. A trigger happens when the signal changes from non-positive to positive.

    See also

    Gate

    Demand

  229. final case class LatoocarfianC(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 3.0f, c: GE = 0.5f, d: GE = 0.5f, xi: GE = 0.5f, yi: GE = 0.5f) extends SingleOut with Product with Serializable

    A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.

    A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:

    x[n+1] = sin(b * y[n]) + c * sin(b * x[n])
    y[n+1] = sin(a * y[n]) + d * sin(a * x[n])

    According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.

    freq

    Iteration frequency in Hertz.

    a

    Equation variable

    b

    Equation variable

    c

    Equation variable

    d

    Equation variable

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    LatoocarfianN

    LatoocarfianL

  230. final case class LatoocarfianL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 3.0f, c: GE = 0.5f, d: GE = 0.5f, xi: GE = 0.5f, yi: GE = 0.5f) extends SingleOut with Product with Serializable

    A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.

    A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:

    x[n+1] = sin(b * y[n]) + c * sin(b * x[n])
    y[n+1] = sin(a * y[n]) + d * sin(a * x[n])

    According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.

    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    c

    Equation variable

    d

    Equation variable

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    LatoocarfianN

    LatoocarfianC

  231. final case class LatoocarfianN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = 3.0f, c: GE = 0.5f, d: GE = 0.5f, xi: GE = 0.5f, yi: GE = 0.5f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.

    A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:

    x[n+1] = sin(b * y[n]) + c * sin(b * x[n])
    y[n+1] = sin(a * y[n]) + d * sin(a * x[n])

    According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.

    freq

    Iteration frequency in Hertz.

    a

    Equation variable

    b

    Equation variable

    c

    Equation variable

    d

    Equation variable

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    LatoocarfianL

    LatoocarfianC

  232. final case class LeakDC(rate: MaybeRate, in: GE, coeff: GE) extends SingleOut with Product with Serializable

    A filter UGen to remove very low frequency content DC offset.

    A filter UGen to remove very low frequency content DC offset.

    This is a one-pole highpass filter implementing the formula

    y[n] = x[n] - x[n-1] + coeff * y[n-1]
    in

    input signal to be filtered

    coeff

    the leak coefficient determines the filter strength. the value must be between zero and one (exclusive) for the filter to remain stable. values closer to one produce less bass attenuation.

    See also

    DC

  233. final case class LeastChange(rate: MaybeRate, a: GE, b: GE) extends SingleOut with Product with Serializable

    A UGen that switches between two input signal depending on which is changing less.

    A UGen that switches between two input signal depending on which is changing less. Change is based on the absolute of the differentiation of the respective signals.

    a

    first input signal to select from

    b

    second input signal to select from

    See also

    MostChange

  234. final case class Limiter(rate: Rate, in: GE, level: GE = 1.0f, dur: GE = 0.01f) extends SingleOut with Product with Serializable

    Limits the input amplitude to the given level.

    Limits the input amplitude to the given level. Unlike Compander , this UGen will never overshoot, but it needs to look ahead in the input signal, introducing a delay in its output. The delay time is equal to twice the value of the dur parameter (the buffer internally used).

    in

    input signal to be limited

    level

    maximum amplitude to which the signal is limited. The limiter will kick in when the input signal exceeds +level or falls below -level .

    dur

    look-ahead time in seconds (init-time only)

    See also

    Normalizer

    Compander

  235. final case class LinCongC(rate: Rate, freq: GE = Nyquist(), a: GE = 1.1f, c: GE = 0.13f, m: GE = 1.0f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A cubic-interpolating sound generator based on the difference equation:

    A cubic-interpolating sound generator based on the difference equation:

    x[n+1] = (a * x[n] + c) % m

    The output signal is automatically scaled to a range of [-1, 1].

    freq

    Iteration frequency in Hertz

    a

    Multiplier amount

    c

    Increment amount

    m

    Modulus amount

    xi

    Initial value of x

    See also

    LinCongN

    LinCongL

  236. final case class LinCongL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.1f, c: GE = 0.13f, m: GE = 1.0f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+1] = (a * x[n] + c) % m

    The output signal is automatically scaled to a range of [-1, 1].

    freq

    Iteration frequency in Hertz

    a

    Multiplier amount

    c

    Increment amount

    m

    Modulus amount

    xi

    Initial value of x

    See also

    LinCongN

    LinCongC

  237. final case class LinCongN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.1f, c: GE = 0.13f, m: GE = 1.0f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+1] = (a * x[n] + c) % m

    The output signal is automatically scaled to a range of [-1, 1].

    freq

    Iteration frequency in Hertz

    a

    Multiplier amount

    c

    Increment amount

    m

    Modulus amount

    xi

    Initial value of x

    See also

    LinCongL

    LinCongC

  238. final case class LinExp(rate: MaybeRate, in: GE, srcLo: GE = 0.0f, srcHi: GE = 1.0f, dstLo: GE = 1.0f, dstHi: GE = 2.0f) extends SingleOut with Product with Serializable

    A UGen which maps a linear range to an exponential range.

    A UGen which maps a linear range to an exponential range. The equivalent formula is (dstHi / dstLo).pow((in - srcLo) / (srcHi - srcLo)) * dstLo .

    Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.

    in

    input signal to convert

    srcLo

    lower limit of input range

    srcHi

    upper limit of input range

    dstLo

    lower limit of output range

    dstHi

    upper limit of output range

    See also

    LinExp

    Clip

  239. final case class LinLin(in: GE, srcLo: GE = 0f, srcHi: GE = 1f, dstLo: GE = 0f, dstHi: GE = 1f) extends GE.Lazy with Product with Serializable

    A graph element which maps a linear range to another linear range.

    A graph element which maps a linear range to another linear range. The equivalent formula is (in - srcLo) / (srcHi - srcLo) * (dstHi - dstLo) + dstLo.

    Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.

    Examples
    // oscillator to frequency range
    play {
      val mod = SinOsc.kr(Line.kr(1, 10, 10))
      SinOsc.ar(LinLin(mod, -1, 1, 100, 900)) * 0.1
    }
    in

    The input signal to convert.

    srcLo

    The lower limit of input range.

    srcHi

    The upper limit of input range.

    dstLo

    The lower limit of output range.

    dstHi

    The upper limit of output range.

    See also

    LinExp

    Clip

    MulAdd

  240. final case class LinPan2(rate: Rate, in: GE, pos: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable

    A stereo panorama UGen based on linear amplitude control.

    A stereo panorama UGen based on linear amplitude control. When in center position ( pos = 0 ), the signal is attenuated by 0.5 or approx. -6 dB.

    in

    (monophonic) input signal to be panned

    pos

    panorama position between -1 (hard left) via 0 (center) to +1 (hard right)

    level

    additional gain control

    See also

    Pan2

    PanAz

    Balance2

    LinXFade2

  241. final case class LinRand(lo: GE = 0.0f, hi: GE = 1.0f, minMax: GE = 0) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable

    A scalar UGen that generates a single random decimal value between lo and hi with a selectable skew towards either end.

    A scalar UGen that generates a single random decimal value between lo and hi with a selectable skew towards either end.

    The minMax <= 0 behaves rather odd: If minMax is less than 1, the distribution is skewed towards lo (with lo = 0 and hi = 1 , the mean is approx. 0.33). If minMax is greater than or equal to 1, the distribution is skewed towards hi (with lo = 0 and hi = 1 , the mean is approx 0.66).

    lo

    lower limit of the output range

    hi

    upper limit of the output range

    minMax

    if 0 , the output is skewed towards lo , if 1 , the output is skewed towards hi .

    See also

    Rand

    ExpRand

    NRand

    RandSeed

  242. final case class LinXFade2(rate: Rate, inA: GE, inB: GE = 0.0f, pan: GE = 0.0f, level: GE = 1.0f) extends SingleOut with Product with Serializable

    An linear two channel cross fading UGen.

    An linear two channel cross fading UGen. In center position ( pan = 0 ), both input signals are attenuated by 0.5 or approx. -6 dB.

    inA

    The first input signal

    inB

    The second input signal

    pan

    the cross-fade position from -1 (only input A audible) to +1 (only input B audible)

    level

    An overall amplitude multiplier that is applied to the output signal

    See also

    LinXFade2

    LinPan2

    XOut

  243. final case class Line(rate: Rate, start: GE = 0.0f, end: GE = 1.0f, dur: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with HasDoneFlag with Product with Serializable

    A line generator UGen that moves from a start value to the end value in a given duration.

    A line generator UGen that moves from a start value to the end value in a given duration.

    Warning: Durations greater than around 2.8e6 seconds cause the UGen to misbehave and jump to the end value directly.

    start

    Starting value (init-time only)

    end

    Ending value (init-time only)

    dur

    Duration in seconds. (init-time only)

    doneAction

    A done-action that is evaluated when the Line has reached the end value after the given duration

    See also

    XLine

    EnvGen

    Ramp

  244. final case class Linen(rate: Rate, gate: GE = 1, attack: GE = 0.01f, sustain: GE = 1.0f, release: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with HasDoneFlag with Product with Serializable

    A linear ASR-type envelope generator UGen.

    A linear ASR-type envelope generator UGen.

    gate

    triggers the envelope and holds it open while greater than zero. A value of less than zero enforces a release with duration -1.0 - gate .

    attack

    duration (seconds) of the attack segment

    sustain

    level of the sustain segment

    release

    duration (seconds) of the release segment

    doneAction

    action to be performed when the envelope reaches its end point.

    See also

    EnvGen

  245. final case class ListTrig(rate: Rate, buf: GE, size: GE, reset: GE = 0, delay: GE = 0) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that produces a scheduled sequences of trigger impulses.

    A UGen that produces a scheduled sequences of trigger impulses. Trigger times are provided as a list (buffer) of absolute offsets from time zero. A trigger is output as a single control period of value 1 , after which output returns to zero.

    This is a third-party UGen (MCLDUGens).

    buf

    identifier of the buffer containing the offsets for the triggers in seconds. The offsets are taken against the start time of the synth or the last time a reset was received. They are not accumulative, and the behavior is undefined if the values are not sorted in ascending order. The buffer should be monophonic.

    size

    the number of values to use from the buffer. Typically, this should be BufFrames.kr(buf) .

    reset

    resets the timer and begins reading the time offsets again at the start of the buffer.

    delay

    this value is added to each of the buffer values. For example, to delay the list of values all by half a second, use a delay of 0.5 . This parameter is only updated at initialization or reset.

    Note

    The argument order is different from its sclang counterpart.

    See also

    ListTrig2

    Logger

    DemandEnvGen

    Dbufrd

    Timer

  246. final case class ListTrig2(rate: Rate, buf: GE, size: GE, reset: GE = 0) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that produces a scheduled sequences of trigger impulses.

    A UGen that produces a scheduled sequences of trigger impulses. Trigger times are provided as a list (buffer) of relative durations between consecutive events. A trigger is output as a single control period of value 1 , after which output returns to zero.

    This is a third-party UGen (MCLDUGens).

    buf

    identifier of the buffer containing the durations for the triggers in seconds. A value represents a relative offsets with respect to its predecessor. The first value indicates the time between the start of the synth or last reset received and the first trigger. The buffer should be monophonic.

    size

    the number of values to use from the buffer. Typically, this should be BufFrames.kr(buf) .

    reset

    resets the timer and begins reading the time deltas again at the start of the buffer.

    Note

    The argument order is different from its sclang counterpart.

    See also

    ListTrig

    Logger

    DemandEnvGen

    Dbufrd

    ListTrig2

  247. final case class LocalBuf(numFrames: GE, numChannels: GE = 1) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable

    A UGen that allocates a buffer local to the synth.

    A UGen that allocates a buffer local to the synth. This is convenient for example when using an FFT chain.

    numFrames

    number of sample frames for the buffer

    numChannels

    number of channels for the buffer

    See also

    de.sciss.synth.ugen.FFT

  248. final case class LocalIn(rate: Rate, init: GE = 0) extends MultiOut with Product with Serializable

    A UGen that reads buses that are local to the enclosing synth.

    A UGen that reads buses that are local to the enclosing synth. These buses should be written using a LocalOut ugen. They behave like regular buses, but are more convenient for the implementation of a self contained effect that uses a feedback processing loop.

    In a synth, there can be only each one control-rate and audio-rate LocalIn / LocalOut pair. The signal written to a LocalOut will not be read by the LocalIn until the next control block cycle, introducing a delay of ControlDur .

    Warning: The argument has been changed numChannels: Int in version 1.15.3 to init: GE in version 1.16.0. The previous version was incompatible with SuperCollider 3.6.x. A previous usage such as LocalIn.ar(2) to create two channels must now be expressed as LocalIn.ar(Seq(0, 0)) !

    init

    the initial state of the UGen. The number of channels of this signal should match with the number of channels written via LocalOut .

    See also

    LocalOut

    InFeedback

    ControlDur

  249. final case class LocalOut(rate: Rate, in: GE) extends ZeroOut with Product with Serializable

    A UGen that writes to buses that are local to the enclosing synth.

    A UGen that writes to buses that are local to the enclosing synth. These buses should have been defined by a LocalIn ugen. These behave like regular buses, but are more convenient for the implementation of a self contained effect that uses a feedback processing loop.

    In a synth, there can be only each one control-rate and audio-rate LocalIn / LocalOut pair. The signal written to a LocalOut will not be read by the LocalIn until the next control block cycle, introducing a delay of ControlDur .

    For more examples, see LocalIn.

    in

    signal to be written to the synth-local bus. The signal's number of channels must be the same number of channels as were declared in the corresponding LocalIn .

    See also

    LocalIn

    Out

    ControlDur

  250. final case class Logger(rate: Rate, buf: GE, in: GE, trig: GE, reset: GE = 0) extends SingleOut with HasSideEffect with IsIndividual with Product with Serializable

    A UGen to store values in a buffer upon receiving a trigger.

    A UGen to store values in a buffer upon receiving a trigger. When a trigger happens, the current input values are sampled and stored as the next consecutive frame of the buffer.

    Storage starts at the buffer beginning and increments the write position until the buffer is full. While the buffer is not yet full, the UGen outputs 1 , then it outputs 0 . The buffer position can be reset using the reset input.

    Note that the UGen zeroes the buffer upon first instantiation, to ensure that out-of-date data is not confused with new data.

    This is a third-party UGen (MCLDUGens).

    buf

    identifier of the buffer to write to. Its number of channels should match those of in .

    in

    (multi-channel) signal to write to the buffer. Its number of channels should match those of buf .

    trig

    a non-positive to positive transition causes the UGen to append the current input values to the buffer

    reset

    a non-positive to positive transition causes the write index into the buffer to be reset to zero. The contents of the buffer will also be filled with zeroes. If the buffer was full, the UGen output switches back to zero.

    Note

    The argument order is different from its sclang counterpart.

    See also

    ListTrig

  251. final case class Logistic(rate: Rate, chaos: GE = 3.0f, freq: GE = 1000.0f, init: GE = 0.5f) extends SingleOut with Product with Serializable

    A noise generator UGen based on the logistic map.

    A noise generator UGen based on the logistic map. Its formula is

    y[n+1] = chaos * y[n] * (1.0 - y[n])
    chaos

    a parameter of the chaotic function with useful values from 0.0 to 4.0. Chaotic behavior occurs from 3.57 up. Using values outside this range can make the UGen blow up, resulting in NaNs.

    freq

    Frequency of calculation in Hertz. The value is limited by the sampling rate.

    init

    Initial value of the recursive function

    See also

    Crackle

    LatoocarfianN

  252. final case class LorenzL(rate: Rate, freq: GE = Nyquist(), s: GE = 10.0f, r: GE = 28.0f, b: GE = 2.667f, h: GE = 0.05f, xi: GE = 0.1f, yi: GE = 0.0f, zi: GE = 0.0f) extends SingleOut with Product with Serializable

    A strange attractor discovered by Edward N.

    A strange attractor discovered by Edward N. Lorenz while studying mathematical models of the atmosphere. The system is composed of three ordinary differential equations:

    x' = s * (y - x)
    y' = x * (r - z) - y
    z' = x * y - b * z

    The time step amount h determines the rate at which the ODE is evaluated. Higher values will increase the rate, but cause more instability. A safe choice is the default amount of 0.05.

    freq

    Iteration frequency in Hertz

    s

    Equation variable

    r

    Equation variable

    b

    Equation variable

    h

    Integration time step

    xi

    Initial value of x

    yi

    Initial value of y

    zi

    Initial value of z

  253. final case class Loudness(chain: GE, smask: GE = 0.25f, tmask: GE = 1.0f) extends SingleOut with ControlRated with IsIndividual with Product with Serializable

    A UGen for the extraction of instantaneous loudness.

    A UGen for the extraction of instantaneous loudness. A perceptual loudness function which outputs loudness in sones; this is a variant of an MP3 perceptual model, summing excitation in ERB bands. It models simple spectral and temporal masking, with equal loudness contour correction in ERB bands to obtain phons (relative dB), then a phon to sone transform. The final output is typically in the range of 0 to 64 sones, though higher values can occur with specific synthesised stimuli.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    Warning: the UGen is broken if FFT sizes other than the ones specified for chain are used.

    chain

    the output (buffer) of an FFT UGen which transforms the audio input to track. The FFT size should be 1024 for 44.1 and 48 kHz sampling rate, and 2048 for 88.2 and 96 kHz sampling rate.

    smask

    Spectral masking parameter: lower bins mask higher bin power within ERB bands, with a power falloff (leaky integration multiplier) of smask per bin. Can be control-rate modulated.

    tmask

    Temporal masking parameter: the phon level let through in an ERB band is the maximum of the new measurement, and the previous minus tmask phons. Can be control-rate modulated.

  254. final case class MFCC(chain: GE, numCoeffs: Int = 13) extends MultiOut with ControlRated with IsIndividual with Product with Serializable

    A UGen for extracting mel frequency cepstral coefficients.

    A UGen for extracting mel frequency cepstral coefficients. It generates a set of MFCCs; these are obtained from a band-based frequency representation (using the Mel scale by default), and then a discrete cosine transform (DCT). The DCT is an efficient approximation for principal components analysis, so that it allows a compression, or reduction of dimensionality, of the data, in this case reducing 42 band readings to a smaller set of MFCCs. A small number of features (the coefficients) end up describing the spectrum. The MFCCs are commonly used as timbral descriptors.

    The output values are somewhat normalised for the range 0.0 to 1.0, but there are no guarantees on exact conformance to this. Commonly, the first coefficient will be the highest value. The number of output channels corresponds to the number of coefficients specified. Technical note: The 0th coefficient is not generated as it consists of multiplying all bands by 1 and summing

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    chain

    the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, with a standard hop of half FFT size, the FFT size should be 1024 at 44.1 or 48 kHz and 2048 at 88.2 or 96 kHz sampling rate.

    numCoeffs

    the number of coefficients, defaults to 13, maximum of 42; more efficient to use less of course! Since this number determines the number of output channels of the UGen, it has to be an Int .

  255. final case class MantissaMask(rate: MaybeRate, in: GE, bits: GE = 3) extends SingleOut with Product with Serializable

    A UGen that masks off bits in the mantissa of the floating point sample value.

    A UGen that masks off bits in the mantissa of the floating point sample value. This introduces a quantization noise, but is less severe than linearly quantizing the signal.

    in

    input signal to quantize

    bits

    The number of mantissa bits to preserve, from 0 to 23.

  256. final case class MdaPiano(rate: Rate, freq: GE = 440, gate: GE = 1, velocity: GE = 100, decay: GE = 0.8f, release: GE = 0.8f, hardness: GE = 0.8f, velHard: GE = 0.8f, muffle: GE = 0.8f, velMuff: GE = 0.8f, velCurve: GE = 0.8f, stereo: GE = 0.2f, tune: GE = 0.5f, random: GE = 0.1f, stretch: GE = 0.1f, sustain: GE = 0) extends MultiOut with Product with Serializable

    A piano synthesiser UGen.

    A piano synthesiser UGen. It is not polyphonic, but it can be retriggered to play notes in sequence.

    The original VST plugin by Paul Kellett was ported to SuperCollider by Dan Stowell. Most likely the arguments are in the normalized range 0 to 1.

    This is a third-party UGen (MdaUGens).

    freq

    Frequency of the note in Hz.

    gate

    note-on occurs when gate goes from non-positive to positive; note-off occurs when it goes from positive to non-positive. Most of the other controls are only updated when a new note-on occurs.

    velocity

    velocity (range is 0 to 127)

    decay

    The time for notes to decay after the initial strike.

    release

    The time for notes to decay after the key is released.

    hardness

    adjusts sample key-ranges up or down to change the "size" and brightness of the piano.

    muffle

    gentle low pass filter.

    stereo

    Width of the stereo effect (which makes low notes sound towards the left, high notes towards the right). 0 to 1.

    tune

    Overall tuning.

    random

    Randomness in note tuning.

    stretch

    Stretches the tuning out (higher notes pushed higher).

    sustain

    if positive, act as if the piano's sustain pedal is pressed.

  257. final case class Median(rate: Rate, in: GE, length: GE = 3) extends SingleOut with Product with Serializable

    A filter UGen that calculates the median of a running window over its input signal.

    A filter UGen that calculates the median of a running window over its input signal. This non-linear filter can be used to reduce impulse noise from a signal.

    length

    window size. I.e., the number of input samples in which to find the median. Must be an odd number from 1 to 31. A value of 1 has no effect. Warning: This parameter is only read an initialization time and cannot be modulated while the UGen is running. (init-time only)

    Note

    The argument order is different from its sclang counterpart.

    See also

    LPF

    LeakDC

    RunningSum

  258. final case class MidEQ(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f, gain: GE = 0.0f) extends SingleOut with Product with Serializable

    A single band parametric equalizer UGen.

    A single band parametric equalizer UGen. It attenuates or boosts a frequency band.

    in

    input signal to be filtered

    freq

    center frequency in Hertz

    rq

    reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq  = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter. Too high values for rq may blow the filter up!

    gain

    The amount of boost (when positive) or attenuation (when negative) applied to the frequency band, in decibels.

    See also

    BPF

    BRF

    HPF

    LPF

    Resonz

  259. final case class Mix(elem: GE) extends SingleOut with Product with Serializable

    A graph element that mixes the channels of a signal together.

    A graph element that mixes the channels of a signal together. It works like the sclang counterpart.

    The Mix companion object contains various useful mixing idioms:

    - Mix.tabulate(n: Int)(fun: Int => GE): corresponds to Seq.tabulate and to Array.fill in sclang. - Mix.fill(n: Int)(thunk: => GE): corresponds to Seq.fill. - Mix.seq(elems: GE*): A shortcut for Mix(GESeq(elems: _*)).

    A separate graph element is Mix.mono. Mix.mono(elem: GE) flattens all channels of the input element before summing them, guaranteeing that the result is monophonic.

    Finally, Mix.fold is an idiom that not actually adds elements, but recursively folds them. Thus, Mix.fold(elem: GE, n: Int)(fun: GE => GE) is equivalent to

    (1 to n).foldLeft(elem) { (res, _) => fun(res) }

    Mix.fold is often used in the SuperCollider examples to apply a filtering process such as reverberation several times. For cases where the iteration index is needed, the full form as shown above can be used instead.

    elem

    the graph element whose channels to mix together

    See also

    Reduce

    BinaryOpUGen

  260. final case class ModDif(rate: Rate, x: GE, y: GE = 0.0f, mod: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that returns the minimum difference of two values in modulo arithmetics.

    A UGen that returns the minimum difference of two values in modulo arithmetics. On a circle, there are two distances between two points. This UGen returns the smaller value of the two.

    x

    the first input value

    y

    the second input value

    mod

    the modulo argument, i.e. the maximum value output, which is double of the maximal difference that will be returned by the UGen.

    See also

    Clip

    Wrap

  261. final case class MoogFF(rate: MaybeRate, in: GE, freq: GE = 200.0f, gain: GE = 2.0f, reset: GE = 0) extends SingleOut with Product with Serializable

    A Moog VCF style UGen.

    A Moog VCF style UGen. This is a type of resonant low pass filter.

    The design of this filter is described in Federico Fontana, "Preserving the Digital Structure of the Moog VCF." In: Proceedings of the ICMC, Copenhagen 2007. Ported to SuperCollider by Dan Stowell.

    freq

    cutoff frequency in Hertz

    gain

    filter resonance gain, between 0 and 4

    reset

    when greater than zero, this will reset the state of the digital filters at the beginning of the next control block.

  262. final case class MostChange(rate: Rate, a: GE, b: GE) extends SingleOut with Product with Serializable

    A UGen that switches between two input signal depending on which is changing more.

    A UGen that switches between two input signal depending on which is changing more. Change is based on the absolute of the differentiation of the respective signals.

    a

    first input signal to select from

    b

    second input signal to select from

    See also

    LeastChange

  263. final case class MouseButton(lo: GE = 0.0f, hi: GE = 1.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable

    A UGen that outputs two different values depending on whether the mouse button is pressed.

    A UGen that outputs two different values depending on whether the mouse button is pressed. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.

    lo

    value output while button is not pressed

    hi

    value output while button is pressed

    lag

    60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.

    See also

    MouseX

    MouseY

    KeyState

  264. final case class MouseX(lo: GE = 0.0f, hi: GE = 1.0f, warp: GE = 0.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable

    A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range.

    A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.

    lo

    value when the mouse is on the left side of the screen

    hi

    value when the mouse is on the right side of the screen. Note: this value is never reached, because the maximum mouse coordinate is one pixel less than the screen size. For example, if the screen width is 1440, lo is 0.0 and hi is 1.0, the maximum value output is 1.0 * 1439/1440 = 0.999306 .

    warp

    curve shape. Either zero (default) for a linear mapping, or 1 for an exponential mapping. Note: When using exponential mapping, make sure the lo value is greater than zero, otherwise NaN values will be output.

    lag

    60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.

    See also

    MouseY

    MouseButton

    KeyState

  265. final case class MouseY(lo: GE = 0.0f, hi: GE = 1.0f, warp: GE = 0.0f, lag: GE = 0.2f) extends SingleOut with ControlRated with Product with Serializable

    A UGen that maps the vertical screen location of the mouse to a given linear or exponential range.

    A UGen that maps the vertical screen location of the mouse to a given linear or exponential range. The lo value corresponds to the bottom of the screen, and the hi value corresponds to the top of the screen (not vice-versa).

    This UGen is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.

    lo

    value when the mouse is on the bottom side of the screen. Note: this value is never reached, because the maximum mouse coordinate is one pixel less than the screen height. For example, if the screen height is 900, lo is 0.0 and hi is 1.0, the minimum value output is 1.0 - 1.0 * 899.0/900 = 0.001111 .

    hi

    value when the mouse is on the top side of the screen

    warp

    curve shape. Either zero (default) for a linear mapping, or 1 for an exponential mapping. Note: When using exponential mapping, make sure the lo value is greater than zero, otherwise NaN values will be output.

    lag

    60 dB decay time of a lag-time smoothing. Use zero to avoid any smoothing.

    See also

    MouseX

    MouseButton

    KeyState

  266. final case class MulAdd(in: GE, mul: GE, add: GE) extends SingleOut with Product with Serializable

    A UGen that multiplies an input with another signal and then adds a third signal.

    A UGen that multiplies an input with another signal and then adds a third signal. This can be used to translate an element into a different value range.

    Usually the graph element operator mulAdd is used instead of explicitly writing MulAdd.

    MulAdd(in, mul, add) == in.mulAdd(mul, add) == in * mul + add
    Examples
    // scale value range
    play {
      // input range -1 to +1,
      // output range ((-1 * 100) + 300) = 200
      // to           ((+1 * 100) + 300) = 400
      val freq = SinOsc.kr(1).mulAdd(100, 300) // or MulAdd(..., 100, 300)
      freq.poll(label = "freq")
      SinOsc.ar(freq) * 0.1
    }
    in

    the input signal to scale and offset

    mul

    the scaling factor, applied first to the input

    add

    the offset, added after applying the multiplication

    See also

    BinaryOpUGen

    Sum3

    Sum4

  267. final case class NRand(lo: GE = 0.0f, hi: GE = 1.0f, n: GE = 2) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable

    A scalar UGen that generates a single random decimal value, averaging a given number of samples from a uniform distribution between lo and hi .

    A scalar UGen that generates a single random decimal value, averaging a given number of samples from a uniform distribution between lo and hi .

    lo

    lower limit of the output range

    hi

    upper limit of the output range

    n

    the number of random numbers to average. For n = 1 , the result is identical to Rand , for n = 2 , the distribution is triangular, and for larger values the distribution converges towards a Gaussian. Warning: The value should be not be less than one.

    See also

    IRand

    TRand

    ExpRand

    RandSeed

  268. final case class NodeID() extends SingleOut with ScalarRated with Product with Serializable

    Identifier of the node which contains the UGen.

    Identifier of the node which contains the UGen.

    See also

    Free

    Poll

    NumRunningSynths

  269. final case class Normalizer(rate: Rate, in: GE, level: GE = 1, dur: GE = 0.01f) extends SingleOut with Product with Serializable

    A UGen that normalizes the input amplitude to the given level.

    A UGen that normalizes the input amplitude to the given level. Unlike Compander , this UGen will not overshoot, but it needs to look ahead in the input signal, introducing a delay in its output. The delay time is equal to twice the value of the dur parameter (the buffer internally used).

    in

    input signal to be normalized

    level

    peak output amplitude level to which to normalize the input

    dur

    look-ahead time in seconds. Shorter times will produce smaller delays and quicker transient response times, but may introduce amplitude modulation artifacts. (init-time only)

    See also

    Limiter

    Compander

  270. final case class NumAudioBuses() extends SingleOut with ScalarRated with Product with Serializable

    Number of audio buses.

  271. final case class NumBuffers() extends SingleOut with ScalarRated with Product with Serializable

    Maximum number of audio buffers.

  272. final case class NumChannels(in: GE) extends SingleOut with ScalarRated with Product with Serializable

    A graph element that produces an integer with number-of-channels of the input element.

    A graph element that produces an integer with number-of-channels of the input element.

    Because ScalaCollider allows late-expanding graph elements, we have no direct way to get an integer of some array-size of a UGen's outputs. On the other hand, there may be sound synthesis definitions that can abstract over the number of channels at definition time.

    Examples
    // amplitude compensation
    play {
      val sines: GE = Seq.fill(8)(SinOsc.ar(ExpRand(200, 2000)))
      val norm = Mix(sines) / NumChannels(sines)   // guarantee that they don't clip
      norm * 0.2
    }
    in

    the element whose number-of-channels to produce

    See also

    ChannelIndices

  273. final case class NumControlBuses() extends SingleOut with ScalarRated with Product with Serializable

    Number of control buses.

  274. final case class NumInputBuses() extends SingleOut with ScalarRated with Product with Serializable

    Number of input buses.

  275. final case class NumOutputBuses() extends SingleOut with ScalarRated with Product with Serializable

    Number of output buses.

  276. final case class NumRunningSynths() extends SingleOut with ScalarRated with Product with Serializable

    Number of currently running synths.

    Number of currently running synths.

    See also

    NumAudioBuses

    NumControlBuses

    NumBuffers

    NumInputBuses

    NumOutputBuses

  277. final case class Nyquist() extends GE with ScalarRated with Product with Serializable

    A helper graph element equivalent to SampleRate.ir * 0.5.

    A helper graph element equivalent to SampleRate.ir * 0.5.

    See also

    SampleRate

  278. final case class OffsetOut(bus: GE, in: GE) extends ZeroOut with AudioRated with HasSideEffect with IsIndividual with Product with Serializable

    A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle.

    A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle. I.e. if the synth is scheduled to be started part way through a control cycle, OffsetOut will maintain the correct offset by buffering the output and delaying it until the exact time that the synth was scheduled for.

    This UGen adds ("mixes") the input-signal to the existing contents of the bus.

    Multi-channel input signals, for example a PanAz , are written as such to the bus without expansion. That is, the bus index argument is used for the first channel, the second channel will appear on bus + 1 , etc.

    If you have an expanding multi-channel input, however, you have to be careful. For example, if you have PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results in one output UGen carrying one channel, and another one carrying two channels. (The way this works is consistent with SCLang). In order to get the correct behaviour (left outputs of the PanAz summed, and right output of the PanAz summed), wrap this expression in a Mix(...) before passing it to the output UGen.

    Note: You cannot currently achieve sample accurate scheduling in SuperCollider. This UGen is therefore more or less useless.

    bus

    bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus.

    in

    signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.

    See also

    Out

    ReplaceOut

    XOut

    SubsampleOffset

  279. final case class OnePole(rate: MaybeRate, in: GE, coeff: GE = 0.5f) extends SingleOut with Product with Serializable

    A one pole (IIR) filter UGen.

    A one pole (IIR) filter UGen. Implements the formula :

    out(i) = ((1 - abs(coef)) * in(i)) + (coef * out(i-1))

    Warning: there are bugs when the coefficient is modulated

    in

    input signal to be processed

    coeff

    feedback coefficient. Should be between -1 and +1

    See also

    OneZero

    TwoPole

    Lag

  280. final case class OneZero(rate: MaybeRate, in: GE, coeff: GE = 0.5f) extends SingleOut with Product with Serializable

    A one zero (FIR) filter UGen.

    A one zero (FIR) filter UGen. Implements the formula :

    out(i) = ((1 - abs(coef)) * in(i)) + (coef * in(i-1))
    in

    input signal to be processed

    coeff

    feed forward coefficient. +0.5 makes a two point averaging filter (see also LPZ1 ), -0.5 makes a differentiator (see also HPZ1 ), +1 makes a single sample delay (see also Delay1 ), -1 makes an inverted single sample delay.

    See also

    OnePole

    TwoZero

    LPZ1

    HPZ1

    Delay1

    Integrator

  281. final case class Onsets(chain: GE, thresh: GE = 0.5f, fun: GE = 3, decay: GE = 1.0f, noiseFloor: GE = 0.1f, minGap: GE = 10, medianSpan: GE = 11, whType: GE = 1, raw: GE = 0) extends SingleOut with ControlRated with IsIndividual with Product with Serializable

    An onset detecting UGen for musical audio signals.

    An onset detecting UGen for musical audio signals. It detects the beginning of notes/drumbeats/etc. Outputs a control-rate trigger signal which is 1 when an onset is detected, and 0 otherwise.

    The onset detection should work well for a general range of monophonic and polyphonic audio signals. The onset detection is purely based on signal analysis and does not make use of any "top-down" inferences such as tempo.

    There are different functions available for the analysis:

    - 0 "power" -- generally OK, good for percussive input, and also very efficient - 1 "magsum" -- generally OK, good for percussive input, and also very efficient - 2 "complex" -- performs generally very well, but more CPU-intensive - 3 "rcomplex" (default) -- performs generally very well, and slightly more efficient than "complex" - 4 "phase" -- generally good, especially for tonal input, medium efficiency - 5 "wphase" -- generally very good, especially for tonal input, medium efficiency - 6 "mkl" -- generally very good, medium efficiency, pretty different from the other methods

    The differences aren't large, so it is recommended you stick with the default "rcomplex" unless you find specific problems with it. Then maybe try "wphase". The "mkl" type is a bit different from the others so maybe try that too. They all have slightly different characteristics, and in tests perform at a similar quality level.

    chain

    the output (buffer) of an FFT UGen which transforms the audio input to track. For the FFT chain, you should typically use a frame size of 512 or 1024 (at 44.1 kHz sampling rate) and 50% hop size (which is the default setting in SC). For different sampling rates choose an FFT size to cover a similar time-span (around 10 to 20 ms).

    thresh

    the detection threshold, typically between 0 and 1, although in rare cases you may find values outside this range useful

    fun

    index of a function to be used to analyse the signal. See main paragraph for possible values (usually can be left to default).

    decay

    (advanced setting) Specifies the time (in seconds) for the normalisation to "forget" about a recent onset. If you find too much re-triggering (e.g. as a note dies away unevenly) then you might wish to increase this value. Not used with "mkl".

    noiseFloor

    (advanced setting) This is a lower limit, connected to the idea of how quiet the sound is expected to get without becoming indistinguishable from noise. For some cleanly-recorded classical music with wide dynamic variations, it was found helpful to go down as far as 1e-6. Not used with "mkl".

    minGap

    (advanced setting) Specifies a minimum gap (in FFT frames) between onset detections, a brute-force way to prevent too many doubled detections.

    medianSpan

    (advanced setting) Specifies the size (in FFT frames) of the median window used for smoothing the detection function before triggering.

    whType

    (advanced setting) ?

    raw

    (advanced setting) ? (init-time only)

    See also

    PV_JensenAndersen

    PV_HainsworthFoote

  282. final case class Osc(rate: Rate, buf: GE, freq: GE = 440.0f, phase: GE = 0.0f) extends SingleOut with IsIndividual with Product with Serializable

    An oscillator UGen that linearly interpolates a wavetable.

    An oscillator UGen that linearly interpolates a wavetable. It has frequency and phase modulation inputs. The wave table is provided by a buffer filled with a wavetable format signal. The buffer size must be a power of 2.

    The buffer is typically filled by a b_gen OSC message. (e.g. buf.sine1(...) , buf.sine2(...) etc.)

    buf

    the buffer with the wavetable in special wavetable format. the size must be a power of two.

    freq

    frequency of table scans in Hz, corresponding to the fundamental frequency of the sound.

    phase

    phase offset or modulator in radians. The value should be within the range of -8*Pi to +8*Pi.

    See also

    OscN

    COsc

    VOsc

    SinOsc

  283. final case class OscN(rate: Rate, buf: GE, freq: GE = 440.0f, phase: GE = 0.0f) extends SingleOut with IsIndividual with Product with Serializable
  284. final case class Out(rate: Rate, bus: GE, in: GE) extends ZeroOut with HasSideEffect with IsIndividual with Product with Serializable

    A UGen that writes a signal onto a bus.

    A UGen that writes a signal onto a bus. It adds ("mixes") the input-signal to the existing contents of the bus.

    Multi-channel input signals, for example a PanAz , are written as such to the bus without expansion. That is, the bus index argument is used for the first channel, the second channel will appear on bus + 1 , etc.

    If you have an expanding multi-channel input, however, you have to be careful. For example, if you have PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results in one output UGen carrying one channel, and another one carrying two channels. (The way this works is consistent with SCLang). In order to get the correct behaviour (left outputs of the PanAz summed, and right output of the PanAz summed), wrap this expression in a Mix(...) before passing it to the output UGen.

    bus

    bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus. Note that the bus index can only be modulated at control-rate.

    in

    signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.

    See also

    In

    PhysicalOut

    ReplaceOut

    XOut

    LocalOut

    Bus

  285. final case class PV_Add(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that performs a complex addition of the two inputs.

    A phase vocoder UGen that performs a complex addition of the two inputs. The formula is (Re(A) + Re(B)) + i(Im(A) + Im(B)) .

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  286. final case class PV_BinScramble(chain: GE, wipe: GE = 0.5f, width: GE = 0.2f, trig: GE = 1) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that randomizes the order of the bins.

    A phase vocoder UGen that randomizes the order of the bins. The trigger will select a new random ordering.

    chain

    the FFT'ed buffer

    wipe

    the amount of bins scrambled, from 0 (none) to 1 (all bins scrambled).

    width

    a value from zero to one, indicating the maximum randomized distance of a bin from its original location in the spectrum.

    trig

    causes a new random bin re-ordering to be made. a trigger occurs when passing from non-positive to positive value.

  287. final case class PV_BinShift(chain: GE, stretch: GE = 1.0f, shift: GE = 0.0f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that stretches and shifts the spectrum.

    A phase vocoder UGen that stretches and shifts the spectrum. It takes each bin, first stretches (scales) its position (bin number) with a given factor, and then adds a shift to it.

    chain

    the FFT'ed buffer

    stretch

    the factor to multiply each bin position with, where 0.5 kind of transposes the signal down by an octave, and 2 transposes it up by an octave.

    shift

    the translation of the spectrum, in number of bins. Since the FFT produces a linear frequency axis, the will produce harmonic distortion.

  288. final case class PV_BinWipe(chainA: GE, chainB: GE, wipe: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that combine low and high bins from two inputs.

    A phase vocoder UGen that combine low and high bins from two inputs. It does so by copying low bins from one input and the high bins of the other, thus realizes a kind of "wipe" between the two input signals.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

    wipe

    can range between -1 and +1. if wipe == 0 then the output is the same as inA. if wipe > 0 then it begins replacing with bins from inB from the bottom up. if wipe < 0 then it begins replacing with bins from inB from the top down.

    See also

    PV_RandWipe

  289. final case class PV_BrickWall(chain: GE, wipe: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that clears bins above or below a cutoff point.

    A phase vocoder UGen that clears bins above or below a cutoff point.

    chain

    the FFT'ed buffer

    wipe

    can range between -1 and +1. if wipe == 0 then there is no effect. if wipe > 0 then it acts like a high pass filter, clearing bins from the bottom up. if wipe < 0 then it acts like a low pass filter, clearing bins from the top down.

  290. final case class PV_ConformalMap(chain: GE, real: GE = 0.0f, imag: GE = 0.0f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its input FFT bins z .

    A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its input FFT bins z .

    It makes a transformation of the complex plane so the output is full of phase vocoder artifacts but may be musically interesting. One should usually keep |a| < 1 , although bigger values may be used to produce noise. A value of a = 0 gives back the input mostly unperturbed.

    chain

    the FFT'ed buffer

    real

    real part of the complex parameter a

    imag

    imaginary part of the complex parameter a

  291. final case class PV_Conj(chain: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that converts the bins into their complex conjugate counterparts.

    A phase vocoder UGen that converts the bins into their complex conjugate counterparts. The complex conjugate is equal to the input, but with reversed sign of the imaginary part.

    chain

    the FFT'ed buffer

  292. final case class PV_Copy(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that copies the spectral frames from chainA to chainB.

    A phase vocoder UGen that copies the spectral frames from chainA to chainB. This allows for parallel processing of spectral data without the need for multiple FFT UGens, and to copy out data at that point in the chain for other purposes. chainA and chainB must be the same size. The output will carry further chainA, so you chan insert the ugen at the appropriate place in the signal chain.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  293. final case class PV_CopyPhase(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that combines the magnitudes of first input and phases of the second input.

    A phase vocoder UGen that combines the magnitudes of first input and phases of the second input. phases of the first input.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  294. final case class PV_Diffuser(chain: GE, trig: GE = 1) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that adds a different constant random phase shift to each bin.

    A phase vocoder UGen that adds a different constant random phase shift to each bin. The trigger will select a new set of random phases.

    chain

    the FFT'ed buffer

    trig

    to trigger a new selection of random phases. A trigger occurs when passing from non-positive to positive value.

  295. final case class PV_Div(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that performs a complex division of the two inputs.

    A phase vocoder UGen that performs a complex division of the two inputs. Be careful that chainB , the divisor, does not contain zeroes as they would obviously blow up the division.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  296. final case class PV_HainsworthFoote(rate: Rate, chain: GE, hainsworth: GE = 0.0f, foote: GE = 0.0f, thresh: GE = 1.0f, waitTime: GE = 0.04f) extends SingleOut with IsIndividual with Product with Serializable

    An FFT based onset detector UGen using a balance of two features.

    An FFT based onset detector UGen using a balance of two features. It is based on work described in Hainsworth (2003), "Techniques for the Automated Analysis of Musical Audio," PhD thesis, University of Cambridge. See especially p. 128. The Hainsworth metric is a modification of the Kullback Liebler distance.

    chain

    the fft signal (buffer) to analyze

    hainsworth

    what strength of detection signal from Hainsworth metric (0 to 1) to use.

    foote

    what strength of detection signal from normalized Foote metric (0 to 1) to use.

    thresh

    threshold level for detection

    waitTime

    after an onset is detected, further detections are suppressed for this period in seconds, preventing multiple rapid triggers

    See also

    Onsets

    PV_JensenAndersen

  297. final case class PV_JensenAndersen(rate: Rate, chain: GE, centroid: GE = 0.25f, hfe: GE = 0.25f, hfc: GE = 0.25f, flux: GE = 0.25f, thresh: GE = 1.0f, waitTime: GE = 0.04f) extends SingleOut with IsIndividual with Product with Serializable

    An FFT based onset detector UGen using a mix of extracted features.

    An FFT based onset detector UGen using a mix of extracted features. It is based on work described in Jensen and Andersen (2003), "Real-time Beat Estimation Using Feature Extraction," in: Proceedings of the Computer Music Modeling and Retrieval Symposium.

    First order derivatives of the features are taken. The threshold may need to be set low to pick up on changes.

    chain

    the fft signal (buffer) to analyze

    centroid

    proportion (0 to 1) of spectral centroid feature

    hfe

    proportion (0 to 1) of high frequency energy feature

    hfc

    proportion (0 to 1) of high frequency content feature

    flux

    proportion (0 to 1) of spectral flux feature

    thresh

    threshold level for detection

    waitTime

    after an onset is detected, further detections are suppressed for this period in seconds, preventing multiple rapid triggers

    See also

    Onsets

    PV_HainsworthFoote

  298. final case class PV_LocalMax(chain: GE, thresh: GE = 0.0f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima.

    A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima. Additionally, the given threshold is also used to filter out bins whose magnitude lies below this threshold.

    chain

    the FFT'ed buffer

    thresh

    magnitude threshold used for general filtering, prior to the local-maximum-filtering

  299. final case class PV_MagAbove(chain: GE, thresh: GE = 0.0f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that passes only those bins whose magnitudes are above a given threshold.

    A phase vocoder UGen that passes only those bins whose magnitudes are above a given threshold.

    chain

    the FFT'ed buffer

    thresh

    magnitude threshold.

  300. final case class PV_MagBelow(chain: GE, thresh: GE = 0.0f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that passes only those bins whose magnitudes are below a given threshold.

    A phase vocoder UGen that passes only those bins whose magnitudes are below a given threshold.

    chain

    the FFT'ed buffer

    thresh

    magnitude threshold.

  301. final case class PV_MagClip(chain: GE, thresh: GE = 0.0f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that limits (clips) the magnitude of the bins to a given threshold.

    A phase vocoder UGen that limits (clips) the magnitude of the bins to a given threshold.

    chain

    the FFT'ed buffer

    thresh

    magnitude threshold. Each bin's magnitude is limited to be not greater than this threshold.

  302. final case class PV_MagDiv(chainA: GE, chainB: GE, zeroes: GE = 1.0E-4f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that divides magnitudes of two inputs and keeps the phases of the first input.

    A phase vocoder UGen that divides magnitudes of two inputs and keeps the phases of the first input.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

    zeroes

    the noise floor to assume when detecting zero bins in chainB that would cause a division by zero and hence blow up. The ugen will use divide by this magnitude instead when zeroes are detected, resulting in a maximum boost of zeroes.reciprocal .

  303. final case class PV_MagFreeze(chain: GE, freeze: GE = 1) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that freezes the magnitudes at current levels.

    A phase vocoder UGen that freezes the magnitudes at current levels. Freezing happens when the freeze input has a value of > 0.

    chain

    the FFT'ed buffer

    freeze

    whether the current levels are frozen (> 0) or not (0).

  304. final case class PV_MagMul(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that multiplies the magnitudes of two inputs and keeps the phases of the first input.

    A phase vocoder UGen that multiplies the magnitudes of two inputs and keeps the phases of the first input.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  305. final case class PV_MagNoise(chain: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that multiplies the magnitudes by random noise.

    A phase vocoder UGen that multiplies the magnitudes by random noise.

    chain

    the FFT'ed buffer

  306. final case class PV_MagShift(chain: GE, stretch: GE = 1.0f, shift: GE = 0.0f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum.

    A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum. This is live PV_BinShift but instead of scaling and shifting the whole complex bins (magnitude and phase), this only operates on the magnitudes and leaves the phases in their original bins.

    chain

    the FFT'ed buffer

    stretch

    the factor to multiply each bin position with

    shift

    the translation of the spectrum, in number of bins

  307. final case class PV_MagSmear(chain: GE, bins: GE = 1) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that averages each bin's magnitude with its neighbors.

    A phase vocoder UGen that averages each bin's magnitude with its neighbors.

    chain

    the FFT'ed buffer

    bins

    number of bins to average on each side of bin. As this number rises, so will CPU usage.

  308. final case class PV_MagSquared(chain: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak.

    A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak. This makes weak bins weaker.

    chain

    the FFT'ed buffer

  309. final case class PV_Max(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that outputs the bins with the maximum magnitude of the two inputs.

    A phase vocoder UGen that outputs the bins with the maximum magnitude of the two inputs.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  310. final case class PV_Min(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that outputs the bins with the minimum magnitude of the two inputs.

    A phase vocoder UGen that outputs the bins with the minimum magnitude of the two inputs.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  311. final case class PV_Mul(chainA: GE, chainB: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that performs a complex multiplication of the two inputs.

    A phase vocoder UGen that performs a complex multiplication of the two inputs. The formula is (Re(A) * Re(B) - Im(A) * Im(B)) + i(Im(A) * Re(B) + Re(A) * Im(B)) .

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

  312. final case class PV_PhaseShift(chain: GE, shift: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that shifts the phase of each bins by a given amount.

    A phase vocoder UGen that shifts the phase of each bins by a given amount.

    chain

    the FFT'ed buffer

    shift

    phase shift in radians

  313. final case class PV_PhaseShift270(chain: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that shift the phase of all bins by 270 (or -90) degrees.

    A phase vocoder UGen that shift the phase of all bins by 270 (or -90) degrees.

    chain

    the FFT'ed buffer

  314. final case class PV_PhaseShift90(chain: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that shift the phase of all bins by 90 degrees.

    A phase vocoder UGen that shift the phase of all bins by 90 degrees.

    chain

    the FFT'ed buffer

  315. final case class PV_RandComb(chain: GE, wipe: GE = 0.5f, trig: GE = 1) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that randomly clears out bins of the signal.

    A phase vocoder UGen that randomly clears out bins of the signal. Which bins are wiped out is subject to a random choice (only the amount is specified) that remains constant between triggers.

    chain

    the FFT'ed buffer

    wipe

    the probability (from 0 to 1) of bins being wiped out, hence 0 means no bins are wiped out, 1 means all bins are wiped out (output will be silence).

    trig

    causes a new random bin selection to be made. a trigger occurs when passing from non-positive to positive value.

  316. final case class PV_RandWipe(chainA: GE, chainB: GE, wipe: GE, trig: GE) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.

    A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

    wipe

    the crossfader position from 0.0 (all bins are taken from chainA ) to 1.0 (all bins are taken from chainB ). For instance, if wipe is 0.5, half of the bins are taken from either input. The decision whether a bin is taken from A or B is random, however remains constant between two triggers.

    trig

    a signal the triggers the re-newed process of determining for each bin whether it will be taken from input A or B. A trigger occurs when passing from non-positive to positive value.

    See also

    PV_BinWipe

  317. final case class PV_RectComb(chain: GE, numTeeth: GE = 1.0f, phase: GE = 0.0f, width: GE = 0.5f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that makes a series of gaps in a spectrum.

    A phase vocoder UGen that makes a series of gaps in a spectrum. This is done by multiplying the spectrum with a kind of rectangle wave that goes from zero to nyquist. The high slope of the rectangle lets the input bins pass (quasi pass-band), the low slope filters them out (quasi stop-band).

    chain

    the FFT'ed buffer

    numTeeth

    the number of periods in the rectangle wave, where zero would mean the input signal is not affected, one means that there is exactly one period of the wave across the spectrum, hence one pass-band and one stop-band.

    phase

    the phase offset of the rectangle wave, where 1.0 is one full period. This is like the offset into the wavetable holding the rectangle, so a value of 0.25 means we start 25% into the basic waveform, and after 0.75 periods the next full period (high slope) begins.

    width

    the pulse width between 0.0 (infinitely small high slope, so all bins filtered out) to 0.5 (half period is high slope, half period is low slope) to 1.0 (maximally wide high slope, no bins filtered out).

    See also

    PV_RectComb2

  318. final case class PV_RectComb2(chainA: GE, chainB: GE, numTeeth: GE = 1.0f, phase: GE = 0.0f, width: GE = 0.5f) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A phase vocoder UGen that switches between two input spectra according to a rectangle wave.

    A phase vocoder UGen that switches between two input spectra according to a rectangle wave. This is basically identical to PV_RectComb , however during the low slopes of the rectangle wave, instead of clearing out the bins, it copies over the corresponding bins of the second fft input buffer.

    chainA

    the first FFT'ed buffer (this gets replaced by the output signal)

    chainB

    the second FFT'ed buffer

    numTeeth

    the number of periods in the rectangle wave, where zero would mean the first input signal is fully passed through, one means that there is exactly one period of the wave across the spectrum, hence one pass-band (first signal passed through) and one stop-band (second signal passed through).

    phase

    the phase offset of the rectangle wave, where 1.0 is one full period. This is like the offset into the wavetable holding the rectangle, so a value of 0.25 means we start 25% into the basic waveform, and after 0.75 periods the next full period (high slope) begins.

    width

    the pulse width between 0.0 (infinitely small high slope, so all bins are copied from the second input) to 0.5 (half period is high slope -- copied from first input --, half period is low slope -- copied from second input) to 1.0 (maximally wide high slope, so all bins passed from the first input).

    See also

    PV_RectComb

  319. final case class PackFFT(chain: GE, fftSize: GE, values: GE, from: GE = 0, to: GE, clear: GE = 0) extends SingleOut with ControlRated with HasSideEffect with IsIndividual with Product with Serializable

    A UGen that writes a complex input signal into an FFT buffer.

    A UGen that writes a complex input signal into an FFT buffer. The input is a sequence of interleaved magnitudes and phases. It is written to an FFT buffer ready for transforming it back into time-domain audio using IFFT.

    values

    input data to pack. It should be a flat sequence containing interleaved magnitude and phase components of all bins in ascending order. E.g. [mag0, phase0, mag1, phase1, mag2, phase2, ... magN, phaseN]. This input is typically demand-rate.

    from

    index of lower bin

    to

    index of upper bin (inclusive)

    clear

    if 1 , clears the buffer before packing the values, setting its contents to zero.

    See also

    Unpack1FFT

    FFT

    IFFT

    SetBuf

  320. final case class Pad(in: GE, to: GE) extends SingleOut with Product with Serializable

    A graph element that controls the multi-channel expansion of its in argument to match the to argument by padding (extending and wrapping) it.

    A graph element that controls the multi-channel expansion of its in argument to match the to argument by padding (extending and wrapping) it.

    in

    the element to replicate

    to

    the reference element that controls the multi-channel expansion. the signal itself is not used or output by Pad.

  321. final case class Pan2(rate: Rate, in: GE, pos: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable

    A stereo panorama UGen based on equal-power amplitude control.

    A stereo panorama UGen based on equal-power amplitude control. When in center position ( pos = 0 ), the signal is attenuated by sqrt(0.5) or approx. -3 dB.

    in

    (monophonic) input signal to be panned

    pos

    panorama position between -1 (hard left) via 0 (center) to +1 (hard right)

    level

    additional gain control

    See also

    LinPan2

    PanAz

    Pan4

    Balance2

    XFade2

  322. final case class Pan4(rate: Rate, in: GE, xpos: GE = 0.0f, ypos: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable

    A four channel equal-power panorama UGen.

    A four channel equal-power panorama UGen. The outputs are in order leftFront , rightFront , leftBack , rightBack .

    in

    (monophonic) input signal to be panned

    xpos

    horizontal panorama position from -1 (left) to +1 (right)

    ypos

    front-to-back panorama position from -1 (back) to +1 (front)

    level

    additional gain control

    See also

    Pan2

    PanAz

  323. final case class PanAz(rate: Rate, numChannels: Int, in: GE, pos: GE = 0.0f, level: GE = 1.0f, width: GE = 2.0f, orient: GE = 0.0f) extends MultiOut with Product with Serializable

    An azimuth-based panorama UGen.

    An azimuth-based panorama UGen. It uses vector-based-amplitude panning where the arbitrary number of speakers is supposed to be distributed in a circle with even spacing between them. It uses an equal-power-curve to transition between adjacent speakers. Note the different default value for the orient argument!

    Use case: To spread an multi-channel input signal across an output bus with a different number of channels, such that the first input channel is played on the first output channel (no spread to adjacent channels) and the last input channel is played to the last output channel (no spread to adjacent channels), you would create a dedicated PanAz per input channel where the pan position is inChanIdx * 2f / (inChannels - 1) * (outChannels - 1) / outChannels .

    numChannels

    the number of output channels

    in

    the input signal

    pos

    the pan position. Channels are evenly spaced over a cyclic period of 2.0. the output channel position is pos / 2 * numChannels + orient . Thus, assuming an orient of 0.0 , and numChannels being for example 3 , a pos of 0*2.0/3 == 0.0 corresponds to the first output channel, a pos of 1*2.0/3 corresponds to the second output channel, a pos of 2*2.0/3=4.0/3 corresponds to the third and last output channel, and a pos of 3*2.0/3=2.0 completes the circle and wraps again to the first channel. Using a bipolar pan position, such as a sawtooth that ranges from -1 to +1, all channels will be cyclically panned through. Must be control rate.

    level

    a control rate level input (linear multiplier).

    width

    the width of the panning envelope. The default of 2.0 pans between pairs of adjacent speakers. Width values greater than two will spread the pan over greater numbers of speakers. Width values less than one will leave silent gaps between speakers.

    orient

    the offset in the output channels regarding a pan position of zero. Note that ScalaCollider uses a default of zero which means that a pan pos of zero outputs the signal exactly on the first output channel. This is different in sclang where the default is 0.5 which means that a pan position of zero will output the signal between the first and second speaker. Accordingly, an orient of 1.0 would result in a channel offset of one, where a pan position of zero would output the signal exactly on the second output channel, and so forth.

    See also

    Pan2

    SplayAz

  324. final case class PanB(rate: Rate, in: GE, azimuth: GE = 0.0f, elevation: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable

    An Ambisonics B-format encoding UGen.

    An Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the X and Y channels.

    Note that unlike PanB2, azimuth is in radians.

    in

    (monophonic) input signal to be encoded

    azimuth

    position around the circle in radians. -Pi/+Pi is behind, -Pi/2 is left, 0 is front, +Pi/2 is right.

    elevation

    elevation in radians, from -Pi/2 (bottom) to +Pi/2 (top)

    level

    additional gain control

    See also

    PanB2

    DecodeB2

  325. final case class PanB2(rate: Rate, in: GE, azimuth: GE = 0.0f, level: GE = 1.0f) extends MultiOut with Product with Serializable

    A two dimensional Ambisonics B-format encoding UGen.

    A two dimensional Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which normally has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the W, X and Y channels.

    Note that unlike PanB, azimuth is normalized between -1 and +1.

    in

    (monophonic) input signal to be encoded

    azimuth

    position around the circle from -1 to +1. -1 and +1 correspond to -180/+180 degrees (behind), -0.5 is 90 degrees to the left, 0 is frontal, +0.5 is 90 degrees to the right.

    level

    additional gain control

    See also

    PanB

    BiPanB2

    DecodeB2

    Pan2

  326. final case class PartConv(rate: Rate, in: GE, fftSize: GE, buf: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen for partitioned convolution.

    A UGen for partitioned convolution. Its advantage over non-partitioning UGens such as Convolution2 is that the impulse response can be arbitrarily large amortization is used to spread processing and avoid CPU spikes.

    The impulse response buffer must be specially prepared, using a /b_gen command that transforms an existing regularly formatted buffer to a new partitioned convolution ready buffer.

    in

    the realtime input to be convolved

    fftSize

    FFT size which is twice the input signal partition size. This must be a multiple of the control-block size, and there must be at least two blocks per partition (to allow for amortization) (init-time only)

    buf

    buffer identifier for the fixed kernel (init-time only). (init-time only)

    See also

    Convolution

    Convolution2

  327. final case class Pause(gate: GE, node: GE) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable

    A UGen which pauses and resumes another node.

    A UGen which pauses and resumes another node. Note that the UGen initially assumes the node is running, that is, if gate is initially 1, this will not resume a paused node. Instead, the gate must go to zero and back to one to resume the node. Additionally, this UGen will only cause action if the gate value changes, that is, if the node is paused or resumed otherwise, this UGen will not interfere with that action, unless the gate value is adjusted.

    gate

    when 0, node is paused, when 1, node is resumed

    node

    the id of the node to be paused or resumed

    See also

    Free

    PauseSelf

  328. final case class PauseSelf(trig: GE) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable

    A UGen that, when triggered, pauses enclosing synth.

    A UGen that, when triggered, pauses enclosing synth. It pauses the enclosing synth when the input signal crosses from non-positive to positive.

    Note that if the trigger is initially high the UGen will not react. For example, PauseSelf.kr("foo".kr) will not work if the control is initially 1 . A work-around is to wrap the input in this case in a Trig object: PauseSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.

    This UGen outputs its input signal for convenience.

    trig

    the input signal which will trigger the action.

    See also

    Pause

    FreeSelf

  329. final case class PauseSelfWhenDone(src: GE with HasDoneFlag) extends SingleOut with ControlRated with HasSideEffect with Product with Serializable

    A UGen that, when its input UGen is finished, pauses enclosing synth.

    A UGen that, when its input UGen is finished, pauses enclosing synth. This is essentially a shortcut for PauseSelf.kr(Done.kr(src)) , so instead of providing a trigger signal it reads directly the done flag of an appropriate ugen (such as Line or PlayBuf ).

    This UGen outputs its input signal for convenience.

    src

    the input UGen which when finished will trigger the action.

    See also

    Pause

    PauseSelf

    FreeSelfWhenDone

    Done

  330. final case class Peak(rate: Rate, in: GE, trig: GE) extends SingleOut with Product with Serializable

    A UGen to measure a signal's peak amplitude.

    A UGen to measure a signal's peak amplitude. Technically, this UGen works like RunningMax after the absolute value of the input signal is taken.

    The UGen keeps an internal state that reflects the maximum absolute input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current absolute input value. This way, the peak value seen from the outside at trigger time is the correct peak value up to that moment. See the 'illustrate timing' example to understand this timing.

    in

    input signal to analyze

    trig

    resets the maximum observed value to the current absolute value of the input signal

    See also

    RunningMin

    RunningMax

    RunningSum

    PeakFollower

    Amplitude

  331. final case class PeakFollower(rate: MaybeRate, in: GE, decay: GE = 0.999f) extends SingleOut with Product with Serializable

    A UGen that continually reports the peak amplitude of the signal received at the input.

    A UGen that continually reports the peak amplitude of the signal received at the input. If the absolute input level drops below the observed peak value, this value decreases by the factor given as decay parameter (but no more than the current absolute input level).

    in

    input signal to trace

    decay

    feedback coefficient controlling the release rate. This should be less than one, otherwise the UGen may blow up.

    See also

    Peak

    Amplitude

    RunningSum

    LagUD

  332. final case class Phasor(rate: Rate, trig: GE = 0, speed: GE = 1.0f, lo: GE = 0.0f, hi: GE = 1.0f, resetVal: GE = 0.0f) extends SingleOut with Product with Serializable

    A linear repeating ramp UGen between start and end values.

    A linear repeating ramp UGen between start and end values. Using a trigger input, it can be reset to a specific position. Upon reaching the end of its ramp, Phasor will wrap back to its start value. Note: Since end is defined as the wrap point, its value is never actually output.

    trig

    trigger signal that causes the phasor to jump to the resetVal position

    speed

    amount of increment per sample frame. I.e at a speed of 1, each sample output by the UGen will be 1 greater than the preceding sample. To achieve a specific frequency f in Hertz, use a speed value of f / SampleRate.ir .

    lo

    start value of the ramp

    hi

    end value of the ramp (exclusive)

    resetVal

    value to jump to upon receiving a trigger in the trig input

    See also

    Ramp

    Stepper

    Line

    LFSaw

  333. final case class PhysicalIn(indices: GE, numChannels: Seq[Int]) extends GE.Lazy with AudioRated with Product with Serializable

    A graph element which reads from a connected sound driver input.

    A graph element which reads from a connected sound driver input. This is a convenience element for accessing physical input signals, e.g. from a microphone connected to your audio interface. It expands to a regular In UGen offset by NumOutputBuses.ir.

    For example, consider an audio interface with channels 1 to 8 being analog line inputs, channels 9 and 10 being AES/EBU and channels 11 to 18 being ADAT inputs. To read a combination of the analog and ADAT inputs, either of the following statement can be used:

    PhysicalIn(Seq(0, 8), Seq(8, 8))
    PhysicalIn(Seq(0, 8), Seq(8))      // numChannels wraps!

    If SuperCollider runs with less physical inputs than requested by this UGen, invalid channels are muted.

    indices

    the physical index to read from (beginning at zero which corresponds to the first channel of the audio interface or sound driver). It may be a multichannel element to specify discrete indices.

    numChannels

    the number of consecutive channels to read for each index. Wraps around if the sequence has less elements than indices has channels.

  334. final case class PhysicalOut(indices: GE, in: GE) extends ZeroOut with AudioRated with Product with Serializable

    A graph element which writes to a connected sound driver output.

    A graph element which writes to a connected sound driver output. This is a convenience element for Out with the ability to provide a set of discrete indices to which corresponding channels of the input signal are mapped, whereas multichannel expansion with respect to the index argument of Out typically do not achieve what you expect.

    If SuperCollider runs with less physical outputs than requested by this UGen, the output is muted.

    indices

    the physical index to write to (beginning at zero which corresponds to the first channel of the audio interface or sound driver). may be a multichannel argument to specify discrete channels. In this case, any remaining channels in in are associated with the last bus index offset.

    in

    the signal to write

  335. final case class PinkNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable

    A noise generator UGen whose spectrum falls off in power by 3 dB per octave.

    A noise generator UGen whose spectrum falls off in power by 3 dB per octave. This gives equal power over the span of each octave. This version gives 8 octaves of pink noise.

    The values produced by this UGen were observed to lie with very high probability between approx. -0.65 and +0.81 (before being multiplied by mul ). The RMS is approx. -16 dB.

    mul

    Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel mul argument will cause the generation of multiple independent noise generators.

    See also

    WhiteNoise

    BrownNoise

    GrayNoise

    ClipNoise

    RandSeed

  336. final case class Pitch(rate: Rate, in: GE, initFreq: GE = 440.0f, minFreq: GE = 60.0f, maxFreq: GE = 4000.0f, execFreq: GE = 100.0f, binsPerOct: GE = 16, median: GE = 1, ampThresh: GE = 0.01f, peakThresh: GE = 0.5f, downSample: GE = 1, clarity: GE = 0) extends MultiOut with Product with Serializable

    An autocorrelation based pitch following UGen.

    An autocorrelation based pitch following UGen. It is more accurate than ZeroCrossing , but more also more CPU costly. For most purposes the default settings can be used and only in needs to be supplied.

    The UGen has two outputs: The first output is the frequency estimate in Hertz, the second output is a toggle hasFreq , which tells whether a pitch was found (1) or not (0). If the clarify argument is used, hasFreq has more fine grained information.

    The pitch follower executes periodically at the rate specified by execFreq in cps. First it detects whether the input peak to peak amplitude is above the ampThresh . If it is not then no pitch estimation is performed, the hasFreq output is set to zero and the freq output is held at its previous value. Otherwise, the autocorrelation is calculated, and the first peak after the peak around the lag of zero that is above peakThresh times the amplitude of the peak at lag zero is reported.

    in

    The signal to be analyzed.

    initFreq

    The initial value of the freq output, until the first valid pitch is found. (init-time only)

    minFreq

    The minimum frequency in Hertz to be considered for reporting. (init-time only)

    maxFreq

    The maximum frequency in Hertz to be considered for reporting. (init-time only)

    execFreq

    The frequency at which the pitch is estimated. This will be automatically clipped to be between minFreq and maxFreq . (init-time only)

    binsPerOct

    A value which guides the search for the peak frequency in the first coarse step. Its setting does *not* affect the final pitch resolution; setting it larger will cause the coarse search to take longer, and setting it smaller will cause the fine search to take longer. (init-time only)

    median

    This specifies the length of a median filter applied to the frequency output estimation. With the default value of 1 the filter is defeated. Median filtering can help eliminating single spikes and jitter. This will however add latency to the output. (init-time only)

    ampThresh

    The minimum amplitude threshold above which the pitch follower operates. An input signal below this threshold is not analyzed. (init-time only)

    peakThresh

    This is a threshold used to find the first peak in the autocorrelation signal which gives the reported frequency. It is a factor of the energy of the signal (autocorrelation coefficient at zero). Set this value higher (e.g. to 1 ) to eliminate false frequencies corresponding to overtones. (init-time only)

    downSample

    An integer factor by which the input signal is down sampled to reduce CPU overhead. This will also reduce the pitch resolution. The default value of 1 means that the input signal is not down sampled. (init-time only)

    clarity

    If the clarity argument is greater than zero (it is zero by default) then the hasFreq output is given additional detail. Rather than simply being 1 when a pitch is detected, it is a "clarity" measure in the range between zero and one. (Technically, it's the height of the autocorrelation peak normalised by the height of the zero-lag peak.) It therefore gives a kind of measure of "purity" of the pitched signal. (init-time only)

  337. final case class PitchShift(in: GE, winSize: GE = 0.2f, pitchRatio: GE = 1.0f, pitchDispersion: GE = 0.0f, timeDispersion: GE = 0.0f) extends SingleOut with AudioRated with Product with Serializable

    A time domain granular pitch shifter.

    A time domain granular pitch shifter. Grains have a triangular amplitude envelope and an overlap of 4:1.

    in

    The input signal.

    winSize

    The size of the grain window in seconds. (init-time only)

    pitchRatio

    The ratio of the pitch shift. Must be from 0 to 4.

    pitchDispersion

    The maximum random deviation of the pitch from the pitchRatio.

    timeDispersion

    A random offset of from zero to timeDispersion seconds is added to the delay of each grain. Use of some dispersion can alleviate a hard comb filter effect due to uniform grain placement. It can also be an effect in itself. timeDispersion can be no larger than windowSize.

  338. final case class PlayBuf(rate: Rate, numChannels: Int, buf: GE, speed: GE = 1.0f, trig: GE = 1, offset: GE = 0.0f, loop: GE = 1, doneAction: GE = doNothing) extends MultiOut with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable

    A UGen to play back samples from a buffer in memory.

    A UGen to play back samples from a buffer in memory.

    PlayBuf provides a kind of high-level interface to sample-playback, whereas BufRd represents a kind of lower-level access. While BufRd has a random-access-pointer in the form of a phase input, PlayBuf advances the phase automatically based on a given playback speed. PlayBuf uses cubic interpolation.

    numChannels

    the number of channels that the buffer will be. Since this is a constant, a change in number of channels of the underlying bus must be reflected by creating different SynthDefs. If a buffer identifier is used of a buffer that has a different numChannels then specified in the PlayBuf, it will fail silently.

    buf

    the identifier of the buffer to use

    speed

    1 advances the play head by the server's sample rate each second. So 2 means doubling speed (and pitch), and 0.5 means half speed (and half pitch). Negative numbers can be used for backwards playback. If the underlying buffer represents a sound at a different sample rate, the rate should be multiplied by BufRateScale.kr(buf) to obtain the correct speed.

    trig

    a trigger which causes a jump to the given offset . A trigger occurs when a signal changes from non-positive to positive (e.g. <= 0 to > 0).

    offset

    sample frame to start playback. This is read when a trigger occurs. It may be fractional.

    loop

    1 to loop after the play head reaches the buffer end, 0 to not loop. This can be modulated.

    doneAction

    what to do when the play head reaches the buffer end. This is only effective when loop is zero.

    See also

    BufRd

    DiskIn

    RecordBuf

    DoneAction

    Done

    BufRateScale

    BufFrames

  339. final case class Pluck(in: GE, trig: GE = 1, maxDelayTime: GE = 0.2f, delayTime: GE = 0.2f, decayTime: GE = 1.0f, coeff: GE = 0.5f) extends SingleOut with AudioRated with Product with Serializable

    A Karplus-Strong UGen.

    A Karplus-Strong UGen.

    in

    An excitation signal.

    trig

    Upon a negative to positive transition, the excitation signal will be fed into the delay line.

    maxDelayTime

    Maximum delay time in seconds (initializes the internal delay buffer). (init-time only)

    delayTime

    Delay time in seconds.

    decayTime

    Time for the echoes to decay by 60 decibels. Negative times emphasize odd partials.

    coeff

    the coefficient of the internal OnePole filter. Values should be between -1 and +1 (larger values will be unstable... so be careful!).

  340. final case class Poll(rate: MaybeRate, trig: GE, in: GE, label: String = "poll", trigId: GE = -1) extends SingleOut with HasSideEffect with Product with Serializable

    A UGen for printing the current output value of its input to the console.

    A UGen for printing the current output value of its input to the console.

    trig

    a non-positive to positive transition telling Poll to return a value

    in

    the signal you want to poll

    label

    a string or symbol to be printed with the polled value

    trigId

    if greater then 0, a "/tr" OSC message is sent back to the client (similar to SendTrig )

    See also

    SendTrig

  341. final case class Pulse(rate: Rate, freq: GE = 440.0f, width: GE = 0.5f) extends SingleOut with Product with Serializable

    A band-limited pulse wave generator UGen, capable of pulse width modulation.

    A band-limited pulse wave generator UGen, capable of pulse width modulation.

    Note: The fine behavior depends on the server's block-size which interacts with the pulse width. The behavior is more regular if the duty period sr / freq * width is an integer multiple of the block-size. A width of 1.0 can produce strange results.

    freq

    Fundamental frequency in Hertz

    width

    Pulse width ratio from zero to one. 0.5 makes a square wave.

    See also

    LFPulse

  342. final case class PulseCount(rate: MaybeRate, trig: GE, reset: GE = 0) extends SingleOut with Product with Serializable

    A UGen that counts the number of triggers observed.

    A UGen that counts the number of triggers observed.

    trig

    a trigger happens when the signal changes from non-positive to positive

    reset

    when triggered, resets the counter to zero. When both trig and reset are triggered at the same time, the reset takes precedence (output will be zero).

    See also

    Stepper

  343. final case class PulseDivider(rate: MaybeRate, trig: GE, div: GE = 2, start: GE = 0) extends SingleOut with Product with Serializable

    A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.

    A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.

    trig

    a trigger occurs when the signal changes from non-positive to positive.

    div

    decimation factor of the UGen. A value of 1 would cause an output trigger for each input trigger, whereas a value of 2 would cause an output trigger each time the internal counter has seen two input triggers.

    start

    value of the internal counter. For example, if div is 2 , then a start value of 0 (default) means that the first output trigger happens after two input triggers, a start value of 1 means that the first output trigger happens after just one input trigger. Negative values can increase the number of required input triggers for the first output trigger. For example, if start is -1 , the first output trigger happens after three input triggers.

    See also

    PulseCount

    Stepper

  344. final case class QuadC(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = -1.0f, c: GE = -0.75f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A cubic-interpolating sound generator based on the difference equation:

    A cubic-interpolating sound generator based on the difference equation:

    x[n+1] = a * pow(x[n], 2) + b * x[n] + c
    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    c

    Equation variable

    xi

    Initial value of x

    See also

    QuadN

    QuadL

  345. final case class QuadL(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = -1.0f, c: GE = -0.75f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+1] = a * pow(x[n], 2) + b * x[n] + c
    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    c

    Equation variable

    xi

    Initial value of x

    See also

    QuadN

    QuadC

  346. final case class QuadN(rate: Rate, freq: GE = Nyquist(), a: GE = 1.0f, b: GE = -1.0f, c: GE = -0.75f, xi: GE = 0.0f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+1] = a * pow(x[n], 2) + b * x[n] + c
    freq

    Iteration frequency in Hertz

    a

    Equation variable

    b

    Equation variable

    c

    Equation variable

    xi

    Initial value of x

    See also

    QuadL

    QuadC

  347. final case class RHPF(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f) extends SingleOut with Product with Serializable

    A resonant high pass filter UGen.

    A resonant high pass filter UGen.

    in

    input signal to be filtered

    freq

    cutoff frequency in Hertz

    rq

    reciprocal of Q. The Q (or quality) is conventionally defined as cutoff-frequency / bandwidth, meaning that rq  = bandwidth / cutoff-frequency. A higher Q or lower rq produces a steeper filter.

    See also

    HPF

    RLPF

    Resonz

  348. final case class RLPF(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f) extends SingleOut with Product with Serializable

    A resonant low pass filter UGen.

    A resonant low pass filter UGen.

    in

    input signal to be filtered

    freq

    cutoff frequency in Hertz

    rq

    reciprocal of Q. The Q (or quality) is conventionally defined as cutoff-frequency / bandwidth, meaning that rq  = bandwidth / cutoff-frequency. A higher Q or lower rq produces a steeper filter.

    See also

    LPF

    RHPF

    Resonz

  349. final case class RMS(rate: Rate, in: GE, lpf: GE = 2.0f) extends SingleOut with Product with Serializable

    A UGen that calculates the root-mean-square of a first order low-pass filtered input signal.

    A UGen that calculates the root-mean-square of a first order low-pass filtered input signal. The formula is 'rms = sqrt(lpf1(x^2))'.

    This is a third-party UGen (DEINDUGens).

    in

    input signal to be analyzed

    lpf

    low-pass filter frequency in Hz

    See also

    Amplitude

  350. final case class RadiansPerSample() extends SingleOut with ScalarRated with Product with Serializable

    A UGen that delivers the conversion factor from frequency in Hertz to radians (normalized frequency).

    A UGen that delivers the conversion factor from frequency in Hertz to radians (normalized frequency). The relation is RadiansPerSample * sr = 2pi , thus multiplying the UGen with a frequency between zero and nyquist (sr/2) yields the normalized frequency between zero and pi.

    See also

    SampleRate

  351. final case class Ramp(rate: MaybeRate, in: GE, dur: GE = 0.1f) extends SingleOut with Product with Serializable

    A UGen which produces a linear lag (time smear) regarding and input signal.

    A UGen which produces a linear lag (time smear) regarding and input signal. Other than Lag which is a feedback filter with exponential decay, Ramp applies a linear ramp. This is achieved by sampling the input signal at regular intervals given by the lagTime and starting a new line segment after each interval.

    in

    the signal to smooth out

    dur

    the ramp-time (seconds) which is also the interval of the sampling

    See also

    Lag

    Sweep

  352. final case class Rand(lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with ScalarRated with IsIndividual with Product with Serializable

    A scalar UGen that generates a single random decimal value, using a uniform distribution from lo to hi .

    A scalar UGen that generates a single random decimal value, using a uniform distribution from lo to hi .

    lo

    lower limit of the output range

    hi

    upper limit of the output range

    See also

    IRand

    TRand

    ExpRand

    RandSeed

  353. final case class RandID(rate: Rate, id: GE = 0) extends SingleOut with HasSideEffect with Product with Serializable

    A UGen that determines which random number generator is used for the enclosing synth.

    A UGen that determines which random number generator is used for the enclosing synth. All synths that use the same generator reproduce the same sequence of numbers when the same seed is set again.

    id

    the random number generator identifier from zero until the maximum number of generators specified with the server switch -r (default: 64)

    See also

    Rand

    RandSeed

    IRand

    WhiteNoise

  354. final case class RandSeed(rate: Rate, trig: GE = 1, seed: GE = 56789) extends SingleOut with HasSideEffect with Product with Serializable

    A UGen that resets the seed of the synth's random number generator upon receiving a trigger.

    A UGen that resets the seed of the synth's random number generator upon receiving a trigger. All synths that use the same random number generator reproduce the same sequence of numbers again. The generator can be set using the RandID UGen.

    trig

    trigger that causes the seed to be set

    seed

    the seed for the random number generator, read at the moment the trigger arrives.

    See also

    Rand

    RandID

    IRand

    WhiteNoise

  355. final case class RecordBuf(rate: Rate, in: GE, buf: GE, offset: GE = 0, recLevel: GE = 1.0f, preLevel: GE = 0.0f, run: GE = 1, loop: GE = 1, trig: GE = 1, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable

    Records input into a Buffer.

    Records input into a Buffer. If recLevel is 1.0 and preLevel is 0.0 then the new input overwrites the old data. If they are both 1.0 then the new data is added to the existing data. (Any other settings are also valid.)

    in

    the signal to record

    buf

    the identifier of the buffer to use

    offset

    sample frame to begin writing from. This is read when a trigger occurs.

    recLevel

    value to multiply by input before mixing with existing data.

    preLevel

    value by which the previous buffer contents is multiplied when recording. If this value is zero, the buffer contents is completely overwritten. If this value is one, the new signal is added to the previous content.

    run

    if zero the recording pauses, otherwise it resumes. The value of run is only read at control-rate! When the recording is paused, the "write-head" remains in its current position and does not advance.

    loop

    1 to loop after the write head reaches the buffer end, 0 to not loop. This can be modulated.

    trig

    a trigger which causes a jump to the given offset . A trigger occurs when a signal changes from non-positive to positive (e.g. <= 0 to > 0).

    doneAction

    what to do when the write head reaches the buffer end. This is only effective when loop is zero.

    See also

    BufWr

    DiskOut

    PlayBuf

    DoneAction

    Done

    BufRateScale

    BufFrames

  356. final case class Reduce(elem: GE, op: Op) extends SingleOut with Product with Serializable
  357. final case class RepeatChannels(a: GE, num: Int) extends GE.Lazy with Product with Serializable

    An auxiliary graph element that repeats the channels of an input signal, allowing for example for an exhaustive element-wise combination with another signal.

    An auxiliary graph element that repeats the channels of an input signal, allowing for example for an exhaustive element-wise combination with another signal.

    Normally, the way multi-channel expansion works is that when two signals are combined, the output signal has a number of channels that is the maximum of the individual number of channels, and channels will be automatically wrapped around.

    For example, in x * y if x has three and y has five channels, the result expands to

    Seq[GE](
      x.out(0) * y.out(0), x.out(1) * y.out(1),
      x.out(2) * y.out(2), x.out(0) * y.out(3),
      x.out(1) * y.out(4)
    )

    Using this element, we can enforce the appearance of all combinations of channels, resulting in a signal whose number of channels is the sum of the individual number of channels.

    For example, RepeatChannels(x, 5) expands to

    Seq[GE](
      x.out(0), x.out(0), x.out(0), x.out(0), x.out(0),
      x.out(1), x.out(1), x.out(1), x.out(1), x.out(1),
      x.out(2), x.out(2), x.out(2), x.out(2), x.out(2)
    )

    And RepeatChannels(x, 5) * y accordingly expands to the fifteen-channels signal

    Seq[GE](
      (x out 0) * (y out 0), (x out 0) * (y out 1), (x out 0) * (y out 2), (x out 0) * (y out 3), (x out 0) * (y out 4),
      (x out 1) * (y out 0), (x out 1) * (y out 1), (x out 1) * (y out 2), (x out 1) * (y out 3), (x out 1) * (y out 4),
      (x out 2) * (y out 0), (x out 2) * (y out 1), (x out 2) * (y out 2), (x out 2) * (y out 3), (x out 2) * (y out 4)
    )
    a

    the signal whose channels to repeat

    num

    the number of repetitions for each input channel

    See also

    ChannelRangeProxy

  358. final case class ReplaceOut(bus: GE, in: GE) extends ZeroOut with AudioRated with HasSideEffect with IsIndividual with Product with Serializable

    A UGen that replace the contents of a bus with an input signal.

    A UGen that replace the contents of a bus with an input signal. Other than Out , the signal is not added to the previous contents of the bus but replaces it, allowing for a simple way of an "insert" effect.

    Multi-channel input signals, for example a PanAz , are written as such to the bus without expansion. That is, the bus index argument is used for the first channel, the second channel will appear on bus + 1 , etc.

    If you have an expanding multi-channel input, however, you have to be careful. For example, if you have PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results in one output UGen carrying one channel, and another one carrying two channels. (The way this works is consistent with SCLang). In order to get the correct behaviour (left outputs of the PanAz summed, and right output of the PanAz summed), wrap this expression in a Mix(...) before passing it to the output UGen.

    bus

    bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus.

    in

    signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.

    See also

    In

    Out

    XOut

  359. final case class Resonz(rate: MaybeRate, in: GE, freq: GE = 440.0f, rq: GE = 1.0f) extends SingleOut with Product with Serializable

    A two pole resonant filter UGen.

    A two pole resonant filter UGen. It has zeroes at z = +1 and z = -1.

    Based on K. Steiglitz, "A Note on Constant-Gain Digital Resonators", Computer Music Journal, vol 18, no. 4, pp. 8-10, Winter 1994.

    in

    input signal to be filtered

    freq

    resonant frequency in Hertz

    rq

    reciprocal of Q. The Q (or quality) is conventionally defined as center-frequency / bandwidth, meaning that rq  = bandwidth / center-frequency. A higher Q or lower rq produces a steeper filter.

    See also

    BPF

    Ringz

    HPF

    LPF

    MidEQ

  360. final case class Ringz(rate: MaybeRate, in: GE, freq: GE = 440.0f, decay: GE = 1.0f) extends SingleOut with Product with Serializable

    A resonant or "ringing" filter UGen.

    A resonant or "ringing" filter UGen. This is the same as Resonz , except that instead of a Q parameter, the bandwidth is specified as a 60 dB ring decay time. One Ringz is equivalent to one component of the Klank UGen.

    Note: Ringz and derived UGens Klank and Formlet produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.

    in

    input signal to be filtered

    freq

    resonant frequency in Hertz

    decay

    the 60 dB decay time in seconds

    See also

    Resonz

    Formlet

    BPF

    Klank

    MidEQ

  361. final case class Rotate2(rate: Rate, x: GE, y: GE, pos: GE = 0.0f) extends MultiOut with Product with Serializable

    A UGen that can be used for rotating an ambisonic B-format sound field around an axis.

    A UGen that can be used for rotating an ambisonic B-format sound field around an axis. It uses an equal-power rotation so it also works well on stereo sounds. It takes two audio inputs ( x , y ) and an angle control ( pos ). It outputs again two channels, using these formulas:

    xr = cos(angle) * x + sin(angle) * y
    yr = cos(angle) * y - sin(angle) * x

    where angle = pos * Pi . This allows, for example, the use of LFSaw to create a continuous rotation around a circle. Note: Be careful when accessing the output channels. xr and yr are the X and Y output channels, whereas x and y refers to the X and Y input channel.

    x

    B-format X input channel

    y

    B-format Y input channel

    pos

    angle to rotate around the circle, normalized between -1 and +1. -1 and +1 corresponds to -180 and +180 degrees (behind), -0.5 is 90 degrees left, 0 is frontal, +0.5 is 90 degrees right.

  362. final case class RunningMax(rate: Rate, in: GE, trig: GE) extends SingleOut with Product with Serializable

    A UGen to measure a signal's maximum value between triggers.

    A UGen to measure a signal's maximum value between triggers.

    The UGen keeps an internal state that reflects the maximum input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.

    in

    input signal to analyze

    trig

    resets the maximum observed value to the current value of the input signal

    See also

    RunningMin

    Peak

    RunningSum

  363. final case class RunningMin(rate: Rate, in: GE, trig: GE) extends SingleOut with Product with Serializable

    A UGen to measure a signal's minimum value between triggers.

    A UGen to measure a signal's minimum value between triggers.

    The UGen keeps an internal state that reflects the minimum input value observed. When a trigger occurs at the reset input, it first copies the current minimum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.

    in

    input signal to analyze

    trig

    resets the minimum observed value to the current value of the input signal

    See also

    RunningMax

    Peak

    RunningSum

  364. final case class RunningSum(rate: MaybeRate, in: GE, length: GE = 440) extends SingleOut with Product with Serializable

    A UGen calculating the sum of an input signal over a sliding window of given number of samples.

    A UGen calculating the sum of an input signal over a sliding window of given number of samples.

    Note: Unlike RunningMin and RunningMax , this is not a trigger based operation, but at any one time, the sum of the past length values is reported, continuously sliding the analysis window.

    in

    the input signal to sum up

    length

    the length of the sliding window over the input signal. these are the number of audio sample-frames for audio-rate calculation, or the number of blocks for control-rate calculation summed up. Warning: The UGen crashes when length is zero. (init-time only)

    See also

    Integrator

    Median

    PulseCount

  365. final case class SOS(rate: MaybeRate, in: GE, a0: GE = 0.0f, a1: GE = 0.0f, a2: GE = 0.0f, b1: GE = 0.0f, b2: GE = 0.0f) extends SingleOut with Product with Serializable

    A second order filter section (biquad) UGen.

    A second order filter section (biquad) UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:

    out(i) = a0 * in(i) + a1 * in(i-1) + a2 * in(i-2) + b1 * out(i-1) + b2 * out(i-2)
    in

    input signal to be filtered

    See also

    FOS

  366. final case class SampleDur() extends SingleOut with ScalarRated with Product with Serializable

    A UGen that reports the server's current (audio) sample period in seconds.

    A UGen that reports the server's current (audio) sample period in seconds. This is equivalent to the reciprocal of SampleRate

    See also

    SampleRate

    ControlDur

  367. final case class SampleRate() extends SingleOut with ScalarRated with Product with Serializable

    A UGen that reports the server's current (audio) sample rate.

    A UGen that reports the server's current (audio) sample rate. This is equivalent to the reciprocal of SampleDur

    See also

    SampleDur

    ControlRate

    RadiansPerSample

  368. final case class Saw(rate: Rate, freq: GE = 440.0f) extends SingleOut with Product with Serializable

    A band-limited sawtooth wave generator UGen.

    A band-limited sawtooth wave generator UGen.

    freq

    Fundamental frequency in Hertz

    See also

    LFSaw

  369. final case class Schmidt(rate: MaybeRate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable

    A Schmidt trigger UGen.

    A Schmidt trigger UGen. Initially it outputs zero. When the input signal rises above hi , its output switches to 1.0, which is hold until the signal falls below lo , switching the output again to 0.0. The produces a kind of hysteresis behavior, preventing heavy oscillations in a noisy system which might occur with a single-threshold trigger.

    in

    input signal to be analyzed

    lo

    low threshold

    hi

    high threshold

  370. final case class ScopeOut(rate: Rate, buf: GE, in: GE) extends ZeroOut with HasSideEffect with IsIndividual with Product with Serializable
  371. final case class ScopeOut2(rate: Rate, buf: GE, in: GE, maxFrames: GE = 4096, frames: GE) extends ZeroOut with HasSideEffect with IsIndividual with Product with Serializable
  372. final case class Select(rate: Rate, index: GE, in: GE) extends SingleOut with Product with Serializable

    A UGen which selects among a sequence of inputs, according to an index signal.

    A UGen which selects among a sequence of inputs, according to an index signal. Note that, although only one signal of the multi input is let through at a time, still all ugens are continuously running.

    index

    an index signal into the channels of the in argument. The index is automatically clipped to lie between 0 and in.numOutputs - 1 . The index is truncated to its integer part (not rounded), hence using for instance an index of 0.9 will still be interpreted as index 0 .

    in

    a graph element which is composed of the channels to be indexed.

    See also

    TWindex

  373. final case class SendReply(rate: MaybeRate, trig: GE, values: GE, msgName: String = "/reply", id: GE = 0) extends ZeroOut with HasSideEffect with Product with Serializable

    A UGen which sends an sequence of values from the server to all notified clients upon receiving triggers.

    A UGen which sends an sequence of values from the server to all notified clients upon receiving triggers. The message sent is osc.Message(<(String) msgName>, <(Int) nodeId>, <(Int) replyId>, <(Float) values>*) .

    For sending a single value, SendTrig provides an alternative.

    trig

    a non-positive to positive transition triggers a message

    values

    a graph element comprising the signal channels to be polled

    msgName

    a string specifying the OSC message's name. by convention, this should start with a forward slash and contain only 7-bit ascii characters.

    id

    an integer identifier which is contained in the reply message. While you can distinguish different SendReply instances from the same Synth by choosing different OSC message names, depending on the application you may use the same message name but different ids (similar to SendTrig ).

    Note

    The argument order is different from its sclang counterpart.

    See also

    SendTrig

  374. final case class SendTrig(rate: MaybeRate, trig: GE, value: GE = 0.0f, id: GE = 0) extends ZeroOut with HasSideEffect with Product with Serializable

    A UGen that sends a value from the server to all notified clients upon receiving triggers.

    A UGen that sends a value from the server to all notified clients upon receiving triggers. The message sent is osc.Message("/tr", <(Int) nodeId>, <(Int) trigId>, <(Float) value>) .

    For sending an array of values, or using an arbitrary reply command, see SendReply .

    trig

    the trigger signal causing the value to be read and sent. A trigger occurs when passing from non-positive to positive.

    value

    a changing signal or constant that will be polled at the time of trigger, and its value passed with the trigger message

    id

    an arbitrary integer that will be sent along with the "/tr" message. This is useful to distinguish between several SendTrig instances per SynthDef.

    Note

    The argument order is different from its sclang counterpart.

    See also

    SendReply

  375. final case class SetBuf(buf: GE, values: GE, offset: GE = 0) extends SingleOut with ScalarRated with HasSideEffect with IsIndividual with Product with Serializable

    A scalar (init-time) UGen that overwrites contents of a buffer with given values.

    A scalar (init-time) UGen that overwrites contents of a buffer with given values.

    buf

    the buffer to write the values into

    values

    values to write into the buffer

    offset

    frame offset into the buffer

    See also

    LocalBuf

    ClearBuf

  376. final case class SetResetFF(rate: MaybeRate, trig: GE, reset: GE) extends SingleOut with Product with Serializable

    A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0.

    A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0. Subsequent triggers happening within the same input slot have no effect. If both inputs receive a trigger at the same time, the reset input takes precedence.

    trig

    trigger that sets output to 1. A trigger happens when the signal changes from non-positive to positive.

    reset

    trigger that sets output to 0. A trigger happens when the signal changes from non-positive to positive.

    See also

    ToggleFF

  377. final case class Shaper(rate: Rate, buf: GE, in: GE) extends SingleOut with IsIndividual with Product with Serializable

    A waveshaping UGen.

    A waveshaping UGen. Waveshaping is a the process of translating an input signal by indexing a table (buffer).

    Advanced notes: wavetable format:

    Signal: [a0, a1, a2...]
    Wavetable: [2*a0-a1, a1-a0, 2*a1-a2, a2-a1, 2*a2-a3, a3-a2...]

    This strange format is not a standard linear interpolation (integer + frac), but for (integer part -1) and (1+frac)) due to some efficient maths for integer to float conversion in the underlying C code.

    buf

    buffer filled in wavetable format containing the transfer function.

    in

    signal to be fed into the wave shaper

    See also

    Index

    WrapIndex

  378. final case class Silent(numChannels: Int) extends GE.Lazy with AudioRated with Product with Serializable

    A graph element that produces a constant silent (zero) audio-rate output signal.

    A graph element that produces a constant silent (zero) audio-rate output signal.

    numChannels

    the number of output channels

    See also

    DC

  379. final case class SinOsc(rate: Rate, freq: GE = 440.0f, phase: GE = 0.0f) extends SingleOut with Product with Serializable

    A sinusoidal (sine tone) oscillator UGen.

    A sinusoidal (sine tone) oscillator UGen. This is the same as Osc except that it uses a built-in interpolating sine table of 8192 entries.

    Note that currently (SC 3.7.x), the first frame generated is not zero (i.e. the value of the sine oscillation at time zero) but the value at time 1 / SampleRate.ir .

    freq

    frequency in Hertz

    phase

    phase offset or modulator in radians

    See also

    Osc

    FSinOsc

    SinOscFB

  380. final case class SinOscFB(rate: Rate, freq: GE = 440.0f, feedback: GE = 0.0f) extends SingleOut with Product with Serializable

    A sine oscillator UGen that has phase modulation feedback.

    A sine oscillator UGen that has phase modulation feedback. Its output plugs back into the phase input, allowing a modulation between a sine wave and a sawtooth-like wave. "Over-modulation" causes chaotic oscillation. It may be useful to simulate feedback FM synths.

    freq

    frequency in Hertz

    feedback

    the amplitude of phase feedback in radians. a value of zero produces a clean sine wave.

    See also

    SinOsc

    FSinOsc

  381. final case class Slew(rate: MaybeRate, in: GE, up: GE = 1.0f, down: GE = 1.0f) extends SingleOut with Product with Serializable

    A slew rate limiter UGen.

    A slew rate limiter UGen. Limits the slope of an input signal. The slope is expressed in units per second.

    Since the UGen is initialized with the initial value of the input signal, some tricks must be applied to set it to an alternative start value. For example:

    val in = Select.kr(ToggleFF.kr(1), Seq("start".ir, "target".kr))
    Slew.kr(in)  // begins at "start" and moves towards "target"
    in

    input signal

    up

    maximum upward slope.

    down

    maximum downward slope.

  382. final case class Slope(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    A UGen measuring the slope of signal.

    A UGen measuring the slope of signal. It calculates the rate of change per second of a signal, as given by the following formula:

    out(i) = (in(i) - in(i-1)) * sampleRate

    It thus equal to HPZ1.ar(_) * 2 * SampleRate.ir

    in

    input signal to be measured

  383. final case class SpecCentroid(chain: GE) extends SingleOut with ControlRated with IsIndividual with Product with Serializable

    A UGen to measure the spectral centroid.

    A UGen to measure the spectral centroid. Given an FFT chain, this measures the spectral centroid, which is the weighted mean frequency, or the "centre of mass" of the spectrum. (DC is ignored.) This can be a useful indicator of the perceptual brightness of a signal.

    Note that the output frequency is pretty close to the correct value when feeding in a sine signal, but the estimate is usually too high when using for example filtered noise. In that case, you will get better results using SpecPcile at 50%.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    chain

    the fft signal (buffer) to analyze

    See also

    SpecPcile

  384. final case class SpecFlatness(chain: GE) extends SingleOut with ControlRated with IsIndividual with Product with Serializable

    A UGen to measure spectral flatness.

    A UGen to measure spectral flatness. Given an FFT chain this calculates the Spectral Flatness measure, defined as a power spectrum's geometric mean divided by its arithmetic mean. This gives a measure which ranges from approx 0 for a pure sinusoid, to approx 1 for white noise.

    The measure is calculated linearly. For some applications you may wish to convert the value to a decibel scale. Note that this UGen may output NaN when the input is zero (probably due to division by zero). In that case, CheckBadValues can be used to prevent further problems.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    chain

    the fft signal (buffer) to analyze

    See also

    CheckBadValues

  385. final case class SpecPcile(chain: GE, percent: GE = 0.5f, interp: GE = 0) extends SingleOut with ControlRated with IsIndividual with Product with Serializable

    A UGen to find the percentile of a signal's magnitude spectrum.

    A UGen to find the percentile of a signal's magnitude spectrum. Given an FFT chain this calculates the cumulative distribution of the frequency spectrum, and outputs the frequency value which corresponds to the desired percentile. For example, to find the frequency at which 90% of the spectral energy lies below that frequency, you want the 90-percentile, which means the value of percent should be 0.9. The 90-percentile or 95-percentile is often used as a measure of spectral roll-off.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    chain

    the fft signal (buffer) to analyze

    percent

    the percentage between 0.0 (0%) and 1.0 (100%)

    interp

    specifies whether interpolation should be used to try and make the percentile frequency estimate more accurate, at the cost of a little higher CPU usage. Set it to 1 to enable this.

  386. final case class Splay(rate: Rate, in: GE, spread: GE, center: GE, level: GE) extends GE.Lazy with Product with Serializable

    A graph element that spreads a sequence of input channels across a ring of output channels.

    A graph element that spreads a sequence of input channels across a ring of output channels. This works by feeding each input channel through a dedicated Pan2 UGen, and mixing the results together.

    The stereo panning position from -1 to +1 for each input channel with index ch is calculated by the formula:

    (ch * 2.0 / (num-in-channels - 1) - 1) + center

    Note: the spread argument is currently not implemented, and thus channels will always be distributed with a spread of 1.0.

    in

    the input signal

    spread

    the spacing between input channels with respect to the output panning. Note: currently not implemented

    center

    shifts the center of the distribution

    level

    a global gain factor (see Pan2)

    See also

    Pan2

    SplayAz

  387. final case class SplayAz(rate: Rate, numChannels: Int, in: GE, spread: GE, center: GE, level: GE, width: GE, orient: GE) extends GE.Lazy with Product with Serializable

    A graph element that spreads a sequence of input channels across a ring of output channels.

    A graph element that spreads a sequence of input channels across a ring of output channels. This works by feeding each input channel through a dedicated PanAz UGen, and mixing the results together.

    The panning position of each input channel with index ch is calculated by the formula:

    val pf = 2.0 / (num-in-channels - 1) * (num-out-channels - 1) / num-out-channels
    ch * pf + center

    Note: the spread argument is currently not implemented, and thus channels will always be distributed with a spread of 1.0.

    numChannels

    the number of output channels

    in

    the input signal

    spread

    the spacing between input channels with respect to the output panning. Note: currently not implemented

    center

    the position of the first channel (see PanAz)

    level

    a global gain factor (see PanAz)

    width

    the width parameter for each PanAz

    orient

    the orient parameter for each PanAz

    See also

    PanAz

    Splay

  388. final case class Spring(rate: MaybeRate, in: GE, spring: GE = 1.0f, damp: GE = 0.0f) extends SingleOut with Product with Serializable
  389. final case class Squiz(rate: Rate, in: GE, pitchRatio: GE = 2, zeroCrossings: GE = 1, maxDur: GE = 0.1f) extends SingleOut with Product with Serializable

    A UGen implementing a simplistic pitch-raising algorithm.

    A UGen implementing a simplistic pitch-raising algorithm. It is not meant to sound natural, and its sound is reminiscent of some weird mixture of filter, ring-modulator and pitch-shifter, depending on the input.

    The algorithm works by cutting the signal into fragments (delimited by upwards-going zero-crossings) and squeezing those fragments in the time domain (i.e. simply playing them back faster than they came in), leaving silences in between.

    This is a third-party UGen (MCLDUGens).

    in

    input signal to be distorted

    pitchRatio

    the ratio by which pitch will be raised, e.g. the default value of 2 will raise by one octave. Only upwards pitch-shifts are possible so a value below 1 has no effect.

    zeroCrossings

    how many positive-going zero-crossings are used to delimit a chunk.

    maxDur

    the maximum duration to remember each fragment, corresponding with an internally allocated memory. Raising it higher will use more real-time memory and probably will not sound very different (especially if zeroCrossings is low). (init-time only)

  390. final case class StandardL(rate: Rate, freq: GE = Nyquist(), k: GE = 1.0f, xi: GE = 0.5f, yi: GE = 0.0f) extends SingleOut with Product with Serializable

    A linear-interpolating sound generator based on the difference equations:

    A linear-interpolating sound generator based on the difference equations:

    x[n+1] = (x[n] + y[n+1]) % 2pi
    y[n+1] = (y[n] + k * sin(x[n])) % 2pi

    The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.

    freq

    Iteration frequency in Hertz

    k

    Perturbation amount

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    StandardN

  391. final case class StandardN(rate: Rate, freq: GE = Nyquist(), k: GE = 1.0f, xi: GE = 0.5f, yi: GE = 0.0f) extends SingleOut with Product with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = (x[n] + y[n+1]) % 2pi
    y[n+1] = (y[n] + k * sin(x[n])) % 2pi

    The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.

    freq

    Iteration frequency in Hertz

    k

    Perturbation amount

    xi

    Initial value of x

    yi

    Initial value of y

    See also

    StandardL

  392. final case class Stepper(rate: MaybeRate, trig: GE, reset: GE = 0, lo: GE = 0, hi: GE = 2147483583, step: GE = 1, resetVal: GE = 0) extends SingleOut with Product with Serializable

    A pulse counting UGen.

    A pulse counting UGen. Each trigger increments a counter which is output as a signal. The counter wraps inside the interval from lo to hi (inclusive). That if you use a lo other than zero, you might want to adjust resetVal as well. Stepper always starts with the value in resetVal , no matter what lo is or whether the reset trigger is high or not.

    trig

    The trigger signal which increments the counter. A trigger happens when the signal changes from non-positive to positive. Note that if the UGen is created with the trigger initially high, the counter will also be incremented immediately. Thus a Stepper.kr(Impulse.kr(1)) will begin by outputting 1 . If you want to avoid this, you could their subtract Impulse.kr(0) from the trigger input, or set resetVal to hi . E.g. Stepper.kr(Impulse.kr(1), lo = 0, hi = 4, resetVal = 4) will produce the sequence 0, 1, 2, 4, 0, ...

    reset

    A trigger which resets the counter to resetVal immediately.

    lo

    The minimum value output. For a decremental step value, the counter jumps to hi if it were to fall below lo .

    hi

    The maximum value output. For an incremental step value, the counter jumps to lo if it were to rise beyond hi . Note that values greater than 0x7FFFFFBF (the default) cause numeric overflow and the UGen to malfunction.

    step

    The amount by which the counter increases or decreases upon receiving triggers. Note that if you use a decremental counter, still lo must be the minimum and hi must be the maximum value output. If lo > hi , the UGen behaves wrongly. In the case of decremental counter, set resetVal to hi . E.g. to count from 4 down to 0, use Stepper.kr(trig, lo = 0, hi = 4, step = -1, resetVal = 4) , or, if you want to ignore an initial high trigger, you could do Stepper.kr(Impulse.kr(1), lo = 0, hi = 4, step = -1, resetVal = 0) -- so resetVal is lo but due to the initial trigger from Impulse the Stepper will in fact start outputting from 4 .

    See also

    PulseCount

  393. final case class StereoConvolution2L(rate: Rate, in: GE, kernelL: GE, kernelR: GE, trig: GE = 1, frameSize: GE, fadePeriods: GE = 1) extends MultiOut with IsIndividual with Product with Serializable

    A frequency domain stereo convolution UGen, capable of performing linear cross-fades between kernel updates.

    A frequency domain stereo convolution UGen, capable of performing linear cross-fades between kernel updates. When receiving a trigger, there is a linear cross-fade between the old kernel the new buffer contents. It operates similar to Convolution2L , however uses two buffers and outputs a stereo signal, resulting in better CPU usage than two discrete instances of Convolution2L as this way one FFT transformation per period is saved.

    Warning: This UGen seems currently broken (SC 3.6.3)

    in

    the realtime input to be convolved

    kernelL

    buffer identifier for the left channel's fixed kernel, which may be modulated in combination with the trigger

    kernelR

    buffer identifier for the right channel's fixed kernel, which may be modulated in combination with the trigger

    trig

    updates the kernel on a change from non-positive to positive (<= 0 to >0), and starts a new cross-fade from the previous kernel to the new one over the given amount of periods.

    frameSize

    size of the kernel. this must be a power of two. the FFT calculated internally by the UGen has a size of twice this value. The maximum allowed frameSize is 16384. (init-time only)

    fadePeriods

    fade duration expressed as number of convolved blocks. If the desired duration in seconds is dur , then the number of periods can be calculated as fadePeriods = dur * SampleRate.ir / frameSize . (init-time only)

    See also

    PartConv

    Convolution2

    Convolution

    Convolution2L

  394. final case class SubsampleOffset() extends SingleOut with ScalarRated with Product with Serializable

    A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.

    A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.

    When a synth is created from a time stamped osc-bundle, it starts calculation at the next possible block (normally 64 samples). Using an OffsetOut UGen, one can delay the audio so that it matches sample accurately.

    For some synthesis methods, one even needs subsample accuracy. SubsampleOffset provides the information where, within the current sample, the synth was scheduled. It can be used to offset envelopes or resample the audio output.

    See also

    ControlRate

    SampleDur

    OffsetOut

  395. final case class Sum3(in0: GE, in1: GE, in2: GE) extends SingleOut with Product with Serializable

    A UGen to efficiently add three signals together.

    A UGen to efficiently add three signals together. Usually used indirectly through Mix.

    in0

    first of the three inputs

    in1

    second of the three inputs

    in2

    third of the three inputs

    See also

    BinaryOpUGen

    MulAdd

    Sum4

  396. final case class Sum4(in0: GE, in1: GE, in2: GE, in3: GE) extends SingleOut with Product with Serializable

    A UGen to efficiently add four signals together.

    A UGen to efficiently add four signals together. Usually used indirectly through Mix.

    in0

    first of the four inputs

    in1

    second of the four inputs

    in2

    third of the four inputs

    in3

    fourth of the four inputs

    See also

    BinaryOpUGen

    MulAdd

    Sum3

  397. final case class Sweep(rate: Rate, trig: GE, speed: GE) extends SingleOut with Product with Serializable

    A UGen which starts a linear raise from zero each time it is triggered.

    A UGen which starts a linear raise from zero each time it is triggered.

    When speed is one, one gets a continually-updating measurement of the time (in seconds) since the last trigger.

    trig

    the trigger that restarts the ramp, when passing from non-positive to positive

    speed

    the amount of increment of the output signal per second. In SCLang this argument is named rate , while ScalaCollider uses speed to avoid conflict with the UGen's calculation rate.

    See also

    Ramp

    Phasor

    Line

  398. final case class SyncSaw(rate: Rate, syncFreq: GE = 440.0f, sawFreq: GE = 440.0f) extends SingleOut with Product with Serializable

    A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch.

    A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch. That is, a sawtooth waveform is produced at one frequency, sawFreq , whereas a trigger at a another frequency, syncFreq , resets the phase of the sawtooth to zero.

    This produces an effect similar to moving formants or pulse width modulation. This is not a band limited waveform, so it may alias.

    syncFreq

    synchronizing (principal) frequency which is the perceived fundamental

    sawFreq

    subordinate sawtooth frequency. It should typically be greater than syncFreq .

    See also

    Saw

    VarSaw

    LFSaw

  399. final case class T2A(in: GE) extends SingleOut with AudioRated with Product with Serializable

    A UGen that converts a control-rate trigger input into an audio-rate trigger output.

    A UGen that converts a control-rate trigger input into an audio-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The output will have a single sample spike of the input trigger's amplitude at the beginning of the calculation block.

    in

    control-rate trigger input

    See also

    K2A

    T2K

    Trig

  400. final case class T2K(in: GE) extends SingleOut with ControlRated with Product with Serializable

    A UGen that converts an audio-rate trigger input into a control-rate trigger output.

    A UGen that converts an audio-rate trigger input into a control-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The UGen behaves strangely in that for a rising slope input signal, it will report the maximum value seen within the calculation block, but if the slope extends to the next block, it will output that second's block maximum value again instead of waiting for a fall to <= 0.

    in

    audio-rate trigger input

    See also

    K2A

    T2K

    Trig

  401. final case class TBall(rate: MaybeRate, in: GE, g: GE = 10.0f, damp: GE = 0.0f, friction: GE = 0.01f) extends SingleOut with Product with Serializable
  402. final case class TDelay(rate: MaybeRate, trig: GE, dur: GE = 0.1f) extends SingleOut with Product with Serializable

    A delay UGen for trigger signals.

    A delay UGen for trigger signals. Other than a normal buffer delay, any new trigger arriving in the time between the previous trigger and the passing of the delay time is ignored.

    trig

    The input trigger. A trigger is recognized when the signal passes from non-positive to positive. Note that, no matter what the amplitude of the input trigger is, the UGen will output a delayed trigger of amplitude 1.0.

    dur

    The delay time in seconds.

  403. final case class TDuty(rate: Rate, dur: GE = 1.0f, level: GE = 1.0f, reset: GE = 0, doneAction: GE = doNothing, gapFirst: GE = 0) extends SingleOut with HasSideEffect with Product with Serializable

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input, and outputs them as trigger values.

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input, and outputs them as trigger values. A value from the level ugen is demanded and output for one sample (when running at audio-rate) or one block (when running at control-rate) according to a stream of duration values. When there is a trigger at the reset input, the level and the dur input are reset.

    dur

    the provider of time values. Can be a demand-rate ugen or any signal. The next poll is acquired after the previous duration.

    level

    a demand-rate ugen providing the output values.

    reset

    a trigger which resets the dur input (if demand-rated) and the the level input ugen. The reset input may also be a demand-rate ugen, in this case providing a stream of reset times.

    doneAction

    a doneAction that is evaluated when the duration stream ends.

    gapFirst

    when 0 (default), the UGen does the first level poll immediately and then waits for the first duration value. When this is 1, the UGen initially polls the first duration value, waits for that duration, and then polls the first level (along with polling the next duration value).

    Note

    The argument order is different from its sclang counterpart.

    See also

    Duty

    Demand

    DoneAction

  404. final case class TExpRand(rate: Rate, lo: GE = 0.01f, hi: GE = 1.0f, trig: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that generates a new random decimal value each time it is triggered, using an exponential distribution from lo to hi .

    A UGen that generates a new random decimal value each time it is triggered, using an exponential distribution from lo to hi . Values lo and hi must both have the same sign and be non-zero.

    Note: Audio-rate inputs for lo and hi are currently broken in SuperCollider, and will therefore be converted to control-rate inputs.

    lo

    lower limit of the output range

    hi

    upper limit of the output range

    trig

    signal to trigger new random number

    See also

    TRand

    ExpRand

    RandSeed

  405. final case class TGrains(numChannels: Int, trig: GE, buf: GE, speed: GE = 1.0f, centerPos: GE = 0.0f, dur: GE = 0.1f, pan: GE = 0.0f, amp: GE = 0.1f, interp: GE = 4) extends MultiOut with AudioRated with IsIndividual with Product with Serializable

    Triggers generate grains from a buffer.

    Triggers generate grains from a buffer. Each grain has a Hanning envelope

    (sin2(x) for x from 0 to pi)

    and is panned between two channels of multiple outputs. Warning: Due to a bug (SC 3.6.6), this UGen does not work with LocalBuf but requires a regular buffer.

    numChannels

    Number of output channels.

    trig

    At each trigger, the following arguments are sampled and used as the arguments of a new grain. A trigger occurs when a signal changes from non-positive to positive value. If the trigger is audio rate then the grains will start with sample accuracy.

    buf

    The buffer index. It must be a one channel (mono) buffer.

    speed

    1.0 is normal, 2.0 is one octave up, 0.5 is one octave down -1.0 is backwards normal rate etc.

    centerPos

    The position in the buffer in seconds at which the grain envelope will reach maximum amplitude.

    dur

    Duration of the grain in seconds.

    pan

    A value from -1 to 1. Determines where to pan the output in the same manner as PanAz.

    amp

    Amplitude of the grain.

    interp

    1, 2, or 4. Determines whether the grain uses (1) no interpolation, (2) linear interpolation, or (4) cubic interpolation.

    See also

    GrainBuf

  406. final case class TIRand(rate: Rate, lo: GE = 0, hi: GE = 127, trig: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that outputs integer random numbers when triggered.

    A UGen that outputs integer random numbers when triggered. The values have a uniform distribution from lo to hi (inclusive).

    Note: Audio-rate inputs for lo and hi are currently broken in SuperCollider, and will therefore be converted to control-rate inputs.

    lo

    lower limit of the output range

    hi

    upper limit of the output range (inclusive)

    trig

    signal to trigger new random number

    See also

    IRand

    TRand

  407. final case class TRand(rate: Rate, lo: GE = 0.0f, hi: GE = 1.0f, trig: GE) extends SingleOut with IsIndividual with Product with Serializable

    A UGen that generates a new random decimal value each time it is triggered, using a uniform distribution from lo to hi .

    A UGen that generates a new random decimal value each time it is triggered, using a uniform distribution from lo to hi .

    Note: Audio-rate inputs for lo and hi are currently broken in SuperCollider, and will therefore be converted to control-rate inputs.

    lo

    lower limit of the output range

    hi

    upper limit of the output range

    trig

    signal to trigger new random number

    See also

    IRand

    TRand

    ExpRand

    RandSeed

  408. final case class TWindex(rate: Rate, trig: GE, prob: GE, normalize: GE = 0) extends SingleOut with Product with Serializable

    A UGen providing a probability-weighted index into a sequence upon receiving a trigger.

    A UGen providing a probability-weighted index into a sequence upon receiving a trigger.

    When triggered, returns a random index value based the values of the channels of the prob argument functioning as probabilities. The index is zero based, hence goes from 0 to prob.numOutputs - 1 .

    By default the sequence of probabilities should sum to 1.0, however for convenience, this can be achieved by the ugen when the normalize flag is set to 1 (less efficient).

    trig

    the trigger used to calculate a new index. a trigger occurs when passing from non-positive to positive

    prob

    a multi-channel graph element, where the output channels correspond to to the probabilities of their respective indices being chosen.

    normalize

    0 if the seq argument already sums up to 1.0 and thus doesn't need normalization, 1 if the sum is not guaranteed to be 1.0 and thus the ugen is asked to provide the normalization.

    See also

    Select

  409. final case class Timer(rate: MaybeRate, trig: GE) extends SingleOut with Product with Serializable

    A UGen that returns time since last triggered.

    A UGen that returns time since last triggered. The time returned is in seconds and is measured from the last received trigger. Note that currently it seems the initial memory is at -1 sample, so for Impulse.ar(1) the result (at 44.1 kHz) is 2.26757e-05, followed strangely by 1.00002, and then (as expected) 1.0.

    trig

    the trigger to update the output signal. A trigger occurs when trig signal crosses from non-positive to positive.

    See also

    Sweep

  410. final case class ToggleFF(rate: MaybeRate, trig: GE) extends SingleOut with Product with Serializable

    A UGen that toggles like a flip-flop between zero and one upon receiving a trigger.

    A UGen that toggles like a flip-flop between zero and one upon receiving a trigger. The flip-flop initially outputs zero and changes to one when the first trigger arrives.

    trig

    a signal to trigger the flip-flop. a trigger occurs when the signal changes from non-positive to positive.

    See also

    SetResetFF

  411. final case class Trig(rate: Rate, in: GE, dur: GE = 0.1f) extends SingleOut with Product with Serializable

    A UGen which holds and outputs an input value for a given duration when triggered.

    A UGen which holds and outputs an input value for a given duration when triggered.

    When a trigger occurs at the input, the input value is sampled and output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.

    Warning: The hold-time is subject to a bug that depends on the input signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one actually gets a high signal for five sample frames instead of four.

    in

    the trigger. This can be any signal. A trigger happens when the signal changes from non-positive to positive.

    dur

    the duration for which the ugens holds the value of the input signal when triggered

    See also

    Trig1

  412. final case class Trig1(rate: Rate, in: GE, dur: GE = 0.1f) extends SingleOut with Product with Serializable

    A UGen which outputs a value of 1 for a given duration when triggered.

    A UGen which outputs a value of 1 for a given duration when triggered.

    When a trigger occurs at the input, a value of 1 is output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.

    Warning: The hold-time is subject to a bug that depends on the input signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one actually gets a high signal for five sample frames instead of four.

    in

    the trigger. This can be any signal. A trigger happens when the signal changes from non-positive to positive.

    dur

    the duration for which the ugens holds the value of 1 when triggered

    See also

    Trig

  413. final case class TrigControl(values: IndexedSeq[Float], ctrlName: Option[String]) extends MultiOut with ControlRated with Product with Serializable
  414. final case class TrigControlProxy(values: IndexedSeq[Float], name: Option[String]) extends ControlProxyLike with ControlRated with Product with Serializable
  415. final case class TwoPole(rate: MaybeRate, in: GE, freq: GE = 440.0f, radius: GE = 0.8f) extends SingleOut with Product with Serializable

    A two pole filter UGen.

    A two pole filter UGen. This provides lower level access to setting of pole location. For general purposes Resonz is better.

    in

    input signal to be filtered

    freq

    frequency of pole angle, in Hertz

    radius

    radius of pole angle. Should be between 0 and 1

    See also

    OnePole

    TwoZero

    Resonz

  416. final case class TwoZero(rate: MaybeRate, in: GE, freq: GE = 440.0f, radius: GE = 0.8f) extends SingleOut with Product with Serializable

    A two zero filter UGen.

    A two zero filter UGen.

    in

    input signal to be filtered

    freq

    frequency of zero angle, in Hertz

    radius

    radius of zero

    See also

    OneZero

    TwoPole

  417. sealed trait UGenInGroup extends UGenInLike

    A trait that can be either a group of UGenInLike or a UGen.MultiOut

  418. final case class UGenOutProxy(source: MultiOut, outputIndex: Int) extends UGenIn with UGenProxy with Product with Serializable

    A UGenOutProxy refers to a particular output of a multi-channel UGen.

    A UGenOutProxy refers to a particular output of a multi-channel UGen. A sequence of these form the representation of a multi-channel-expanded UGen.

  419. sealed trait UGenProxy extends UGenIn
  420. abstract class UnaryOpUGen extends SingleOut
  421. final case class Unpack1FFT(chain: GE, fftSize: GE, bin: GE, which: GE = 0) extends SingleOut with DemandRated with IsIndividual with Product with Serializable
  422. final case class VBAP(rate: MaybeRate, numChannels: Int, in: GE, buf: GE, azimuth: GE = 0, elevation: GE = 1, spread: GE = 0) extends MultiOut with Product with Serializable

    A UGen for Vector Base Amplitude Panning (VBAP).

    A UGen for Vector Base Amplitude Panning (VBAP). This allows for equal power panning of a source over an arbitrary array of equidistant speakers. Normally this would be a ring, a dome, or partial dome.

    VBAP was created by Ville Pulkki. For more information on VBAP see http://www.acoustics.hut.fi/research/cat/vbap/ This version of VBAP for SC was ported from the ver. 0.99 PD code by Scott Wilson.

    This is a third-party UGen (VBAPUGens).

    numChannels

    the number of output channels

    in

    the signal to be panned

    buf

    id of a buffer containing data calculated by VBAPSetup . Its number of channels must correspond to numChannels

    azimuth

    +/- 180° from the median plane (i.e. straight ahead)

    elevation

    +/- 90° from the azimuth plane

    spread

    A value from 0-100. When 0, if the signal is panned exactly to a speaker location the signal is only on that speaker. At values higher than 0, the signal will always be on more than one speaker. This can smooth the panning effect by making localisation blur more constant.

    See also

    CircleRamp

  423. trait VBAPSetup extends AnyRef
  424. final case class VDiskIn(rate: Rate, numChannels: Int, buf: GE, speed: GE = 1.0f, loop: GE = 0, sendId: GE = 0) extends MultiOut with HasSideEffect with IsIndividual with HasDoneFlag with Product with Serializable

    A UGen to stream in a signal from an audio file with variable playback speed.

    A UGen to stream in a signal from an audio file with variable playback speed. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.

    Note: The buffer size must be a multiple of (2 * the server's block size). See Buffer#cue for details.

    If the speed is too high, the UGen will not execute, posting a warning.

    numChannels

    the amount of channels the file and the buffer will have. This is an Int and hence must be pre-determined. Different SynthDefs must be created for different numbers of channels

    buf

    the id of the buffer with the correct number of channels and frames

    speed

    controls the speed of playback. The buffer is always streamed at a frequency of SampleRate.ir * speed , so the buffer's own sample rate is irrelevant. Factors below 4 are probably fine, but the higher the value, the more disk activity there is, and the more likelihood there will be a problem. The following must be true: rate < bufFrames / (2 * blockSize) , e.g with typical default values, this will be 32768 / (2 * 64) = 256 .

    loop

    whether the file should loop when its end is reached

    sendId

    If a value other than zero is used, the UGen sends an OSC message with this id and the file position each time it reloads the buffer: OSCMessage("/diskin", nodeId, sendId, frame)

    See also

    Buffer#cue

    DiskIn

    DiskOut

    PlayBuf

  425. final case class VOsc(rate: Rate, bufPos: GE, freq: GE = 440.0f, phase: GE = 0.0f) extends SingleOut with IsIndividual with Product with Serializable
  426. final case class VOsc3(rate: Rate, bufPos: GE, freq1: GE = 110.0f, freq2: GE = 220.0f, freq3: GE = 440.0f) extends SingleOut with IsIndividual with Product with Serializable
  427. final case class VarSaw(rate: Rate, freq: GE = 440.0f, iphase: GE = 0.0f, width: GE = 0.5f) extends SingleOut with Product with Serializable

    A sawtooth-triangle oscillator UGen with variable duty.

    A sawtooth-triangle oscillator UGen with variable duty. A width of zero produces a sawtooth of falling slope, with an initial phase of zero making it start at +1. A width of 0.5 produces a triangle wave, starting at -1 then raising to +1, then falling again to -1. A width of 1.0 produces a sawtooth of rising slope, starting -1.

    Increasing the initial wave will increase the offset into the waveform. For example, with a phase of 0.5 and a width of 0.5, the result is a triangle waveform that starts at +1.

    There is a strange anomaly for the falling sawtooth (zero width): Instead of starting directly at +1, the first sample is -1 and only from the second sample at +1 the waveform starts falling. In other words, the waveform has a delay of one sample.

    freq

    frequency in Hertz

    iphase

    initial phase offset in cycle (0 to 1)

    width

    duty cycle from zero to one.

    See also

    Saw

    LFSaw

    SyncSaw

  428. final case class Vibrato(rate: Rate, freq: GE = 440.0f, beat: GE = 6.0f, depth: GE = 0.02f, delay: GE = 0.0f, onset: GE = 0.0f, beatVar: GE = 0.04f, depthVar: GE = 0.1f, iphase: GE = 0.0f) extends SingleOut with Product with Serializable

    A low frequency oscillator UGen for modelling vibrato.

    A low frequency oscillator UGen for modelling vibrato. It produces a modulating frequency value in Hertz that can be used as the frequency parameter of another UGen.

    By setting more extreme settings, one can get back to the timbres of FM synthesis. One can also add in some noise to the vibrato rate and vibrato size (modulation depth) to make for a more realistic motor pattern.

    The vibrato output is a waveform based on a squared envelope shape with four stages marking out 0.0 to 1.0, 1.0 to 0.0, 0.0 to -1.0, and -1.0 back to 0.0. The vibrato rate determines how quickly one moves through these stages.

    freq

    fundamental frequency in Hertz. If the Vibrato UGen is running at audio rate, this must be an audio-rate input as well.

    beat

    vibrato rate, that is the speed of wobble in Hertz. Note that if this is set to a too low value, you may never get vibrato back, since this input is only checked at the end of a cycle.

    depth

    amount of vibrato frequency deviation around the fundamental, as a proportion of the fundamental.

    delay

    delay in seconds before vibrato is established. (init-time only)

    onset

    transition time in seconds from no vibrato to full vibrato after the initial delay time. (init-time only)

    beatVar

    random (noise) variation on the beat parameter, expressed as a proportion of beat . It can change once per cycle of vibrato.

    depthVar

    random (noise) variation on the depth of modulation, expressed as a proportion of depth . It can change once per cycle of vibrato. The noise affects independently the up and the down part of vibrato shape within a cycle.

    iphase

    initial phase of vibrato modulation, allowing starting above or below the fundamental rather than on it. (init-time only)

  429. final case class Warp1(numChannels: Int, buf: GE, pos: GE = 0.0f, speed: GE = 1.0f, winSize: GE = 0.2f, envBuf: GE = -1, overlaps: GE = 8.0f, winRand: GE = 0.0f, interp: GE = 1) extends MultiOut with AudioRated with IsIndividual with Product with Serializable
  430. final case class WaveLoss(rate: MaybeRate, in: GE, drop: GE = 20, chunk: GE = 40, mode: GE = 1) extends SingleOut with IsIndividual with Product with Serializable

    A UGen which uses zero-crossings to divide an input signal into tiny segments.

    A UGen which uses zero-crossings to divide an input signal into tiny segments. It simply discards a fraction of the segments (replacing them with silence).

    The technique was described in a lecture by Trevor Wishart.

    This is a third-party UGen (MCLDUGens).

    in

    input signal to be distorted

    drop

    the number of wave segments to drop in each group of size chunk .

    chunk

    the number of wave segments that are grouped, so that drop elements from it are removed.

    mode

    1 for deterministic mode, in which always the first drop segments within a chunk are dropped, 2 for randomized mode, where drop segments at random indices within a chunk are dropped.

  431. final case class WhiteNoise(rate: Rate, mul: GE = 1.0f) extends SingleOut with IsIndividual with Product with Serializable

    A noise generator UGens whose spectrum has equal power at all frequencies.

    A noise generator UGens whose spectrum has equal power at all frequencies. Output values range from -1 to +1 (before being multiplied by mul ). The RMS is approx. -4.8 dB.

    mul

    Not actually a UGen input, this argument produces a multiplication of the output by this factor. A multi-channel mul argument will cause the generation of multiple independent noise generators.

    See also

    PinkNoise

    BrownNoise

    GrayNoise

    ClipNoise

    RandSeed

    LFNoise0

    Dust

  432. final case class Wrap(rate: Rate, in: GE, lo: GE = 0.0f, hi: GE = 1.0f) extends SingleOut with Product with Serializable

    A UGen that constrains a signal to a given range, by "wrapping" values outside the range.

    A UGen that constrains a signal to a given range, by "wrapping" values outside the range. This is similar to the wrap2 binary operator but permits both a lower range value lo and an upper range value hi .

    An input value greater than or equal to hi will be wrapped back to (in - hi) % (hi - lo) + lo . An input value less than lo will be wrapped back to hi - (lo - in) % (hi - lo) .

    in

    input signal to constrain

    lo

    lower margin of wrapping (inclusive)

    hi

    upper margin of wrapping (exclusive)

    See also

    Fold

    Clip

  433. final case class WrapIndex(rate: Rate, buf: GE, in: GE = 0) extends SingleOut with IsIndividual with Product with Serializable

    A UGen which reads a single sample value from a buffer at a given index.

    A UGen which reads a single sample value from a buffer at a given index.

    It uses the in argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are wrapped around the valid range. For example, if the buffer has four samples, index 4 is wrapped to index 0, index 5 is wrapped to index 1, index -1 is wrapped to index 3, index -2 is wrapped to index 2, etc.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the Index UGen for details.

    buf

    The buffer to read from.

    in

    The sample index into the buffer. This is truncated to an integer automatically.

    See also

    Index

    FoldIndex

    IndexL

  434. final case class WrapOut(in: GE, fadeTime: Double = 0.02) extends ZeroOut with WritesBus with Product with Serializable

    An element which writes an input signal to a bus, optionally applying a short fade-in.

    An element which writes an input signal to a bus, optionally applying a short fade-in. This is automatically added when using the play { ... } syntax. If the fade time is given, an envelope is added with a control named "gate" which can be used to release the synth. The bus is given by a control named "out" and defaults to zero.

    in

    the signal to play to the default output

    fadeTime

    the fade in time; use a negative number for no fading

  435. final case class XFade2(rate: Rate, inA: GE, inB: GE = 0.0f, pan: GE = 0.0f, level: GE = 1.0f) extends SingleOut with Product with Serializable

    An equal power two channel cross fading UGen.

    An equal power two channel cross fading UGen. In center position ( pan = 0 ), both input signals are attenuated by sqrt(0.5) or approx. -3 dB.

    inA

    The first input signal

    inB

    The second input signal

    pan

    the cross-fade position from -1 (only input A audible) to +1 (only input B audible)

    level

    An overall amplitude multiplier that is applied to the output signal

    See also

    LinXFade2

    Pan2

    XOut

  436. final case class XLine(rate: Rate, start: GE = 1.0f, end: GE = 2.0f, dur: GE = 1.0f, doneAction: GE = doNothing) extends SingleOut with HasSideEffect with HasDoneFlag with Product with Serializable

    An exponential curve generator UGen that moves from a start value to the end value in a given duration.

    An exponential curve generator UGen that moves from a start value to the end value in a given duration.

    At a given point in time 0 <= t <= dur , the output value is start * (stop/start).pow(t/dur) .

    Warning: It must be ensured that the both start is not zero and start and end have the same sign (e.g. a start of -1 and an end of -0.001 are valid), otherwise the UGen will output a NaN ! While in the case of end being zero the UGen will also output zero, it is recommended to treat this case as pathological as well.

    Warning: Durations greater than around 2.8e6 seconds cause the UGen to misbehave and jump to the end value directly.

    start

    Starting value (init-time only)

    end

    Ending value (init-time only)

    dur

    Duration in seconds (init-time only)

    doneAction

    A done-action that is evaluated when the Line has reached the end value after the given duration

    See also

    Line

  437. final case class XOut(rate: Rate, bus: GE, in: GE, xfade: GE) extends ZeroOut with HasSideEffect with IsIndividual with Product with Serializable

    A UGen that cross-fades the contents of a bus with an input signal.

    A UGen that cross-fades the contents of a bus with an input signal. A linear cross-fade can go from 0.0 (previous bus contents preserved, no input signal added) via 0.5 (previous signal attenuated by -6 dB, input signal attenuated by -6 dB and added) to 1.0 (contents completely replaced by input signal).

    bus

    bus index to write to. For an audio-rate UGen, this is an audio-bus, for a control-rate UGen, this is a control-bus.

    in

    signal to write to the bus. If the UGen is audio-rate, the input must also be audio-rate.

    xfade

    cross-fade value. The new bus contents will be old_bus_content * (1 - xfade) + in * xfade

    Note

    The argument order is different from its sclang counterpart.

    See also

    In

    Out

    XOut

  438. final case class ZeroCrossing(rate: MaybeRate, in: GE) extends SingleOut with Product with Serializable

    A pitch estimation UGen based on counting the zero-crossings of the input signal.

    A pitch estimation UGen based on counting the zero-crossings of the input signal. This is a very crude pitch follower, but can be useful in some situations.

    in

    signal to analyze

    See also

    Pitch

  439. final case class Zip(elems: GE*) extends GE.Lazy with Product with Serializable

    A graph element that interleaves a number of (multi-channel) input signals.

    A graph element that interleaves a number of (multi-channel) input signals. For example, if two stereo-signals a and b are zipped, the output will be a four-channel signal corresponding to [ a out 0, b out 0, a out 1, b out 1 ]. If the input signals have different numbers of channels, the minimum number of channels is used.

    Examples
    // peak and RMS metering
    val x = play {
      val sig   = PhysicalIn.ar(0 to 1)  // stereo input
      val tr    = Impulse.kr(5)
      val peak  = Peak.kr(sig, tr)
      val rms   = A2K.kr(Lag.ar(sig.squared, 0.1))
      SendReply.kr(tr, Zip(peak, rms), "/meter")
    }
    
    val r = message.Responder.add(x.server) {
      case osc.Message("/meter", x.id, _, peakL: Float, rmsL: Float, peakR: Float, rmsR: Float) =>
        println(f"peak-left $peakL%g, rms-left $rmsL%g, peak-right $peakR%g, rms-right $rmsR%g")
    
    x.free(); r.remove()
    elems

    the signals to interleave in a multi-channel output signal

Value Members

  1. object A2K extends ProductReader[A2K] with Serializable

    A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling.

    A converter UGen that takes an audio-rate input and produces a control-rate output by means of sampling. The sample is always taken at the beginning of each control-block, while all other samples of the audio-rate input within that block are ignored.

    See also

    K2A

    T2K

  2. object APF extends ProductReader[APF] with Serializable
  3. object AllpassC extends ProductReader[AllpassC] with Serializable

    All pass delay line with cubic interpolation.

    All pass delay line with cubic interpolation.

    See also

    AllpassN

    AllpassL

  4. object AllpassL extends ProductReader[AllpassL] with Serializable

    All pass delay line with linear interpolation.

    All pass delay line with linear interpolation.

    See also

    AllpassN

    AllpassC

  5. object AllpassN extends ProductReader[AllpassN] with Serializable

    All pass delay line with no interpolation.

    All pass delay line with no interpolation.

    See also

    AllpassL

    AllpassC

  6. object AmpComp extends ProductReader[AmpComp] with Serializable

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.

    Implements the formula: (root / freq).pow(exp)

    Higher frequencies are normally perceived as louder, therefore AmpComp outputs lower values for them. For example, with default parameters, the pitch C4 (frequency 262 Hz) produces the base factor of 1.0, whereas a pitch one octave up, C5 (or 523 Hz) produces a factor of 0.793719 (an attenuation of -2 dB).

    An alternative is AmpCompA that better models the bell-shaped equal loudness contours of the hearing system. Especially note that the output of this UGen can become very high for frequencies much lower than the root parameter.

    Examples
    // activate with mouse button
    play {
      val freq = MouseX.kr(300, 15000, 1)
      val mod  = freq * SinOsc.ar(MouseY.kr(3, 200, 1)).mulAdd(0.5, 1)
      val corr = AmpComp.ar(mod, 300) * 2
      val amp  = Select.ar(MouseButton.kr(lag = 0), Seq(DC.ar(1), corr))
      SinOsc.ar(mod) * 0.1 * amp
    }
    See also

    AmpCompA

  7. object AmpCompA extends ProductReader[AmpCompA] with Serializable

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency.

    A UGen that produces a psychoacoustic amplitude compensation factor for a given frequency. It uses the A-weighting curve that is based on the Fletcher-Munson curve for rather low volume sounds (40 phon).

    Only the freq parameter can be modulated, the other parameters are read at initialization time only.

    Examples
    // activate with mouse button
    play {
      val freq = MouseX.kr(300, 15000, 1)
      val mod  = freq * SinOsc.ar(MouseY.kr(3, 200, 1)).mulAdd(0.5, 1)
      val corr = AmpCompA.ar(mod, 300) * 2
      val amp  = Select.ar(MouseButton.kr(lag = 0), Seq(DC.ar(1), corr))
      SinOsc.ar(mod) * 0.1 * amp
    }
    See also

    AmpComp

  8. object Amplitude extends ProductReader[Amplitude] with Serializable

    An amplitude follower UGen.

    An amplitude follower UGen. Tracks and reports the peak amplitude of its input signal.

    Examples
    // use sound-card input to control pulse amplitude
    play {
      // use headphones to prevent feedback!
      Pulse.ar(90, 0.3) * Amplitude.kr(PhysicalIn.ar(0))
    }
    // compare with known amplitude
    play {
      val amp = MouseX.kr
      val in  = PinkNoise.ar(amp)
      val ana = Amplitude.kr(amp, attack = 2, release = 2)
      (ana - amp).poll(2, "discrepancy")
      in
    }
    See also

    DetectSilence

  9. object ArrayMax extends ProductReader[ArrayMax] with Serializable

    A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.

    A UGen that finds the largest value across the channels of its input signal, providing both the value and the index.

    Examples
    // randomly changing array of three numbers
    play {
      val tr  = Impulse.kr(1)
      val sig = Vector.fill(3)(TIRand.kr(0, 100, tr))
      sig.zipWithIndex.foreach { case (n, i) => n.poll(tr, s"sig[$i]") }
      val m   = ArrayMax.kr(sig)
      m.value.poll(tr, "max-value")
      m.index.poll(tr, "max-index")
      ()
    }

    This is a third-party UGen (MCLDUGens).

    See also

    ArrayMin

    BufMax

  10. object ArrayMin extends ProductReader[ArrayMin] with Serializable

    A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.

    A UGen that finds the smallest value across the channels of its input signal, providing both the value and the index.

    Examples
    // randomly changing array of three numbers
    play {
      val tr  = Impulse.kr(1)
      val sig = Vector.fill(3)(TIRand.kr(0, 100, tr))
      sig.zipWithIndex.foreach { case (n, i) => n.poll(tr, s"sig[$i]") }
      val m   = ArrayMin.kr(sig)
      m.value.poll(tr, "min-value")
      m.index.poll(tr, "min-index")
      ()
    }

    This is a third-party UGen (MCLDUGens).

    See also

    ArrayMax

    BufMin

  11. object AudioControl extends ProductReader[AudioControl] with Serializable
  12. object AudioControlProxy extends ProductReader[AudioControlProxy] with Serializable
  13. object BAllPass extends ProductReader[BAllPass] with Serializable

    An all pass filter UGen.

    An all pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  14. object BBandPass extends ProductReader[BBandPass] with Serializable

    An band pass filter UGen.

    An band pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  15. object BBandStop extends ProductReader[BBandStop] with Serializable

    An band stop (reject) filter UGen.

    An band stop (reject) filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  16. object BHiPass extends ProductReader[BHiPass] with Serializable

    A 2nd order (12db per oct roll-off) resonant high pass filter UGen.

    A 2nd order (12db per oct roll-off) resonant high pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  17. object BHiShelf extends ProductReader[BHiShelf] with Serializable

    A high shelf equalizer UGen.

    A high shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  18. object BLowPass extends ProductReader[BLowPass] with Serializable

    A 2nd order (12db per oct roll-off) resonant low pass filter UGen.

    A 2nd order (12db per oct roll-off) resonant low pass filter UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  19. object BLowShelf extends ProductReader[BLowShelf] with Serializable

    A low shelf equalizer UGen.

    A low shelf equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  20. object BPF extends ProductReader[BPF] with Serializable

    A second order band pass filter UGen.

    A second order band pass filter UGen.

    Examples
    // modulated frequency
    play {
      val in   = Saw.ar(200) * 0.5
      val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(3600, 4000)
      BPF.ar(in, freq)
    }
    // mouse controlled frequency and Q
    play {
      val in   = WhiteNoise.ar(0.5)
      val freq = MouseX.kr(200, 10000, 1)
      val q    = MouseY.kr(1, 100, 1) // bottom to top
      val flt  = BPF.ar(in, freq, q.reciprocal)
      flt * q.sqrt // compensate for energy loss
    }
    See also

    HPF

    LPF

    BRF

    Resonz

    MidEQ

  21. object BPZ2 extends ProductReader[BPZ2] with Serializable

    a special fixed band-pass filter UGen.

    a special fixed band-pass filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) - in(i-2))

    This filter cuts out frequencies around zero Hertz and Nyquist.

    Examples
    // engage with mouse button
    play {
      val sig = WhiteNoise.ar(0.5)
      val flt = BPZ2.ar(sig)
      LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
    }
    See also

    HPZ2

    LPZ2

    BRZ2

    BPF

  22. object BPeakEQ extends ProductReader[BPeakEQ] with Serializable

    An parametric equalizer UGen.

    An parametric equalizer UGen. The B equalization suite is based on the Second Order Section (SOS) biquad UGen.

    Note: Biquad coefficient calculations imply certain amount of CPU overhead. These plugin UGens contain optimizations such that the coefficients get updated only when there has been a change to one of the filter's parameters. This can cause spikes in CPU performance and should be considered when using several of these units.

  23. object BRF extends ProductReader[BRF] with Serializable

    A second order band reject (notch) filter UGen.

    A second order band reject (notch) filter UGen.

    Examples
    // modulated frequency
    play {
      val in   = Saw.ar(200) * 0.5
      val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(3600, 4000)
      BRF.ar(in, freq)
    }
    // mouse controlled frequency and Q
    play {
      val in   = WhiteNoise.ar(0.5)
      val freq = MouseX.kr(200, 10000, 1)
      val q    = MouseY.kr(0.5, 10, 1) // bottom to top
      BRF.ar(in, freq, q.reciprocal)
    }
    See also

    HPF

    LPF

    BPF

    MidEQ

  24. object BRZ2 extends ProductReader[BRZ2] with Serializable

    a special fixed band-reject filter UGen.

    a special fixed band-reject filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) + in(i-2))

    This filter cuts out frequencies around half of the Nyquist frequency.

    Examples
    // engage with mouse button
    play {
      val sig = WhiteNoise.ar(0.5)
      val flt = BRZ2.ar(sig)
      LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
    }
    See also

    HPZ1

    HPZ2

    BRF

  25. object Balance2 extends ProductReader[Balance2] with Serializable

    An equal power two channel balancing UGen.

    An equal power two channel balancing UGen. It takes a left and right input signal and attenuates them according to the pos value, producing again a stereophonic output.

    See also

    XFade2

    Pan2

  26. object Ball extends ProductReader[Ball] with Serializable
  27. object BeatTrack extends ProductReader[BeatTrack] with Serializable

    An autocorrelation based beat tracker UGen.

    An autocorrelation based beat tracker UGen.

    The underlying model assumes 4/4, but it should work on any isochronous beat structure, though there are biases to 100-120 bpm; a fast 7/8 may not be tracked in that sense. There are four control-rate outputs, being ticks at quarter, eighth and sixteenth level from the determined beat, and the current detected tempo. Note that the sixteenth note output won't necessarily make much sense if the music being tracked has swing; it is provided just as a convenience.

    This beat tracker determines the beat, biased to the mid-tempo range by weighting functions. It does not determine the measure level, only a tactus. It is also slow reacting, using a 6 second temporal window for its autocorrelation maneuvres. Don't expect human musician level predictive tracking.

    On the other hand, it is tireless, relatively general (though obviously best at transient 4/4 heavy material without much expressive tempo variation), and can form the basis of computer processing that is decidedly faster than human.

    Warning: This UGen only works properly at 44.1 or 48.0 kHz.

  28. object BeatTrack2 extends ProductReader[BeatTrack2] with Serializable

    A template matching beat tracker UGen.

    A template matching beat tracker UGen. This beat tracker is based on exhaustively testing particular template patterns against feature streams; the testing takes place every 0.5 seconds. The two basic templates are a straight (groove=0) and a swung triplet (groove=1) pattern of 16th notes; this pattern is tried out at scaling factors corresponding to the tempi from 60 to 180 bpm. This is the cross-correlation method of beat tracking. A majority vote is taken on the best tempo detected, but this must be confirmed by a consistency check after a phase estimate. Such a consistency check helps to avoid wild fluctuating estimates, but is at the expense of an additional half second delay. The latency of the beat tracker with default settings is thus at least 2.5 seconds; because of block-based amortisation of calculation, it is actually around 2.8 seconds latency for a 2.0 second temporal window.

    This beat tracker is designed to be flexible for user needs; you can try out different window sizes, tempo weights and combinations of features. However, there are no guarantees on stability and effectiveness, and you will need to explore such parameters for a particular situation.

    The UGen has six outputs corresponding to beat-tick, eighth-tick, groove-tick, tempo, phase, and groove. Warning: it reads from input control bus instead of taking a regular control input signal as its first argument!

  29. object BiPanB2 extends ProductReader[BiPanB2] with Serializable

    A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal.

    A two dimensional Ambisonics B-format encoder UGen for a two-channel input signal. ambisonic B-format. It places the two input channels at opposite poles of the 2D (W, X, Y) Ambisonics field. It is equivalent to:

    PanB2(_, inA, azimuth, level) + PanB2(_, inB, azimuth + 1, level)
    Examples
    // 4-channel rotation of opposite sounds
    play {
      val p = WhiteNoise.ar(0.05)                     // first source
      val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03  // second source
      // B-format encode 2 signals at opposite sides of the circle
      val enc = BiPanB2.ar(p, q, MouseX.kr(-1, +1))
      // B-format decode to quad (front-left, front-right, rear-left, rear-right)
      DecodeB2.ar(4, enc.w, enc.x, enc.y)
    }
    See also

    PanB2

    DecodeB2

  30. object BinaryOpUGen extends ProductReader[BinaryOpUGen]

    Binary operations are generally constructed by calling one of the methods of GEOps.

    Binary operations are generally constructed by calling one of the methods of GEOps.

    See also

    GEOps

    UnaryOpUGen

  31. object Blip extends ProductReader[Blip] with Serializable

    Band Limited ImPulse generator UGen.

    Band Limited ImPulse generator UGen. All harmonics have equal amplitude. This is the equivalent of 'buzz' in Music-N languages. It is capable of cross-fading during a control period block if the number of harmonics changes, avoiding audible pops.

    Examples
    // modulate fundamental frequency
    play { Blip.ar(XLine.kr(20000, 200, 6), 100) * 0.2 }
    // modulate number of harmonics
    play { Blip.ar(200, Line.kr(1, 100, 20)) * 0.2 }
    See also

    Impulse

  32. object BrownNoise extends ProductReader[BrownNoise] with Serializable

    A noise generator UGen whose spectrum falls off in power by 6 dB per octave.

    A noise generator UGen whose spectrum falls off in power by 6 dB per octave. The values produced by this UGen lie between -1 and +1 , the RMS is approx. -4.8 dB (the same as white noise).

    Examples
    // plain noise
    play { BrownNoise.ar(Seq(0.2, 0.2)) }
    See also

    WhiteNoise

    PinkNoise

    GrayNoise

    ClipNoise

    RandSeed

  33. object BufAllpassC extends ProductReader[BufAllpassC] with Serializable

    All pass delay line with cubic interpolation which uses a buffer for its internal memory.

    All pass delay line with cubic interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    Examples
    // Compare interpolation types
    // allocate buffer
    val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo)
    
    // Since the allpass delay has no audible effect as a resonator on
    // steady state sound ...
    play { BufAllpassC.ar(b.id, WhiteNoise.ar(0.1), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    // ...these examples add the input to the effected sound and compare variants so that you can hear
    // the effect of the phase comb:
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassN.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassL.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassC.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    b.free()  // after synths have been stopped
    See also

    BufAllpassN

    BufAllpassL

  34. object BufAllpassL extends ProductReader[BufAllpassL] with Serializable

    All pass delay line with linear interpolation which uses a buffer for its internal memory.

    All pass delay line with linear interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    Examples
    // Compare interpolation types
    // allocate buffer
    val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo)
    
    // Since the allpass delay has no audible effect as a resonator on
    // steady state sound ...
    play { BufAllpassC.ar(b.id, WhiteNoise.ar(0.1), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    // ...these examples add the input to the effected sound and compare variants so that you can hear
    // the effect of the phase comb:
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassN.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassL.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassC.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    b.free()  // after synths have been stopped
    See also

    BufAllpassN

    BufAllpassC

  35. object BufAllpassN extends ProductReader[BufAllpassN] with Serializable

    All pass delay line with no interpolation which uses a buffer for its internal memory.

    All pass delay line with no interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    Examples
    // Compare interpolation types
    // allocate buffer
    val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo)
    
    // Since the allpass delay has no audible effect as a resonator on
    // steady state sound ...
    play { BufAllpassC.ar(b.id, WhiteNoise.ar(0.1), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    // ...these examples add the input to the effected sound and compare variants so that you can hear
    // the effect of the phase comb:
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassN.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassL.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    play {
      val z = WhiteNoise.ar(0.2)
      z + BufAllpassC.ar(b.id, z, XLine.kr(0.0001, 0.01, 20), 0.2)
    }
    
    b.free()  // after synths have been stopped
    // Used as echo
    val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo)
    
    // doesn't really sound different than Comb,
    // but it outputs the input signal immediately (inverted) and the echoes
    // are lower in amplitude.
    play { BufAllpassN.ar(b.id, Decay.ar(Dust.ar(1) * 0.5, 0.2) * WhiteNoise.ar, 0.2, 3) }
    
    b.free()
    See also

    BufAllpassL

    BufAllpassC

  36. object BufChannels extends ProductReader[BufChannels] with Serializable

    Returns the current number of channels of the buffer at the provided index.

    Returns the current number of channels of the buffer at the provided index.

    Examples
    // channels of local buffer
    play {
      val buf = LocalBuf(1024, 2)
      BufChannels.ir(buf).poll(0) // reports 2
    }
    See also

    BufFrames

    BufSamples

  37. object BufCombC extends ProductReader[BufCombC] with Serializable

    Comb delay line with cubic interpolation which uses a buffer for its internal memory.

    Comb delay line with cubic interpolation which uses a buffer for its internal memory.

    Examples
    // Compare interpolation
    // These examples compare the variants, so that you can hear the difference in interpolation
    
    // allocate buffer
    val b = Buffer.alloc(s, (0.01 * s.sampleRate).toInt.nextPowerOfTwo)
    
    // Comb used as a resonator. The resonant fundamental is equal to
    // reciprocal of the delay time.
    play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    // with negative feedback
    play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    b.free()   // do this after the synths have ended
    See also

    BufCombN

    BufCombL

  38. object BufCombL extends ProductReader[BufCombL] with Serializable

    Comb delay line with linear interpolation which uses a buffer for its internal memory.

    Comb delay line with linear interpolation which uses a buffer for its internal memory.

    Examples
    // Compare interpolation
    // These examples compare the variants, so that you can hear the difference in interpolation
    
    // allocate buffer
    val b = Buffer.alloc(s, (0.01 * s.sampleRate).toInt.nextPowerOfTwo)
    
    // Comb used as a resonator. The resonant fundamental is equal to
    // reciprocal of the delay time.
    play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    // with negative feedback
    play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    b.free()   // do this after the synths have ended
    See also

    BufCombN

    BufCombC

  39. object BufCombN extends ProductReader[BufCombN] with Serializable

    Comb delay line with no interpolation which uses a buffer for its internal memory.

    Comb delay line with no interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    Examples
    // Compare interpolation
    // These examples compare the variants, so that you can hear the difference in interpolation
    
    // allocate buffer
    val b = Buffer.alloc(s, (0.01 * s.sampleRate).toInt.nextPowerOfTwo)
    
    // Comb used as a resonator. The resonant fundamental is equal to
    // reciprocal of the delay time.
    play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), 0.2) }
    
    // with negative feedback
    play { BufCombN.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    play { BufCombL.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    play { BufCombC.ar(b.id, WhiteNoise.ar(0.01), XLine.kr(0.0001, 0.01, 20), -0.2) }
    
    b.free()   // do this after the synths have ended
    // Used as an echo
    val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo)
    
    play { BufCombN.ar(b.id, Decay.ar(Dust.ar(1) * 0.5, 0.2) * WhiteNoise.ar, 0.2, 3) }
    
    b.free()   // do this after the synth has ended
    See also

    BufCombL

    BufCombC

  40. object BufDelayC extends ProductReader[BufDelayC] with Serializable

    Simple delay line with cubic interpolation which uses a buffer for its internal memory.

    Simple delay line with cubic interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    See also

    BufDelayN

    BufDelayL

  41. object BufDelayL extends ProductReader[BufDelayL] with Serializable

    Simple delay line with linear interpolation which uses a buffer for its internal memory.

    Simple delay line with linear interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    See also

    BufDelayN

    BufDelayC

  42. object BufDelayN extends ProductReader[BufDelayN] with Serializable

    Simple delay line with no interpolation which uses a buffer for its internal memory.

    Simple delay line with no interpolation which uses a buffer for its internal memory.

    Warning: For reasons of efficiency, the effective buffer size is the allocated size rounded down to the next power of two. For example, if 44100 samples are allocated, the maximum delay would be 32768 samples. Also note that the buffer must be monophonic.

    Examples
    // Random white-noise decay
    // allocate buffer
    val b = Buffer.alloc(s, (0.2 * s.sampleRate).toInt.nextPowerOfTwo, 1)
    
    // Dust randomly triggers Decay to create an exponential
    // decay envelope for the WhiteNoise input source.
    // We apply a slight filter to the delayed signal
    // so it is easier to distinguish
    play {
      val z = Decay.ar(Dust.ar(1) * 0.5, 0.3) * WhiteNoise.ar
      LPF.ar(BufDelayN.ar(b.id, z, 0.2), 8000) + z  // input is mixed with delay
    }
    
    b.free()  // do this after the synth has ended
    See also

    BufDelayL

    BufDelayC

  43. object BufDur extends ProductReader[BufDur] with Serializable

    Returns the current duration of the buffer at the provided index.

    Returns the current duration of the buffer at the provided index.

    Examples
    // duration of local buffer
    play {
      val buf = LocalBuf(SampleRate.ir * 1.5, 2)
      BufDur.ir(buf).poll(0) // reports 1.5
    }
    See also

    BufFrames

    BufRateScale

    SampleDur

  44. object BufFrames extends ProductReader[BufFrames] with Serializable

    Returns the number of allocated frames of the buffer at the provided index.

    Returns the number of allocated frames of the buffer at the provided index.

    Examples
    // frames of local buffer
    play {
      val buf = LocalBuf(1024, 2)
      BufFrames.ir(buf).poll(0) // reports 1024
    }
    See also

    BufSamples

    BufChannels

    BufDur

  45. object BufMax extends ProductReader[BufMax] with Serializable

    A UGen that finds the largest value in a buffer, providing both the value and the index.

    A UGen that finds the largest value in a buffer, providing both the value and the index.

    Examples
    // simple test
    val b = Buffer(s)
    b.alloc(100)
    b.zero()
    b.set(33 -> 1.034)
    
    // verify that the 33rd value is detected...
    val x = play {
      val m  = BufMax.kr(b.id)
      val tr = "poll".tr(1)
      m.value.poll(tr, "max-value")
      m.index.poll(tr, "max-index")
      ()
    }
    
    // ...until we set a new maximum...
    b.set(74 -> 1.038); x.set("poll" -> 1)
    
    x.free(); b.free()

    This is a third-party UGen (MCLDUGens).

    See also

    BufMin

    ArrayMax

  46. object BufMin extends ProductReader[BufMin] with Serializable

    A UGen that finds the smallest value in a buffer, providing both the value and the index.

    A UGen that finds the smallest value in a buffer, providing both the value and the index.

    Examples
    // simple test
    val b = Buffer(s)
    b.alloc(100)
    b.zero()
    b.set(33 -> -1.034)
    
    // verify that the 33rd value is detected...
    val x = play {
      val m  = BufMin.kr(b.id)
      val tr = "poll".tr(1)
      m.value.poll(tr, "min-value")
      m.index.poll(tr, "min-index")
      ()
    }
    
    // ...until we set a new minimum...
    b.set(74 -> -1.038); x.set("poll" -> 1)
    
    x.free(); b.free()

    This is a third-party UGen (MCLDUGens).

    See also

    BufMax

    ArrayMin

  47. object BufRateScale extends ProductReader[BufRateScale] with Serializable

    Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.

    Returns a ratio by which the playback of the buffer at the provided index is to be scaled relative to the current sample rate of the server.

    buffer sample rate / server sample rate
    Examples
    // rate scale of local buffer
    play {
      val buf = LocalBuf(1024)
      BufRateScale.ir(buf).poll(0) // reports 1.0 because buffer rate matches server rate
    }
    See also

    BufSampleRate

    SampleRate

    PlayBuf

  48. object BufRd extends ProductReader[BufRd] with Serializable

    A UGen which reads the content of a buffer, using an index pointer.

    A UGen which reads the content of a buffer, using an index pointer.

    Warning: if the supplied buf refers to a buffer whose number of channels differs from numChannels , the UGen will fail silently.

    An alternative to BufRd is PlayBuf . While PlayBuf plays through the buffer by itself, BufRd only moves its read point by the index input and therefore has no pitch input. PlayBuf uses cubic interpolation, while BufRd has variable interpolation. PlayBuf can determine the end of the buffer and issue a done-action.

    Examples
    // Write and read
    val b = Buffer.alloc(s, numFrames = 32768, numChannels = 1)
    
    // write into the buffer with a BufWr
    val y = play {
      val in = SinOsc.ar(LFNoise1.kr(2).mulAdd(300, 400)) * 0.1
      val rate = "rate" kr 1
      BufWr.ar(in, b.id, Phasor.ar(0, BufRateScale.kr(b.id) * rate, 0, BufFrames.kr(b.id)))
      0.0 // quiet
    }
    
    // read it with a BufRd
    val x = play {
      val rate = "rate" kr 1
      BufRd.ar(1, b.id, Phasor.ar(0, BufRateScale.kr(b.id) * rate, 0, BufFrames.kr(b.id)))
    }
    
    y.set("rate" -> 0.5) // notice the clicks when the play head overtakes the write head!
    x.set("rate" -> 0.5)
    y.set("rate" -> 1.0)
    See also

    PlayBuf

    BufWr

    Phasor

    BufFrames

    BufRateScale

  49. object BufSampleRate extends ProductReader[BufSampleRate] with Serializable

    Returns the buffer's current sample rate.

    Returns the buffer's current sample rate.

    Examples
    // rate of local buffer
    play {
      val buf = LocalBuf(1024)
      BufSampleRate.ir(buf).poll(0) // matches server sample rate
    }
    See also

    SampleRate

    BufRateScale

  50. object BufSamples extends ProductReader[BufSamples] with Serializable

    Returns the current number of allocated samples in the Buffer at the provided index.

    Returns the current number of allocated samples in the Buffer at the provided index. A sample is not the same as a frame (compare with BufFrames ); a frame includes the samples in each channel of the buffer. Only for a mono buffer are samples the same as frames.

    samples = frames * numChannels
    Examples
    // samples of local buffer
    play {
      val buf = LocalBuf(1024, 2)
      BufSamples.ir(buf).poll(0) // 2 * 1024 = 2048
    }
    See also

    BufFrames

    BufChannels

    BufDur

  51. object BufWr extends ProductReader[BufWr] with Serializable

    A UGen that writes a signal to a buffer, using an index pointer.

    A UGen that writes a signal to a buffer, using an index pointer.

    Warning: if the supplied buf refers to a buffer whose number of channels differs from those of the input signal, the UGen will fail silently.

    An alternative to BufWr is RecordBuf . While RecordBuf advances the index into the buffer by itself, BufWr only moves its write point by the index input, making it possible to adjust the writing speed or to access the buffer in a non-linear way. RecordBuf can determine the end of the buffer and issue a done-action.

    Examples
    // record and playback
    // a two second mono buffer
    val b = Buffer.alloc(s, numFrames = s.sampleRate.toInt * 2)
    
    val y = play {
      val sig  = SinOsc.ar(LFNoise1.kr(2).mulAdd(300, 400)) * 0.1
      val rate = "rate" kr 1
      BufWr.ar(in = sig, buf = b.id, index =
        Phasor.ar(speed = BufRateScale.kr(b.id) * rate, lo = 0, hi = BufFrames.kr(b.id)))
      0.0 // quiet
    }
    
    // read it with a BufRd
    val x = play {
      val rate = "rate" kr 1
      BufRd.ar(1, buf = b.id, index =
        Phasor.ar(speed = BufRateScale.kr(b.id) * rate, lo = 0, hi = BufFrames.kr(b.id)))
    }
    
    x.set("rate" -> 5)
    y.set("rate" -> 3)
    x.set("rate" -> 2)
    See also

    RecordBuf

    BufRd

    Phasor

    BufFrames

    BufRateScale

  52. case object BuildInfo extends Product with Serializable

    This object was generated by sbt-buildinfo.

  53. object COsc extends ProductReader[COsc] with Serializable
  54. object ChannelIndices extends ProductReader[ChannelIndices] with Serializable
  55. object ChannelProxy extends ProductReader[ChannelProxy] with Serializable
  56. object ChannelRangeProxy extends ProductReader[ChannelRangeProxy] with Serializable
  57. object CheckBadValues extends ProductReader[CheckBadValues] with Serializable

    A UGen to test for infinity, not-a-number (NaN), and denormal numbers.

    A UGen to test for infinity, not-a-number (NaN), and denormal numbers. Its output is as follows: 0 = a normal float, 1 = NaN, 2 = infinity, and 3 = a denormal. According to the post settings it will print the information to the console along with a given identifier.

  58. object CircleRamp extends ProductReader[CircleRamp] with Serializable

    This is a UGen like Ramp , but it always takes the shortest way around a defined circle, wrapping values where appropriate.

    This is a UGen like Ramp , but it always takes the shortest way around a defined circle, wrapping values where appropriate. This can be useful when smoothing panning signals for speaker rings, for instance in Vector Base Amplitude Panning.

    This is a third-party UGen (VBAPUGens).

    See also

    VBAP

    Ramp

    Lag

  59. object ClearBuf extends ProductReader[ClearBuf] with Serializable

    A scalar (init-time) UGen that fills the contents of a buffer with zeroes.

    A scalar (init-time) UGen that fills the contents of a buffer with zeroes.

    See also

    LocalBuf

    SetBuf

  60. object Clip extends ProductReader[Clip] with Serializable

    A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins.

    A UGen that constrains a signal to a given range, by limiting values outside the range to the range margins. This is similar to the clip2 binary operator but permits both a lower range value lo and an upper range value hi .

    Mathematically, this is equivalent to in.max(lo).min(hi).

    Be aware that there seems to be an initialization bug. The following crashes, indicating that Clip.ar outputs a zero initially:

    {{ play { val bar = Integrator.ar(DC.ar(0), coeff = 0.999) val foo = Clip.ar(bar, lo = 1.0, hi = 44100.0) // .max(1.0) val sum = RunningSum.ar(DC.ar(0), length = foo) sum.poll(1, "sum") () } }}

    Examples
    // clip sine wave to modulate timbre
    play {
      val hi = SinOsc.ar(0.1).linExp(-1, 1, 0.01, 1.0)
      Clip.ar(SinOsc.ar(300), 0, hi) * 0.2 / hi
    }
    See also

    Wrap

    Fold

  61. object ClipNoise extends ProductReader[ClipNoise] with Serializable

    A noise generator UGen whose values are either -1 or +1 (before being multiplied by mul ).

    A noise generator UGen whose values are either -1 or +1 (before being multiplied by mul ). This produces the maximum energy (an RMS of 0 dB) for the least peak to peak amplitude.

    Examples
    // plain noise
    play { ClipNoise.ar(Seq(0.2, 0.2)) }
    See also

    LFClipNoise

    WhiteNoise

    PinkNoise

    BrownNoise

    GrayNoise

    RandSeed

    LFNoise0

    Dust

  62. object CoinGate extends ProductReader[CoinGate] with Serializable

    A UGen that randomly filters an input trigger signal.

    A UGen that randomly filters an input trigger signal. When a trigger arrives, it may pass with a probability given by the prob argument.

    Examples
    // filter dust, probability controlled by mouse
    play {
      val p = MouseX.kr
      CoinGate.ar(Dust.ar(400), p)
    }
    Note

    The argument order is different from its sclang counterpart.

    See also

    Gate

    PulseDivider

    TRand

  63. object CombC extends ProductReader[CombC] with Serializable

    Comb delay line with cubic interpolation.

    Comb delay line with cubic interpolation.

    See also

    CombN

    CombL

  64. object CombL extends ProductReader[CombL] with Serializable

    Comb delay line with linear interpolation.

    Comb delay line with linear interpolation.

    See also

    CombN

    CombC

  65. object CombN extends ProductReader[CombN] with Serializable

    Comb delay line with no interpolation.

    Comb delay line with no interpolation.

    See also

    CombL

    CombC

  66. object Compander extends ProductReader[Compander] with Serializable

    A compressor, expander, limiter, gate and ducking UGen.

    A compressor, expander, limiter, gate and ducking UGen. This dynamic processor uses a hard-knee characteristic. All of the thresholds and ratios are given as direct values, not in decibels!

    See also

    Limiter

    Normalizer

  67. object ComplexRes extends ProductReader[ComplexRes] with Serializable

    A resonating filter UGen which can be modulated in its resonating frequency at audio rate.

    A resonating filter UGen which can be modulated in its resonating frequency at audio rate.

    Implements the filter structure found in Julian Parker and Till Bovermann (2013): Dynamic FM synthesis using a network of complex resonator filters

    Examples
    // pulse excitation
    play { ComplexRes.ar(Pulse.ar(1, 0.01), 5000 * SinOsc.ar(Seq(50, 51)), 0.5) }

    This is a third-party UGen (DEINDUGens).

    See also

    Resonz

    Formlet

    RHPF

    RLPF

    Ringz

  68. object Constant extends Serializable
  69. object Control extends ProductReader[Control] with Serializable
  70. object ControlDur extends ProductReader[ControlDur] with Serializable

    A UGen that reports the server's current control period in seconds.

    A UGen that reports the server's current control period in seconds. This is equivalent to the reciprocal of ControlRate

    Examples
    // print the control period
    play { ControlDur.ir.poll(0) }
    See also

    ControlRate

    SampleDur

  71. object ControlProxy extends ProductReader[ControlProxy] with Serializable
  72. object ControlProxyFactory
  73. object ControlRate extends ProductReader[ControlRate] with Serializable

    A UGen that reports the server's current control rate.

    A UGen that reports the server's current control rate. This is equivalent to the reciprocal of ControlDur

    Examples
    // print the control rate
    play { ControlRate.ir.poll(0) }
    // play a sine tone at control rate
    play { SinOsc.ar(ControlRate.ir) * 0.1 }
    See also

    ControlDur

    SampleRate

  74. object ControlValues extends Serializable
  75. object Convolution extends ProductReader[Convolution] with Serializable

    A UGen that performs a convolution with an continuously changing kernel.

    A UGen that performs a convolution with an continuously changing kernel. If the kernel is static or must only change occasionally, Convolution2 will be a more CPU friendly alternative. The process introduces a delay of frameSize - blockSize .

    Examples
    // sine filter
    play {
      val a = WhiteNoise.ar
      val b = SinOsc.ar(MouseY.kr(20, 2000, 1))
      Convolution.ar(a, b, 512) * 0.01
    }
    See also

    PartConv

    Convolution2L

    Convolution2

  76. object Convolution2 extends ProductReader[Convolution2] with Serializable

    A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal.

    A frequency-domain convolution UGen using a fixed kernel which can be updated by a trigger signal. The delay caused by the convolution when the kernel is a dirac impulse is equal to frameSize - controlBlockSize , so for a frameSize of 2048 and a control-block size of 64, this is 1984 sample frames.

    Examples
    // three example kernels
    // creates a buffer with `n` set values
    def mkBuf(n: Int, amp: => Double): Buffer = {
      val v = Vector.tabulate[FillValue](n) { i =>
        (i.linLin(0, n, 0, 2048).toInt, amp)
      }
      val b = Buffer(s)
      b.alloc(2048, completion = b.zeroMsg(b.setMsg(v: _*)))
      b
    }
    
    val b = mkBuf(3, 1)
    val c = mkBuf(50, math.random)
    val d = mkBuf(20, 1)
    
    val x = play {
      val z   = Impulse.ar(1)
      val buf = "kernel".kr(b.id)
      val tr  = "trig"  .tr
      Convolution2.ar(z, buf, tr, 2048) * 0.5
    }
    
    // set buffer and trigger kernel actualization
    x.set("kernel" -> b.id, "trig" -> 1)
    x.set("kernel" -> c.id, "trig" -> 1)
    x.set("kernel" -> d.id, "trig" -> 1)
    
    x.free(); b.free(); c.free(); d.free()
    See also

    PartConv

    Convolution2L

    Convolution

  77. object Convolution2L extends ProductReader[Convolution2L] with Serializable

    A frequency-domain convolution UGen using two linearly interpolated fixed kernels.

    A frequency-domain convolution UGen using two linearly interpolated fixed kernels. When a trigger is received, a linear fade will be performed from the previously used kernel (internally stored by the UGen) towards the snapshot of the current kernel content upon receiving the trigger.

    The delay caused by the convolution when the kernel is a dirac impulse is equal to frameSize - controlBlockSize , so for a frameSize of 2048 and a control-block size of 64, this is 1984 sample frames.

    Note: If a trigger is received before the previous fade is complete, the interpolation is broken and the kernel instead jumps straight to one of the two buffers.

    Examples
    // three example kernels
    def mkBuf(n: Int, amp: => Double): Buffer = {
      val v = Vector.tabulate[FillValue](n) { i =>
        (i.linLin(0, n, 0, 2048).toInt, amp)
      }
      val b = Buffer(s)
      b.alloc(2048, completion = b.zeroMsg(b.setMsg(v: _*)))
      b
    }
    
    val b = mkBuf(3, 1)
    val c = mkBuf(50, math.random)
    val d = mkBuf(20, 1)
    
    val x = play {
      val z     = Impulse.ar(16)
      val buf   = "kernel".kr(b.id)
      val tr    = "trig"  .tr
      val dur   = 4.0          // fade-time in seconds
      val n     = 2048
      val block = SampleRate.ir / n
      val p     = dur * block  // ... in periods
      Convolution2L.ar(z, buf, tr, 2048, p) * 0.5
    }
    
    x.set("kernel" -> b.id, "trig" -> 1)
    x.set("kernel" -> c.id, "trig" -> 1)
    x.set("kernel" -> d.id, "trig" -> 1)
    
    x.free(); b.free(); c.free(); d.free()
    See also

    PartConv

    Convolution2

    Convolution

  78. object Convolution3 extends ProductReader[Convolution3] with Serializable

    A UGen for triggered convolution in the time domain.

    A UGen for triggered convolution in the time domain.

    Warning: This UGen seems currently broken (SC 3.6.3)

    See also

    PartConv

    Convolution2

    Convolution

    Convolution2L

  79. object Crackle extends ProductReader[Crackle] with Serializable

    A noise generator UGen based on a chaotic function.

    A noise generator UGen based on a chaotic function. Output values lie between zero and one. Although this is a deterministic process, it is randomly seeded.

    Examples
    // increasing parameter
    play {
      val chaos = Line.kr(1.0, 2.01, 15)
      chaos.poll(2, "chaos")
      Crackle.ar(Seq(chaos, chaos)) * 0.5
    }
    See also

    Dust

    LatoocarfianN

    Logistic

  80. object Crest extends ProductReader[Crest] with Serializable

    A UGen that measures the "crest factor" of a time-domain signal.

    A UGen that measures the "crest factor" of a time-domain signal. The "crest factor" is the ratio of the absolute peak to the absolute mean over a certain time period. In pseudocode:

    crest = (samples.abs.max) / (samples.abs.mean)

    For Pulse waves the value will be 1, because the mean and the maximum are the same. For SinOsc , the theoretical value is 2.sqrt . For Saw it is 3.sqrt . These exact values might not occur in practice, because of anti-aliasing and other sampling factors.

    This is not to be confused with FFTCrest which does the same thing for spectral data.

    Examples
    // mouse movement varies from sine wave (left) to almost-square (right)
    play {
      val sig = (SinOsc.ar(MouseY.kr(100, 1000, 1)) * MouseX.kr(1,10)).clip2(1)
      Crest.kr(sig, 440).poll
      Pan2.ar(sig * 0.1)
    }

    This is a third-party UGen (MCLDUGens).

  81. object CuspL extends ProductReader[CuspL] with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+1] = a - b * sqrt(abs(x[n]))
    Examples
    // vary frequency
    play { CuspL.ar(MouseX.kr(20, SampleRate.ir), 1.0, 1.99) * 0.3 }
    // mouse-controlled parameters
    play { CuspL.ar(SampleRate.ir/4, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2,1)) * 0.3 }
    // as a frequency control
    play { SinOsc.ar(CuspL.ar(40, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2, 1)) * 800 + 900) * 0.4 }
    See also

    CuspN

  82. object CuspN extends ProductReader[CuspN] with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+1] = a - b * sqrt(abs(x[n]))
    Examples
    // vary frequency
    play { CuspN.ar(MouseX.kr(20, SampleRate.ir), 1.0, 1.99) * 0.3 }
    // mouse-controlled parameters
    play { CuspN.ar(SampleRate.ir/4, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2, 1)) * 0.3 }
    // as a frequency control
    play { SinOsc.ar(CuspN.ar(40, MouseX.kr(0.9, 1.1, 1), MouseY.kr(1.8, 2,1)) * 800 + 900) * 0.4 }
    See also

    CuspL

  83. object DC extends ProductReader[DC] with Serializable

    A UGen that creates a constant signal at a given calculation rate.

    A UGen that creates a constant signal at a given calculation rate.

    Examples
    // create a silent audio signal
    play {
      // Note: Select.ar requires audio-rate input.
      // Therefore, DC can be used to wrap the otherwise
      // incompatible constant zero. In future versions of
      // ScalaCollider, this wrapping will be done
      // automatically, however.
      Select.ar(MouseButton.kr(lag = 0), Seq(DC.ar(0), SinOsc.ar * 0.2))
    }
    See also

    LeakDC

  84. object DFM1 extends ProductReader[DFM1] with Serializable

    A digital filter UGen which aims at accurately modeling an analog filter.

    A digital filter UGen which aims at accurately modeling an analog filter. It provides low-pass and high-pass modes, and the filter can be overdriven and will self-oscillate at high resonances.

    This is a third-party UGen (TJUGens).

  85. object DNoiseRing extends ProductReader[DNoiseRing] with Serializable

    Demand rate UGen implementing a Wiard noise ring.

    Demand rate UGen implementing a Wiard noise ring.

    "In latter model synthesizers, digital noise sources began to appear in place of analog ones. Traditionally, a pseudo-random shift register set up for optimal length. By optimal length, it is meant that every state of all available bits will appear at some time, but the order is unknown. Essentially a counter that counts in an unknown order. This represents the maximum state of information "entropy" available for that number of bits. But music has close self-similarity over short periods of time. That is, it repeats itself with changes appearing slowly. This shift register generator is designed to give control of the rate of appearance of new information. It has a tight set of controls over how random it actually is and how fast change occurs." (source: http://mamonu.weebly.com/wiard-noisering.html)

    Examples
    // plain 32bit value scaled to 0..1
    play {
      val noise = DNoiseRing(change = MouseX.kr(0, 1), chance = 0.51, numBits = 32)
      Demand.ar(Impulse.ar(10000), noise) / 2.0.pow(33)
    }
    // sequencer
    play {
      val noise = DNoiseRing(change = MouseX.kr(0, 1), chance = MouseY.kr(0, 1), numBits = 32)
      val tr    = Impulse.ar(10)
      val freq  = (Demand.ar(tr, noise)).linLin(0, 2.0.pow(32), 40, 40+48).midiCps
      freq.poll(tr, "freq")
      Pan2.ar(SinOsc.ar(freq) * 0.25)
    }

    This is a third-party UGen (DEINDUGens).

    See also

    Duty

    Demand

  86. object Dbrown extends ProductReader[Dbrown] with Serializable

    A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.

    A demand-rate UGen that produces random decimal numbers, analogous to a Brownian motion.

    Examples
    // random frequency
    play {
      val in = Dbrown(lo = 0, hi = 15, step = 1)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = v * 30 + 300
      SinOsc.ar(f) * 0.1
    }
    See also

    Dwhite

    Dibrown

    BrownNoise

    Demand

  87. object Dbufrd extends ProductReader[Dbufrd] with Serializable

    A demand-rate UGen that reads out a buffer.

    A demand-rate UGen that reads out a buffer. All inputs can be either demand UGens or any other UGens.

    See also

    BufRd

    Dbufwr

  88. object Dbufwr extends ProductReader[Dbufwr] with Serializable
  89. object Dconst extends ProductReader[Dconst] with Serializable

    A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total.

    A demand-rate UGen that outputs values from the child demand stream until the sum of those values reaches or exceeds a given total. The last value will be truncated so that the sum of Dconst 's output values will match the total exactly.

  90. object Decay extends ProductReader[Decay] with Serializable

    An integrator UGen with exponential decay of past values.

    An integrator UGen with exponential decay of past values. This is essentially the same as Integrator except that instead of supplying the coefficient directly, it is calculated from a 60 dB decay time. This is the time required for the integrator to lose 99.9 % of its value or -60dB.

    Note: This should not be confused with Lag which does not overshoot due to integration, but asymptotically follows the input signal.

    See also

    Integrator

    Decay2

    Lag

  91. object Decay2 extends ProductReader[Decay2] with Serializable

    A integrator UGen with controllable attack and release times.

    A integrator UGen with controllable attack and release times. While Decay has a very sharp attack and can produce clicks, Decay2 rounds off the attack by subtracting one Decay from another. It can be seen as equivalent to

    Decay.ar(in, release) - Decay.ar(in, attack)

    Note: This should not be confused with LagUD which does not overshoot due to integration, but asymptotically follows the input signal.

    See also

    Decay

    Integrator

    LagUD

  92. object DecodeB2 extends ProductReader[DecodeB2] with Serializable

    A two dimensional Ambisonics B-format decoding UGen.

    A two dimensional Ambisonics B-format decoding UGen. It assumes a set of speakers in a regular polygon. The output channels are in clockwise order. The position of the first speaker is specified by the orient argument.

    Examples
    // 4-channel rotation of opposite sounds
    play {
      val p = WhiteNoise.ar(0.05)                     // first source
      val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03  // second source
      // B-format encode 2 signals at opposite sides of the circle
      val enc = PanB2.ar(p, -0.5) + PanB2.ar(q, +0.5)
      val Seq(w, x, y) = (0 to 2).map(enc out _)
      val rot = Rotate2.ar(x, y, MouseX.kr(-1, +1))
      // B-format decode to quad (front-left, front-right, rear-left, rear-right)
      DecodeB2.ar(4, w, rot.xr, rot.yr)
    }
    See also

    PanB

    PanB2

  93. object DegreeToKey extends ProductReader[DegreeToKey] with Serializable

    A UGen that uses an input signal as an index into an octave repeating table of pitch classes.

    A UGen that uses an input signal as an index into an octave repeating table of pitch classes. The input is truncated to an integer, and indices wrap around the table and shift octaves as they do.

    Examples
    // modal space where mouse x controls pitch step
    play {
      // initialize the scale buffer (Dorian)
      val scale = Vector(0, 2, 3.2, 5, 7, 9, 10)
      val buf   = LocalBuf(scale.size)
      SetBuf(buf, scale)
    
      // base MIDI pitch
      val base  = DegreeToKey.kr(buf, in = MouseX.kr(0, 15), octave = 12) + 72
      val noise = LFNoise1.kr(Seq(3, 3)) * 0.04  // low freq stereo detuning
      // lead tone
      val lead  = SinOsc.ar((base + noise).midiCps)
      // drone 5ths
      val drone = RLPF.ar(LFPulse.ar(Seq(48.midiCps, 55.midiCps), 0.15),
                          SinOsc.kr(0.1).mulAdd(10, 72).midiCps, 0.1)
      val mix = (lead + drone) * 0.1
      // add some 70's euro-space-rock echo
      CombN.ar(mix, 0.31, 0.31, 2) + mix
    }
    See also

    WrapIndex

  94. object DelTapRd extends ProductReader[DelTapRd] with Serializable

    Tap a delay line from a DelTapWr UGen.

    Tap a delay line from a DelTapWr UGen.

    See also

    DelTapWr

  95. object DelTapWr extends ProductReader[DelTapWr] with Serializable

    Write to a buffer for a DelTapRd UGen

    Write to a buffer for a DelTapRd UGen

    See also

    DelTapRd

  96. object Delay1 extends ProductReader[Delay1] with Serializable

    A UGen that delays the input by 1 audio frame or control period.

    A UGen that delays the input by 1 audio frame or control period.

    For audio-rate signals the delay is 1 audio frame, and for control-rate signals the delay is 1 control period.

    Note: The first value output is not zero but the same as the first input value! In this respect the UGen behaves different than DelayN .

    Examples
    // analog to HPZ1
    play {
      val z = PinkNoise.ar
      val x = z - Delay1.ar(z)
      // mouse button to compare dry/wet
      LinXFade2.ar(z, x, MouseButton.kr(-1, 1))
    }
    See also

    Delay2

    DelayN

  97. object Delay2 extends ProductReader[Delay2] with Serializable

    A UGen that delays the input by 2 audio frames or control periods.

    A UGen that delays the input by 2 audio frames or control periods.

    For audio-rate signals the delay is 2 audio frames, and for control-rate signals the delay is 2 control periods.

    Warning: the The first value output is zero, while both the second and the third value output equal the first input value! In this respect the UGen behaves different than DelayN .

    Examples
    // high-frequency comb filter
    play {
      val z = PinkNoise.ar
      val x = z - Delay2.ar(z)
      // mouse button to compare dry/wet
      LinXFade2.ar(z, x, MouseButton.kr(-1, 1))
    }
    See also

    Delay1

    DelayN

  98. object DelayC extends ProductReader[DelayC] with Serializable

    Simple delay line with cubic interpolation.

    Simple delay line with cubic interpolation.

    See also

    DelayN

    DelayL

  99. object DelayL extends ProductReader[DelayL] with Serializable

    Simple delay line with linear interpolation.

    Simple delay line with linear interpolation.

    See also

    DelayN

    DelayC

  100. object DelayN extends ProductReader[DelayN] with Serializable

    Simple delay line with no interpolation.

    Simple delay line with no interpolation. The initial buffer contents is zero.

    Examples
    // Delayed random pulses
    play {
      // Dust randomly triggers Decay to create an exponential
      // decay envelope for the WhiteNoise input source
      val z = Decay.ar(Dust.ar(2) * 0.5, 0.3) * WhiteNoise.ar
      DelayN.ar(z, 0.2, 0.2) + z  // input is mixed with delay via the add input
    }
    // Recursive application
    play {
      val z = Decay2.ar(Dust.ar(1) * 0.5, 0.01, 0.1) * Saw.ar(Seq(100, 101)) * 0.5
      (z /: (0 until 5)) { (zi, i) =>
        DelayN.ar(RLPF.ar(zi, Rand(100, 3000), 0.03), 1, 1.0 / (2 << i)) + zi * 0.5
      }
    }
    See also

    DelayL

    DelayC

  101. object Demand extends ProductReader[Demand] with Serializable

    A UGen which polls results from demand-rate ugens when receiving a trigger.

    A UGen which polls results from demand-rate ugens when receiving a trigger. When there is a trigger at the trig input, a value is demanded from each ugen in the in input and output. The unit generators in the list should be demand-rate. When there is a trigger at the reset input, the demand rate ugens in the list are reset.

    Note: By design, a reset trigger only resets the demand ugens; it does not reset the value at Demand's output. Demand continues to hold its value until the next value is demanded, at which point its output value will be the first expected item in the in argument.

    Note: One demand-rate ugen represents a single stream of values, so that embedding the same ugen twice calls this stream twice per demand, possibly yielding different values. To embed the same sequence twice, either make sure the ugen is demanded only once, or create two instances of the ugen.

    Warning: Demand currently seems to have problems with infinite sequences. As a workaround use a very large length instead. E.g. instead of Dbrown(0, 1, inf) use Dbrown(0, 1, 0xFFFFFFFF) !

    Warning: Demand seems to have a problem with initial triggers. For example Demand.kr(Impulse.kr(0), 1) will have a spurious zero value output first.

    Note

    The argument order is different from its sclang counterpart.

    See also

    Duty

    TDuty

  102. object DemandEnvGen extends ProductReader[DemandEnvGen] with Serializable

    An envelope generator UGen using demand-rate inputs for the envelope segments.

    An envelope generator UGen using demand-rate inputs for the envelope segments. For each parameter of the envelope (levels, durations and shapes), values are polled every time a new segment starts.

    See also

    EnvGen

    Env

    DoneAction

  103. object DetectIndex extends ProductReader[DetectIndex] with Serializable

    A UGen which determines the index in a buffer at which the value matches a given input signal.

    A UGen which determines the index in a buffer at which the value matches a given input signal. If the input value is not found, it outputs -1.

    For example, if the buffer contains values 5, 3, 2, 8, and the input signal is 3, the output will be 1. If the input is 3.001, the output will be -1. Unlike IndexInBetween , this UGen always searches through the entire buffer until the value is found or the end has been reached (returning -1).

    See also

    Index

    IndexInBetween

  104. object DetectSilence extends ProductReader[DetectSilence] with Serializable

    A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent").

    A UGen which detects whether its input signal falls below a given amplitude for a given amount of time (becoming "silent"). A silence is detected if the absolute sample values of the input remain less than or equal to the amp threshold for a consecutive amount of time given by the dur argument.

    A value of 1 is output when this condition is met, and a value of 0 is output when the condition is not met (i.e. at least one sample occurs in the input whose absolute value is greater than amp ). Besides, when the output changes from zero to one, the doneAction is executed (unless it is doNothing ).

    A special case is the initial condition of the UGen: It will begin with an output value of 0 (no silence detected), even if the input signal is below the amplitude threshold. It is only after the first input sample rising above the threshold that the actual monitoring begins and a trigger of 1 or the firing of the done-action may occur.

    See also

    Amplitude

  105. object Dgeom extends ProductReader[Dgeom] with Serializable

    A demand-rate UGen that produces a geometric series.

    A demand-rate UGen that produces a geometric series. Each value is calculated as

    x[t] = x[t-1] * grow

    With x[0] given as argument start.

    Examples
    // increasing frequency
    play {
      val in = Dgeom(1, 1.2, 15)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = v * 30 + 300
      SinOsc.ar(f) * 0.1
    }
    See also

    Dseries

    Demand

  106. object Dibrown extends ProductReader[Dibrown] with Serializable

    A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the drunk object in Max.

    A demand-rate UGen that produces random integer numbers, analogous to a Brownian motion, or the drunk object in Max.

    Note: The length parameter seems currently broken.

    Examples
    // random frequency
    play {
      val in = Dibrown(lo = 0, hi = 15, step = 2)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    See also

    Diwhite

    Dbrown

    BrownNoise

    Demand

  107. object DiodeRingMod extends ProductReader[DiodeRingMod] with Serializable

    Ring modulation UGen based on a physical model of a diode.

    Ring modulation UGen based on a physical model of a diode.

    Examples
    // sprinkle
    play {
      val ring = DiodeRingMod.ar(
        SinOsc.ar((3700: GE) * Seq(1.0, 1.1, 1.2) * (SinOsc.ar(200) + 2)),
        SinOsc.ar(( 100: GE) * Seq(0.75, 1, 0.5)))
      Splay.ar(ring) * 0.2 * LFPulse.ar(10.3 * 0.5, 0, 0.04) * 0.5
    }
    // wobble
    play {
      val ring = DiodeRingMod.ar(
        SinOsc.ar((400: GE) * Seq(1.0, 1.1, 1.2) * (SinOsc.ar(200) + 2)),
        SinOsc.ar((100: GE) * Seq(0.75, 1, 0.5)))
      Splay.ar(ring) * 0.2 * LFPulse.ar(10.3 * 1/32, 0, 0.2) * 0.25
    }

    This is a third-party UGen (DEINDUGens).

    See also

    BinaryOpUGen

  108. object DiskIn extends ProductReader[DiskIn] with Serializable

    A UGen to stream in a signal from an audio file.

    A UGen to stream in a signal from an audio file. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.

    Note: The buffer size must be a multiple of (2 * the server's block size). See Buffer#cue for details.

    See also

    Buffer#cue

    VDiskIn

    PlayBuf

  109. object DiskOut extends ProductReader[DiskOut] with Serializable

    A UGen which writes a signal to a sound file on disk.

    A UGen which writes a signal to a sound file on disk. To achieve this efficiently, a buffer is needs to be provides which is used to buffer the incoming signal.

    Note: It might be that the buffer size must be a multiple of (2 * the server's block size). We haven't currently verified this, but to be safe, you should make sure this property is met.

    The signal output by the UGen represents the number of frames written.

    See also

    Buffer#write

    DiskIn

    RecordBuf

  110. object Diwhite extends ProductReader[Diwhite] with Serializable

    A demand-rate UGen that produces equally distributed random integer numbers.

    A demand-rate UGen that produces equally distributed random integer numbers.

    Examples
    // random pitch
    play {
      val in = Diwhite(lo = 0, hi = 15)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    See also

    Dwhite

    Dibrown

    IRand

    TIRand

    Demand

  111. object Donce extends ProductReader[Donce] with Serializable
  112. object Done extends ProductReader[Done] with Serializable

    A UGen which monitors another UGen to see when it is finished.

    A UGen which monitors another UGen to see when it is finished. Some UGens, such as PlayBuf , RecordBuf , Line , XLine , EnvGen , Linen , BufRd , BufWr , DbufRd , and the Buffer delay UGens set a 'done' flag when they are finished playing. This UGen echoes that flag as an explicit output signal when it is set to track a particular UGen. When the tracked UGen changes to done, the output signal changes from zero to one.

    See also

    PlayBuf

    Line

    EnvGen

  113. object Dpoll extends ProductReader[Dpoll] with Serializable

    A demand rate UGen printing the current output value of its input to the console when polled.

    A demand rate UGen printing the current output value of its input to the console when polled.

    See also

    SendTrig

    Poll

  114. object Drand extends ProductReader[Drand] with Serializable

    A demand-rate UGen which outputs random elements from a sequence.

    A demand-rate UGen which outputs random elements from a sequence. Drand allows duplicate elements to appear, whereas Dxrand forbids repetitions.

    Examples
    // sequence of constants
    play {
      val in = Drand(Seq(3, 5, 7, 8, 11), inf)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    See also

    Demand

    Dser

    Dxrand

    Diwhite

  115. object Dreset extends ProductReader[Dreset] with Serializable

    A demand-rate UGen that, when triggered, resets the state of its in argument.

    A demand-rate UGen that, when triggered, resets the state of its in argument.

    Examples
    // reset on mouse-click
    play {
      val in = Dreset(Dseries(0, 2, inf), MouseButton.kr)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = v * 30 + 340
      SinOsc.ar(f) * 0.1
    }
    See also

    Demand

    Duty

  116. object Dseq extends ProductReader[Dseq] with Serializable

    A demand-rate UGen which reproduces and repeats a sequence of values.

    A demand-rate UGen which reproduces and repeats a sequence of values.

    The arguments can be constant or any other ugens, where demand rate UGens are normally polled, proceeding to the next value when the sub-sequence ends.

    Examples
    // sequence of constants
    play {
      val in = Dseq(Seq(3, 5, 7, 8, 11), inf)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    // constants alternating with white noise samples
    play {
      val in = Dseq(Seq[GE](3, 5, 7, 8, 11, WhiteNoise.kr * 2), inf)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    // constants alternating with two brownian values
    play {
      val br = Dbrown(lo = -3, hi = 3, step = 1, length = 2)
      val c7 = Dseq(7, repeats = inf)
      val in = Dseq(Seq[GE](3, 5, 7, 8, 11, br), inf)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    See also

    Demand

    Dser

  117. object Dser extends ProductReader[Dser] with Serializable

    A demand-rate UGen which reproduces and repeats values of a sequence.

    A demand-rate UGen which reproduces and repeats values of a sequence. It is very similar to Dseq , the difference being that the length parameter specifies the length of output sequence, not the number of repetitions of the input sequence. The input sequence is repeated if length is greater than the length of the input sequence.

    The arguments can be constant or any other ugens, where demand rate UGens are normally polled, proceeding to the next value when the sub-sequence ends.

    Examples
    // sequence of constants
    play {
      val in = Dseq(Seq(3, 5, 7, 8, 11), 8)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    See also

    Demand

    Dseq

  118. object Dseries extends ProductReader[Dseries] with Serializable

    A demand-rate UGen which produces an arithmetic (linear) series.

    A demand-rate UGen which produces an arithmetic (linear) series.

    The arguments can be constant or any other ugens.

    See also

    Dgeom

    Dseq

  119. object Dshuf extends ProductReader[Dshuf] with Serializable

    A demand-rate UGen which outputs a randomly shuffled version of an input sequence.

    A demand-rate UGen which outputs a randomly shuffled version of an input sequence. The sequence is only shuffled once, thus when repeats is greater than one, the same randomized sequence will be repeated, until the UGen is reset. This happens for example, when it is nested inside a Dseq , as shown in the example "reshuffle".

    Examples
    // sequence of constants
    play {
      val in = Dshuf(Seq(3, 5, 7, 8, 11), inf)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    // reshuffle
    play {
      val in = Dseq(Seq[GE](Dshuf(Seq(3, 5, 7, 8, 11), 4), 24), inf)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    // audio rate
    play {
      val in = Dseq(Seq(Dshuf(Seq.fill(81)(util.Random.nextInt(10)), 5)), inf)
      val tr = Impulse.ar(500)
      val f  = Demand.ar(tr, in) * 30 + 340
      SinOsc.ar(f) * 0.1
    }
    // embedded structures
    play {
      val in = Dseq(repeats = inf, seq =
        Dshuf(repeats = 8, seq = Seq[GE](
          Drand(Seq(1, 2, 3), 1),
          3,
          Drand(Seq(20, 23, 56), 1),
          7, 8.5)))
      val tr = Impulse.kr(MouseX.kr(1, 40, 1))
      val f  = Demand.kr(tr, in) * 30 + 340
      SinOsc.ar(f) * 0.1
    }
    See also

    Demand

    Dser

    Drand

    Dshuf

  120. object Dstutter extends ProductReader[Dstutter] with Serializable
  121. object Dswitch extends ProductReader[Dswitch] with Serializable
  122. object Dswitch1 extends ProductReader[Dswitch1] with Serializable
  123. object Dust extends ProductReader[Dust] with Serializable

    A UGen generating random impulses with values ranging from 0 to +1 .

    A UGen generating random impulses with values ranging from 0 to +1 . The pulse duration is one sample for audio-rate and one block for control-rate operation.

    The approximate RMS energy is (density/sr).log2 * 3 - 4.8 where sr is the sample-rate. For example, at 44.1 kHz, a density of 1000 Hz yields an RMS of approx. -21.2 dB.

    Examples
    // decreasing density
    play { Dust.ar(XLine.kr(20000, 2, Seq(20, 20))) * 0.5 }
    See also

    Dust2

    TRand

    RandSeed

    ClipNoise

    GrayNoise

    CoinGate

  124. object Dust2 extends ProductReader[Dust2] with Serializable

    A UGen generating random impulses with values ranging from -1 to +1 .

    A UGen generating random impulses with values ranging from -1 to +1 . The pulse duration is one sample for audio-rate and one block for control-rate operation.

    Examples
    // decreasing density
    play { Dust2.ar(XLine.kr(20000, 2, Seq(20, 20))) * 0.5 }
    See also

    Dust

    TRand

    RandSeed

    ClipNoise

    CoinGate

  125. object Duty extends ProductReader[Duty] with Serializable

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input.

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input. A value from the level ugen is demanded and output according to a stream of duration values. When there is a trigger at the reset input, the level and the dur input are reset.

    Note

    The argument order is different from its sclang counterpart.

    See also

    TDuty

    Demand

    DoneAction

  126. object Dwhite extends ProductReader[Dwhite] with Serializable

    A demand-rate UGen that produces random decimal numbers with a constant spectral density, equivalent to WhiteNoise for audio- or control-rate.

    A demand-rate UGen that produces random decimal numbers with a constant spectral density, equivalent to WhiteNoise for audio- or control-rate.

    Examples
    // random frequency
    play {
      val in = Dwhite(lo = 0, hi = 15)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = v * 30 + 300
      SinOsc.ar(f) * 0.1
    }
    See also

    Diwhite

    Dbrown

    WhiteNoise

    Demand

  127. object Dxrand extends ProductReader[Dxrand] with Serializable

    A demand-rate UGen which outputs random elements from a sequence.

    A demand-rate UGen which outputs random elements from a sequence. Dxrand forbid repetitions, whereas Drand allows duplicate elements to appear.

    Examples
    // sequence of constants
    play {
      val in = Dxrand(Seq(3, 5, 7, 8, 11), inf)
      val tr = Impulse.kr(5)
      val v  = Demand.kr(tr, in)
      v.poll(tr)
      val f  = (v + 62).midiCps
      SinOsc.ar(f) * 0.1
    }
    See also

    Demand

    Dser

    Drand

    Dshuf

  128. object Env extends EnvFactory[Env] with Serializable
  129. object EnvGen extends ProductReader[EnvGen] with Serializable

    An envelope generator UGen.

    An envelope generator UGen. It uses a break point description in its envelope input, typically coming from an Env object. The envelope may be re-triggered using the gate input. Upon start and upon re-triggering, the envelope , levelScale , levelBias and timeScale parameters are polled and remain constant for the duration of the envelope.

    To construct a manual envelope without the use of the Env class, the format should be as follows:

    val env = Seq[GE](startLevel, numSegments, releaseNode, loopNode,
    targetLevel1, duration1, curveType1, curvature1,
    targetLevel2, duration2, curveType2, curvature2,
    ...)

    Where the curve-type is one of Curve.step.id , Curve.lin.id , Curve.exp.id , etc. The curvature values are only relevant for the parametric curve type. The releaseNode and loopNode parameters are segment indices or the special value -99 indicating that there are no release or loop segments.

    Note: The actual minimum duration of a segment is not zero, but one sample step for audio rate and one block for control rate. This may result in asynchronicity when in two envelopes of different number of levels, the envelope times add up to the same total duration. Similarly, when modulating times, the new time is only updated at the end of the current segment; this may lead to asynchronicity of two envelopes with modulated times.

    Examples
    // percussive one-shot
    play { PinkNoise.ar(EnvGen.kr(Env.perc, doneAction = freeSelf)) }
    // fixed duration amplitude envelope
    play {
      val env = Env(0, Seq(0.01 -> 1, 0.5 -> 0.5, 0.02 -> 1, 0.5 -> 0))
      SinOsc.ar(470) * EnvGen.kr(env, doneAction = freeSelf)
    }
    // amplitude and frequency modulation
    play {
      val env  = Env(0, Seq(0.01 -> 1, 0.5 -> 0.5, 0.02 -> 0.8, 0.5 -> 0, 0.2 -> 1.2, 0.5 -> 0))
      val gate = Impulse.kr(MouseX.kr(0.2, 3), 0.5)
      val gen  = EnvGen.kr(env, gate)
      SinOsc.ar(270, SinOsc.ar(gen * 473)) * gen * 0.2
    }
    // Dust-triggered envelope
    play {
      val c   = Curve.parametric(-4)
      val env = Env(0, Seq((0.05,0.5,c), (0.1,0.0,c), (0.01,1.0,c), (1.0,0.9,c), (1.5,0.0,c)))
      val gen = EnvGen.ar(env, Dust.ar(1))
      SinOsc.ar(gen * 1000 + 440) * gen * 0.1
    }
    // two channels
    play {
      val p = Curve.parametric(-4)
    
      def mkEnv(a: Double, b: Double) = {
        val env = Env(0.0, Seq((0.05,a,p), (0.1,0.0,p), (0.01,1.0,p), (1.0,b,p), (1.5,0.0,p)))
        EnvGen.ar(env, Dust.ar(1))
      }
    
      val gen: GE = Seq(mkEnv(-0.2, -0.4), mkEnv(0.5, 0.9))
      SinOsc.ar(gen * 440 + 550) * gen * 0.1
    }
    // control gate and done-action
    val x = play {
      var gen = EnvGen.kr(Env.adsr(), "gate".kr(0), doneAction = "done".kr(0))
      SinOsc.ar(440) * gen * 0.1
    }
    
    x.set("gate" -> 1)  // turn on
    x.set("gate" -> 0)  // turn off
    x.set("gate" -> 1)  // turn on
    x.set("done" -> freeSelf.id, "gate" -> 0) // turn off and free
    // fast triggering
    play {
      val freq = MouseX.kr(1, 100, 1)
      val gate = Impulse.ar(freq)
      val env  = Env.perc(0.1, 0.9)
      val gen  = EnvGen.ar(env, gate = gate, timeScale = freq.reciprocal)
      SinOsc.ar(440) * gen * 0.1
    }
    See also

    Env

    IEnvGen

    Line

    XLine

    Linen

    Decay

  130. object ExpRand extends ProductReader[ExpRand] with Serializable

    A scalar UGen that generates a single random decimal value, using an exponential distribution from lo to hi .

    A scalar UGen that generates a single random decimal value, using an exponential distribution from lo to hi . Values lo and hi must both have the same sign and be non-zero.

    Examples
    // random sine frequencies
    play {
      val m = Mix.fill(10)(FSinOsc.ar(ExpRand(200.0, 800.0)))
      m * Line.kr(0.025, 0, 4, doneAction = freeSelf)
    }
    See also

    Rand

    TExpRand

    RandSeed

  131. object FBSineC extends ProductReader[FBSineC] with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = sin(im * y[n] + fb * x[n])
    y[n+1] = (a * y[n] + c) % 2pi

    This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0 , and a = 1 a normal sine wave results.

    Examples
    // default initial parameters
    play { FBSineC.ar(SampleRate.ir/4) * 0.2 }
    // increase feedback
    play { FBSineC.ar(SampleRate.ir, 1, Line.kr(0.01, 4, 10), 1, 0.1) * 0.2 }
    // increase phase multiplier
    play { FBSineC.ar(SampleRate.ir, 1, 0, XLine.kr(1, 2, 10), 0.1) * 0.2 }
    // modulate frequency and index multiplier
    play { FBSineC.ar(LFNoise2.kr(1).mulAdd(1e4, 1e4), LFNoise2.kr(1).mulAdd(16, 17), 1, 1.005, 0.7) * 0.2 }
    // randomly modulate parameters
    play {
      FBSineC.ar(
        LFNoise2.kr(1).mulAdd(1e4, 1e4),
        LFNoise2.kr(1).mulAdd(32, 33),
        LFNoise2.kr(1) * 0.5,
        LFNoise2.kr(1).mulAdd(0.05, 1.05),
        LFNoise2.kr(1).mulAdd(0.3, 0.3)
      ) * 0.2
    }
    See also

    FBSineN

    FBSineL

  132. object FBSineL extends ProductReader[FBSineL] with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = sin(im * y[n] + fb * x[n])
    y[n+1] = (a * y[n] + c) % 2pi

    This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.

    Examples
    // default initial parameters
    play { FBSineL.ar(SampleRate.ir/4) * 0.2 }
    // increase feedback
    play { FBSineL.ar(SampleRate.ir, 1, Line.kr(0.01, 4, 10), 1, 0.1) * 0.2 }
    // increase phase multiplier
    play { FBSineL.ar(SampleRate.ir, 1, 0, XLine.kr(1, 2, 10), 0.1) * 0.2 }
    // modulate frequency and index multiplier
    play { FBSineL.ar(LFNoise2.kr(1).mulAdd(1e4, 1e4), LFNoise2.kr(1).mulAdd(16, 17), 1, 1.005, 0.7) * 0.2 }
    // randomly modulate parameters
    play {
      FBSineL.ar(
        LFNoise2.kr(1).mulAdd(1e4, 1e4),
        LFNoise2.kr(1).mulAdd(32, 33),
        LFNoise2.kr(1) * 0.5,
        LFNoise2.kr(1).mulAdd(0.05, 1.05),
        LFNoise2.kr(1).mulAdd(0.3, 0.3)
      ) * 0.2
    }
    See also

    FBSineN

    FBSineC

  133. object FBSineN extends ProductReader[FBSineN] with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = sin(im * y[n] + fb * x[n])
    y[n+1] = (a * y[n] + c) % 2pi

    This uses a linear congruential function to drive the phase indexing of a sine wave. For im = 1, fb = 0, and a = 1 a normal sine wave results.

    Examples
    // default initial parameters
    play { FBSineN.ar(SampleRate.ir/4) * 0.2 }
    // increase feedback
    play { FBSineN.ar(SampleRate.ir, 1, Line.kr(0.01, 4, 10), 1, 0.1) * 0.2 }
    // increase phase multiplier
    play { FBSineN.ar(SampleRate.ir, 1, 0, XLine.kr(1, 2, 10), 0.1) * 0.2 }
    // modulate frequency and index multiplier
    play { FBSineN.ar(LFNoise2.kr(1).mulAdd(1e4, 1e4), LFNoise2.kr(1).mulAdd(16, 17), 1, 1.005, 0.7) * 0.2 }
    // randomly modulate parameters
    play {
      FBSineN.ar(
        LFNoise2.kr(1).mulAdd(1e4, 1e4),
        LFNoise2.kr(1).mulAdd(32, 33),
        LFNoise2.kr(1) * 0.5,
        LFNoise2.kr(1).mulAdd(0.05, 1.05),
        LFNoise2.kr(1).mulAdd(0.3, 0.3)
      ) * 0.2
    }
    See also

    FBSineL

    FBSineC

  134. object FFT extends ProductReader[FFT] with Serializable

    A UGen performing short-time forward fourier transformations.

    A UGen performing short-time forward fourier transformations. In order to properly link the spectral ugens ( PV_... ), you should begin by using the output of each UGen (which is just the fft buffer identifier), and use that as buffer input of the next UGen. That way, the UGen graph is correctly sorted. E.g. IFFT(PV_...(FFT(buf, in))) .

    The UGen will initially output zero until the first FFT can be performed. This is the case after hop * fftSize . Thus, for a default fft buffer size of 1024 and a hop of 0.5, and for a default control block size of 64, for the first 1024*0.5/64 = 8 control blocks the UGen will output zero. This also implies that the first FFT in this case is performed on the first 512 samples of the in signal (prepended by 512 zeros). In other words, the first 'full' FFT of the input happens after fftSize/controlBlockSize cycles, no matter what hop size was chosen.

    If you use FFT for performing signal analysis and not phase vocoder effects, make sure you change the window type accordingly.

    Examples
    // perfect reconstruction
    play {
      // with a hop of 0.5 and forward Hann window,
      // we get a perfect reconstruction delayed
      // by the fftSize minus one control-block.
      // (alternatively, you can use a hop of 1.0,
      //  and winType of 1 for both FFT and IFFT)
      val n     = 1024
      val hop   = 0.5
      val buf   = LocalBuf(n)
      val in    = PinkNoise.ar(0.5)
      val fft   = FFT(buf, in, hop = hop, winType = 1)
      val out   = IFFT.ar(fft, winType = -1)
      val dur   = (2 * n * hop) / SampleRate.ir - ControlDur.ir
      val dly   = DelayN.ar(in, dur, dur)
      out - dly
    }
    See also

    IFFT

    FFTTrigger

  135. object FFTTrigger extends ProductReader[FFTTrigger] with Serializable

    A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal.

    A phase vocoder UGen that takes a buffer and prepares it to be used in FFT chains, without doing an actual FFT on a signal. This is useful if you want to provide a buffer whose content had already been transformed into the Fourier domain.

  136. object FOS extends ProductReader[FOS] with Serializable

    A first order filter section UGen.

    A first order filter section UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:

    out(i) = a0 * in(i) + a1 * in(i-1) + b1 * out(i-1)

    Warning: there are bugs when the coefficients are modulated

    Examples
    // same as OnePole
    play {
      val x = LFTri.ar(0.4) * 0.99
      FOS.ar(LFSaw.ar(200) * 0.1, 1 - x.abs, 0.0, x)
    }
    // same as OneZero
    play {
      val x = LFTri.ar(0.4) * 0.99
      FOS.ar(LFSaw.ar(200) * 0.1, 1 - x.abs, x, 0.0)
    }
    See also

    SOS

    OnePole

    OneZero

  137. object FSinOsc extends ProductReader[FSinOsc] with Serializable

    A sine oscillator UGen using a fast approximation.

    A sine oscillator UGen using a fast approximation. It uses a ringing filter and is less CPU expensive than SinOsc . However, the amplitude of the wave will vary with frequency. Generally the amplitude will go down when the frequency rises and it will go up as if the frequency is lowered.

    Warning: In the current implementation, the amplitude can blow up if the frequency is modulated by certain alternating signals (e.g. abruptly by TRand ).

    Examples
    // plain oscillator
    play { FSinOsc.ar(441) * 0.2 }
    See also

    SinOsc

    SinOscFB

  138. object Flatten extends ProductReader[Flatten] with Serializable
  139. object Fold extends ProductReader[Fold] with Serializable

    A UGen that constrains a signal to a given range, by "folding" values outside the range.

    A UGen that constrains a signal to a given range, by "folding" values outside the range. This is similar to the fold2 binary operator but permits both a lower range value lo and an upper range value hi .

    Folding can be understood as "reflecting" around the boundaries. For example, if the upper margin is 3, then if an input value exceeds 3, the excess is negatively reflected; 3.1 becomes 2.9, 3.2 becomes 2.8, etc. until the lower margin is reached again where another reflection occurs. Likewise, if the lower margin is 1, then if an input value falls below 1, the undershoot is reflected; 0.9 becomes 1.1, 0.8 becomes 1.2, etc. until the upper margin is reached again where another reflection occurs.

    Examples
    // fold sawtooth wave to modulate timbre
    play {
      val hi = SinOsc.ar(0.1).linExp(-1, 1, 0.01, 1.0)
      Fold.ar(Saw.ar(300), 0, hi) * 0.2 / hi
    }
    See also

    Wrap

    Clip

  140. object FoldIndex extends ProductReader[FoldIndex] with Serializable

    A UGen which reads a single sample value from a buffer at a given index.

    A UGen which reads a single sample value from a buffer at a given index.

    It uses the in argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are "folded" inside the valid range. Folding means reflecting the excess at the valid range's boundaries.

    For example, if the buffer has four samples, index 4 is wrapped to index 2 (the excess beyond the maximum index of 3 is 4 - 3 = 1, and the excess is folded so that and 3 - 1 = 2), index 5 is folded to index 1, index -1 is folded to index 1, index -2 is folded to index 2, etc.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the Index UGen for details.

    See also

    Index

    WrapIndex

    IndexL

  141. object Formant extends ProductReader[Formant] with Serializable

    A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.

    A UGen that generates a set of harmonics around a formant frequency at a given fundamental frequency.

    Examples
    // modulate fundamental frequency
    play { Formant.ar(XLine.kr(400, 1000, 8), 2000, 800) * 0.2 }
    // modulate formant frequency
    play { Formant.ar(200, XLine.kr(400, 4000, 8), 200) * 0.2 }
    // modulate the bandwidth
    play { Formant.ar(400, 2000, XLine.kr(800, 8000, 8)) * 0.2 }
  142. object Formlet extends ProductReader[Formlet] with Serializable

    A FOF-like resonant filter UGen.

    A FOF-like resonant filter UGen. Its impulse response is like that of a sine wave with a Decay2 envelope over it. It is possible to control the attack and decay times.

    Formlet is equivalent to:

    Ringz(in, freq, decay) - Ringz(in, freq, attack)

    The great advantage to this filter over FOF (Fonction d'onde formantique) is that there is no limit to the number of overlapping grains since the grain is just the impulse response of the filter.

    Note: Ringz and derived UGens Klank and Formlet produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.

    Examples
    // modulated formant frequency
    play {
      val in = Blip.ar(SinOsc.kr(5,0).mulAdd(20, 300), 1000) * 0.1
      Formlet.ar(in, XLine.kr(1500, 700, 8), 0.005, 0.04)
    }
    // mouse control of frequency and decay time
    play {
      val in    = Blip.ar(SinOsc.kr(5,0).mulAdd(20, 300), 1000) * 0.1
      val freq  = MouseY.kr(700, 2000, 1)
      val decay = MouseX.kr(0.01, 0.2, 1)
      Formlet.ar(in, freq, attack = 0.005, decay = decay)
    }
    See also

    Ringz

    Resonz

    RLPF

    RHPF

  143. object Free extends ProductReader[Free] with Serializable

    A UGen that, when triggered, frees a given node.

    A UGen that, when triggered, frees a given node.

    This UGen outputs its trig input signal for convenience.

    See also

    Pause

    FreeSelf

  144. object FreeSelf extends ProductReader[FreeSelf] with Serializable

    A UGen that, when triggered, frees enclosing synth.

    A UGen that, when triggered, frees enclosing synth. It frees the enclosing synth when the input signal crosses from non-positive to positive.

    Note that if the trigger is initially high the UGen will not react. For example, FreeSelf.kr("foo".kr) will not work if the control is initially 1 . A work-around is to wrap the input in this case in a Trig object: FreeSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.

    This UGen outputs its input signal for convenience.

    See also

    Free

    PauseSelf

  145. object FreeSelfWhenDone extends ProductReader[FreeSelfWhenDone] with Serializable

    A UGen that, when its input UGen is finished, frees enclosing synth.

    A UGen that, when its input UGen is finished, frees enclosing synth. This is essentially a shortcut for FreeSelf.kr(Done.kr(src)) , so instead of providing a trigger signal it reads directly the done flag of an appropriate ugen (such as Line or PlayBuf ).

    This UGen outputs its input signal for convenience.

    See also

    Free

    FreeSelf

    PauseSelfWhenDone

    Done

  146. object FreeVerb extends ProductReader[FreeVerb] with Serializable

    A monophonic reverb UGen.

    A monophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator.

    Examples
    // mouse control for mix and room
    play {
      val in   = Decay.ar(Impulse.ar(1), 0.25) * LFCub.ar(1200) * 0.1
      val mix  = MouseX.kr
      val room = MouseY.kr
      val verb = FreeVerb.ar(in, mix, room, "damp".kr(0.5))
      Pan2.ar(verb)
    }
    See also

    FreeVerb2

    GVerb

  147. object FreeVerb2 extends ProductReader[FreeVerb2] with Serializable

    A stereophonic reverb UGen.

    A stereophonic reverb UGen. All parameters are specified in and automatically clipped to the range 0 to 1. The UGen is stateless insofar it does not use a random number generator. However, if the same input is used for left and right channel, the output channels are different and uncorrelated. There is also some cross-feed between the two channels.

    Examples
    // mouse control for mix and room, random input pan
    play {
      val tr   = Impulse.ar(1)
      val in   = Decay.ar(tr, 0.25) * LFCub.ar(1200) * 0.1
      val in2  = Pan2.ar(in, TRand.ar(-1, 1, tr))
      val mix  = MouseX.kr
      val room = MouseY.kr
      FreeVerb2.ar(in2 out 0, in2 out 1, mix, room, "damp".kr(0.5))
    }
    See also

    FreeVerb

    GVerb

  148. object FreqShift extends ProductReader[FreqShift] with Serializable

    A frequency shifting UGen.

    A frequency shifting UGen. It implements single sideband (SSB) amplitude modulation, also known as frequency shifting, but not to be confused with pitch shifting. Frequency shifting moves all the components of a signal by a fixed amount but does not preserve the original harmonic relationships.

    Examples
    // shift a sine frequency from 200 to 700 Hz
    play {
      val freq = Line.ar(0, 500, 5)
      FreqShift.ar(SinOsc.ar(200) * 0.25, freq)
    }
    // negative frequency to shift downwards
    play {
      val freq = Line.ar(0, -500, 5)
      FreqShift.ar(SinOsc.ar(700) * 0.25, freq)
    }
    See also

    Hilbert

    PV_MagShift

  149. object Friction extends ProductReader[Friction] with Serializable

    A UGen implementing a physical model of a system with dry-friction.

    A UGen implementing a physical model of a system with dry-friction. A chaotic filter.

    The input is treated as the driving force in a physical model of a mass resting on a belt, which can stick or slip relative to the belt (depending on the friction between the two). The input represents the position of the belt, and the mass is held approximately in place by a spring and a damper. The output is the position of the mass, which in very high-friction situations will be exactly the same as the input – but when the other forces can overcome the friction then stick-and-slip alternations will typically occur.

    Note that DC offset will have a qualitative effect on the system's behaviour (because of the spring being stretched), so feel free to experiment with adding/removing DC.

    The model is inspired by the one considered in this research article: A. Luo and B. Gegg, Dynamics of a harmonically excited oscillator with dry-friction on a sinusoidally time-varying, traveling surface, International Journal of Bifurcation and Chaos, 16 (2006), pp. 3539–3566.

    To create the system studied in that paper (which analyses chaotic stick-and-slip oscillations), the input should be a sinusoid added to an ever-increasing ramp value. But for musical effects you can do different things.

    Examples
    // filter a simple sine wave, producing a chaotic result
    play {
      val sig = SinOsc.ar(660)
      val out = Friction.ar(sig, friction = 5.41322e-5, mass = 8.05501)
      Pan2.ar(out, 0, 0.1)
    }
    // modulate parameters by mouse. Left is original (modulated) sine wave, right is filtered
    play {
      val sig = SinOsc.ar((LFPulse.kr(0.5) + LFPulse.kr(0.33)).mulAdd(220, 440).lag(0.1))
      val out = Friction.ar(sig, friction = MouseX.kr(0.00001, 0.03, 1), mass = MouseY.kr(0.2, 10, 1))
      GESeq(sig, out) * 0.1
    }
    // Ringz oscillators, each with separate Friction, merged to create 'rusty' klank.
    play {
      // Note the way the effect changes as the sound dies away.
      val imp = Impulse.ar(1) * 0.1
      val klank = Ringz.ar(imp, Seq(800, 1071, 1153, 1723))
      val rusty = Friction.ar(klank, friction = 1.75584e-5, mass = 2.69789)
      Pan2.ar(Mix(rusty))
    }
    // play with DC offset and spring stiffness
    play {
      val sig = SinOsc.ar(330) + MouseX.kr(0.01, 10, 1)
      val out = Friction.ar(sig, friction = 5.41322e-5, mass = 8.05501, spring = MouseY.kr(0,1))
      Pan2.ar(out * 0.1)
    }
    // DC offset and spring stiffness for a control signal
    play {
      // Converts boring sinusoidal freq undulation into something much more interesting
      val sig = LFPar.kr(33) + MouseX.kr(0.01, 10, 1)
      val fr  = Friction.kr(sig, friction = 5.41322e-5, mass = 8.05501, spring = MouseY.kr(0,1))
      val out = SinOsc.ar(fr.linLin(-1, 1, 150, 500))
      Pan2.ar(out * 0.1)
    }

    This is a third-party UGen (MCLDUGens).

  150. object GESeq extends ProductReader[GESeq] with Serializable
  151. object GVerb extends ProductReader[GVerb] with Serializable

    A stereophonic reverb UGen.

    A stereophonic reverb UGen. It is based on the GVerb LADSPA effect by Juhana Sadeharju.

    Note: A CPU spike may occur when the synth is instantiated. Warning: The UGen has a bug which results in loud noise if the room size is increased during playback. It seems safe to start with a large room size and decrease the value during playing. Warning: The UGen may crash the server if roomSize becomes larger than maxRoomSize .

    Examples
    // mouse control for time and damping
    play {
      val tr   = Impulse.ar(1)
      val in   = Decay.ar(tr, 0.25) * LFCub.ar(1200) * 0.1
      val damp = MouseX.kr
      val tail = MouseY.kr(1, 100, 1)
      GVerb.ar(in, roomSize = 20, revTime = tail, damping = damp, maxRoomSize = 20)
    }
    See also

    FreeVerb

    FreeVerb2

  152. object Gate extends ProductReader[Gate] with Serializable

    A gate or hold UGen.

    A gate or hold UGen. It allows the input signal value to pass when the gate argument is positive, otherwise it holds last value.

    Before the first high gate value is registered, this UGen outputs zero.

    See also

    Latch

  153. object GbmanL extends ProductReader[GbmanL] with Serializable
  154. object GbmanN extends ProductReader[GbmanN] with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = 1 - y[n] + abs(x[n])
    y[n+1] = x[n]

    The behavior of the system is only dependent on its initial conditions. Reference: Devaney, R. L. "The Gingerbreadman." Algorithm 3, 15-16, Jan. 1992.

    Examples
    // default initial parameters
    play { GbmanN.ar(MouseX.kr(20, SampleRate.ir)) * 0.1 }
    // change initial parameters
    play { GbmanN.ar(MouseX.kr(20, SampleRate.ir), -0.7, -2.7) * 0.1 }
    // wait for it...
    play { GbmanN.ar(MouseX.kr(20, SampleRate.ir), 1.2, 2.0002) * 0.1 }
    // as a frequency control
    play { SinOsc.ar(GbmanN.ar(40) * 400 + 500) * 0.4 }
    See also

    GbmanL

  155. object Gen extends App
  156. object Gendy1 extends ProductReader[Gendy1] with Serializable
  157. object Gendy2 extends ProductReader[Gendy2] with Serializable
  158. object Gendy3 extends ProductReader[Gendy3] with Serializable
  159. object Goertzel extends ProductReader[Goertzel] with Serializable

    A UGen implementing the Goertzel algorithm which is a way to calculate the magnitude and phase of a signal's content at a single specified frequency.

    A UGen implementing the Goertzel algorithm which is a way to calculate the magnitude and phase of a signal's content at a single specified frequency. It is the equivalent of running an FFT, and then only looking at the output corresponding to a single bin. If one is only interested in a small number of bins, then it is more efficient; if one is interested in the majority of bins, one typically wants to do an FFT instead.

    Examples
    // tracking the amplitude of a known sine wave
    play {
      val freqM  = 220.0
      // try changing freq to a matching or non-matching frequency to what we're looking for
      val freq   = freqM  // or try MouseY.kr(110, 440, 1)
      val amp    = MouseX.kr
      val sig    = SinOsc.ar(freq) * amp
      val length = 4096
      val g      = Goertzel.kr(sig, length, freqM)
    
      // Calc the magnitude. We also normalize it against buffer size here.
      val mag = (g.real.squared + g.imag.squared).sqrt / (length / 2)
      amp.poll(label = "Input    amplitude")
      mag.poll(label = "Measured amplitude")
      Pan2.ar(sig * 0.1)
    }
    // tracking control rate input
    play {
      val freqM  = 22.0
      // try changing freq to a matching or non-matching frequency to what we're looking for
      val freq   = freqM  // or try MouseY.kr(110, 440, 1)
      val amp    = MouseX.kr
      val sig    = SinOsc.kr(freq) * amp
      val length = 100
      val g      = Goertzel.kr(sig, length, freqM)
    
      // Calc the magnitude. We also normalize it against buffer size here.
      val mag = (g.real.squared + g.imag.squared).sqrt / (length / 2)
      amp.poll(label = "Input    amplitude")
      mag.poll(label = "Measured amplitude")
      ()
    }

    This is a third-party UGen (MCLDUGens).

  160. object GrainBuf extends ProductReader[GrainBuf] with Serializable

    A granular synthesis UGen taking sound stored in a buffer.

    A granular synthesis UGen taking sound stored in a buffer. Another buffer can be used to provide an amplitude envelope. The input sound buffer must be monophonic, but output may be multi-channel, using a panorama control.

    All arguments except numChannels and maxGrain are polled at grain creation (trigger) time.

    See also

    TGrains

    PlayBuf

    PanAz

  161. object GrainFM extends ProductReader[GrainFM] with Serializable
  162. object GrainIn extends ProductReader[GrainIn] with Serializable
  163. object GrainSin extends ProductReader[GrainSin] with Serializable
  164. object GrayNoise extends ProductReader[GrayNoise] with Serializable

    A noise generator UGen which results from flipping random bits in a word.

    A noise generator UGen which results from flipping random bits in a word. The resulting waveform looks like a sample-and-hold function with values between -1 and +1 (before being multiplied by mul ).

    This type of noise has a high RMS level relative to its peak to peak level. With approx. -4.8 dB, the RMS is the same as white noise, but the spectrum is emphasized towards lower frequencies.

    Examples
    // plain noise
    play { GrayNoise.ar(Seq(0.2, 0.2)) }
    See also

    WhiteNoise

    PinkNoise

    BrownNoise

    ClipNoise

    RandSeed

    LFNoise0

    Dust

  165. object Greyhole extends ProductReader[Greyhole] with Serializable

    A complex echo-like effect UGen, inspired by the classic Eventide effect of a similar name.

    A complex echo-like effect UGen, inspired by the classic Eventide effect of a similar name. The effect consists of a diffuser (like a mini-reverb) connected in a feedback system with a long modulated delay-line. Excels at producing spacey washes of sound.

    Note: You may need to increase the server's real-time memory

    Examples
    // discrete
    play {
      val src = LeakDC.ar(Splay.ar(Impulse.ar(Seq(1, 3, 5, 7, 9))))
      Greyhole.ar(
        inL = src.out(0), inR = src.out(1), delayTime = 0.1, damp = 0.1,
        feedback = 0.1, modDepth = 0.01, modFreq = 2)
    }
    // time modulation
    play {
      val src = LeakDC.ar(Splay.ar(Impulse.ar(Seq(1, 3, 5, 7, 9))))
      val time = LFTri.kr(0.01).linExp(-1, 1, 0.05, 0.2)
      Greyhole.ar(
        inL = src.out(0), inR = src.out(1), delayTime = time, damp = 0.4,
        feedback = 0.99, modDepth = 0.01, modFreq = 2)
    }

    This is a third-party UGen (DEINDUGens).

    See also

    JPverb

  166. object HPF extends ProductReader[HPF] with Serializable

    A second order high pass filter UGen.

    A second order high pass filter UGen.

    Examples
    // modulated frequency
    play {
      val in   = Saw.ar(200) * 0.5
      val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(3600, 4000)
      HPF.ar(in, freq)
    }
    // mouse controlled frequency
    play {
      val in   = WhiteNoise.ar(0.5)
      val freq = MouseX.kr(200, 10000, 1)
      HPF.ar(in, freq)
    }
    See also

    LPF

    BPF

    BRF

    RHPF

    HPZ1

  167. object HPZ1 extends ProductReader[HPZ1] with Serializable

    A two point difference filter UGen.

    A two point difference filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) - in(i-1))

    Note: the filter's memory is initialized with the first input sample, so for HPZ1.ar(DC.ar(x)) the output will be zero, even at the beginning.

    Examples
    // engage with mouse button
    play {
      val sig = PinkNoise.ar
      val flt = HPZ1.ar(sig)
      LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
    }
    // detect changes
    play {
      val z  = LFNoise0.ar(2)
      val f  = HPZ1.ar(z)
      val ch = f sig_!= 0 // input increased or decreased
      z.poll(ch, "now")
      0
    }
    See also

    OneZero

    LPZ1

    Delay1

  168. object HPZ2 extends ProductReader[HPZ2] with Serializable

    three point difference filter UGen.

    three point difference filter UGen. Implements the formula :

    out(i) = 0.25 * (in(i) - 2 * in(i-1) + in(i-2))
    Examples
    // engage with mouse button
    play {
      val sig = WhiteNoise.ar(0.5)
      val flt = HPZ2.ar(sig)
      LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
    }
    See also

    LPZ1

    HPZ2

    BPZ2

    BRZ2

  169. object Hasher extends ProductReader[Hasher] with Serializable

    A UGen that returns a unique output value from -1 to +1 for each input value according to a hash function.

    A UGen that returns a unique output value from -1 to +1 for each input value according to a hash function. The same input value will always produce the same output value. The input values can have any range.

    Examples
    // scramble mouse motion
    play {
      SinOsc.ar(
        Hasher.kr(MouseX.kr(0,10)).mulAdd(300, 500)
      ) * 0.2
    }
    // distort pulse wave
    play {
      val lag  = MouseY.kr(0.001, 0.1, 1)
      val freq = MouseX.kr(1, 500, 1)
      Hasher.ar(Lag.ar(LFPulse.ar(freq), lag)) * 0.2
    }
  170. object HenonC extends ProductReader[HenonC] with Serializable

    A cubic-interpolating sound generator based on the difference equation:

    A cubic-interpolating sound generator based on the difference equation:

    x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]

    This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.

    Examples
    // default initial parameters
    play { HenonC.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // mouse-control of parameters
    play { HenonC.ar(SampleRate.ir/4, MouseX.kr(1,1.4), MouseY.kr(0,0.3)) * 0.2 }
    // randomly modulate parameters
    play {
      HenonC.ar(
        SampleRate.ir/8,
        LFNoise2.kr(1).mulAdd(0.2, 1.2),
        LFNoise2.kr(1).mulAdd(0.15, 0.15)
      ) * 0.2
    }
    // as a frequency control
    play { SinOsc.ar(HenonC.ar(40, MouseX.kr(1, 1.4), MouseY.kr(0, 0.3)) * 800 + 900) * 0.4 }
    See also

    HenonL

    HenonC

  171. object HenonL extends ProductReader[HenonL] with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]

    This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.

    Examples
    // default initial parameters
    play { HenonL.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // mouse-control of parameters
    play { HenonL.ar(SampleRate.ir/4, MouseX.kr(1,1.4), MouseY.kr(0,0.3)) * 0.2 }
    // randomly modulate parameters
    play {
      HenonL.ar(
        SampleRate.ir/8,
        LFNoise2.kr(1).mulAdd(0.2, 1.2),
        LFNoise2.kr(1).mulAdd(0.15, 0.15)
      ) * 0.2
    }
    // as a frequency control
    play { SinOsc.ar(HenonL.ar(40, MouseX.kr(1, 1.4), MouseY.kr(0, 0.3)) * 800 + 900) * 0.4 }
    See also

    HenonL

    HenonC

  172. object HenonN extends ProductReader[HenonN] with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+2] = 1 - a * pow(x[n+1], 2) + b * x[n]

    This equation was discovered by French astronomer Michel Hénon while studying the orbits of stars in globular clusters.

    Examples
    // default initial parameters
    play { HenonN.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // mouse-control of parameters
    play { HenonN.ar(SampleRate.ir/4, MouseX.kr(1,1.4), MouseY.kr(0,0.3)) * 0.2 }
    // randomly modulate parameters
    play {
      HenonN.ar(
        SampleRate.ir/8,
        LFNoise2.kr(1).mulAdd(0.2, 1.2),
        LFNoise2.kr(1).mulAdd(0.15, 0.15)
      ) * 0.2
    }
    // as a frequency control
    play { SinOsc.ar(HenonN.ar(40, MouseX.kr(1, 1.4), MouseY.kr(0, 0.3)) * 800 + 900) * 0.4 }
    See also

    HenonL

    HenonC

  173. object Hilbert extends ProductReader[Hilbert] with Serializable

    A Hilbert transform UGen.

    A Hilbert transform UGen. This transformation produces two signals from a given input with identical frequency content, but with their respective phases shifted to be 90 degrees apart (0.5 pi radians).

    The two signals output by Hilbert correspond to the real and imaginary part of the complex transformed signal. Due to the method used (an IIR filter), distortion occurs in the upper octave of the frequency spectrum.

    The transform can be used to implemented single-side-band (SSB) modulation, but a dedicated UGen FreqShift is already provided for this case.

    Examples
    // a form of envelope tracking
    play {
      val in = SinOsc.ar(440)
      val h  = Hilbert.ar(in)
      val x  = h.real.squared + h.imag.squared
      x.poll(1)  // cos(x)^2 + sin(x)^2 == 1 (ideally)
      0
    }
    See also

    FreqShift

  174. object Hopf extends ProductReader[Hopf] with Serializable

    A UGen based on Hopf bifurcations that tries to synchronize to an input signal.

    A UGen based on Hopf bifurcations that tries to synchronize to an input signal.

    Examples
    // sync to sine input
    play {
      val freqIn  = MouseX.kr(100.0, 1000.0)
      freqIn.poll(label = "mouse")
      val sigIn   = SinOsc.ar(freqIn)
      val hopf    = Hopf.ar(sigIn, 0.001)
      val freqOut = hopf.omega * SampleRate.ir / (2*math.Pi)
      freqOut.poll(label = "hopf ")
      val sigOut  = hopf.phase
      Pan2.ar(sigOut * 0.01)
    }

    This is a third-party UGen (kuramoto).

    See also

    Kuramoto

  175. object IEnv extends EnvFactory[IEnv] with Serializable
  176. object IEnvGen extends ProductReader[IEnvGen] with Serializable

    Envelope generator UGen with random access index pointer into the break-point function.

    Envelope generator UGen with random access index pointer into the break-point function.

    Warning: The envelope must be generated using IEnv not Env . IEnv has a completely different format. Using the wrong format ( Env ) may crash the server.

    To construct a manual envelope without the use of the IEnv class, the format should be as follows:

    val env = Seq[GE](offset, startLevel, numSegments, totalDuration,
    duration1, curveType1, curvature1, targetLevel1,
    duration2, curveType2, curvature2, targetLevel2
    ...)
    Examples
    // mouse controls index
    play {
      import Curve._
      val env = IEnv(0, Seq(
        (0.10, 0.6, lin),
        (0.02, 0.3, exp),
        (0.40, 1.0, parametric(-6)),
        (1.10, 0.0, sine)))
      val dur = Mix(env.segments.map(_.dur))
      val gen = IEnvGen.kr(env, MouseX.kr(0, dur))
      SinOsc.ar(gen * 500 + 440) * 0.2
    }
    See also

    IEnv

    EnvGen

  177. object IFFT extends ProductReader[IFFT] with Serializable

    A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.

    A UGen performing an inverse FFT, transforming a buffer containing a spectral domain signal back into the time domain.

    Examples
    // perfect reconstruction
    play {
      // with a hop of 0.5 and forward Hann window,
      // we get a perfect reconstruction delayed
      // by the fftSize minus one control-block.
      // (alternatively, you can use a hop of 1.0,
      //  and winType of 1 for both FFT and IFFT)
      val n     = 1024
      val hop   = 0.5
      val buf   = LocalBuf(n)
      val in    = PinkNoise.ar(0.5)
      val fft   = FFT(buf, in, hop = hop, winType = 1)
      val out   = IFFT.ar(fft, winType = -1)
      val dur   = (2 * n * hop) / SampleRate.ir - ControlDur.ir
      val dly   = DelayN.ar(in, dur, dur)
      out - dly
    }
    See also

    FFT

  178. object IRand extends ProductReader[IRand] with Serializable

    A scalar UGen that generates a single random integer value, using a uniform distribution from lo to hi .

    A scalar UGen that generates a single random integer value, using a uniform distribution from lo to hi .

    Examples
    // random sine frequencies
    play {
      val m = Mix.fill(10)(FSinOsc.ar(IRand(40, 100).midiCps))
      m * Line.kr(0.025, 0, 4, doneAction = freeSelf)
    }
    See also

    Rand

    TIRand

    ExpRand

    RandSeed

  179. object Impulse extends ProductReader[Impulse] with Serializable

    A non-band-limited generator UGen for single sample impulses.

    A non-band-limited generator UGen for single sample impulses.

    Examples
    // modulating frequency
    play { Impulse.ar(XLine.kr(100, 20000, 10)) * 0.3 }
    // modulating amplitude
    play { Impulse.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.3 }
    // modulating phase
    play { Impulse.ar(4, Seq(DC.kr(0), MouseX.kr(0, 1))) * 0.3 }
    See also

    LFPulse

    Dust

    Blip

  180. object In extends ProductReader[In] with Serializable

    A UGen that reads a signal from a bus.

    A UGen that reads a signal from a bus. Whether an audio- or control-bus is used depends on the rate of the UGen.

    In.ar and In.kr behave differently with respect to signals left on the bus in the previous calculation cycle (control block): In.ar can access audio signals that were generated in the current calculation cycle by synths appearing earlier in the node tree. It does not read signals produced by nodes in the previous calculation cycle (i.e. synths appearing later in the node tree), the input would instead be zero. To allow such "feedback", InFeedback can be used.

    In contrast, In.kr does not distinguish between "new" and "old" data: It will always read the most recent value found on the bus, whether it was generated earlier in this calculation cycle, left over from the last one, or set before by the client.

    Note: The server uses the first NumOutputBuses channels to write to the sound card, followed by another NumInputBuses to read from the sound card. For convenience, the pseudo-UGens PhysicalOut and PhysicalIn can be used.

    Examples
    // cross-synth routing
    // allocate an internal stereo audio-bus
    val bus = Bus.audio(s, 2)
    
    // writes to internal bus (initially inaudible)
    val x = play {
      Out.ar(bus.index, Dust.ar(Seq(345, 345)))
    }
    
    // reads internal bus and makes it audible.
    // must be after `x` to be able to read the bus signal
    val y = play(target = x, addAction = addAfter) {
      val in = In.ar(bus.index, 2)
      Resonz.ar(in, 555, 0.1) * 10
    }
    
    // when done, do not forget to free the bus
    y.free(); x.free(); bus.free()
    See also

    Out

    PhysicalIn

    InFeedback

    LocalIn

    Bus

  181. object InFeedback extends ProductReader[InFeedback] with Serializable

    A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.

    A UGen which reads a signal from an audio bus with a current or one cycle old timestamp.

    Audio buses adhere to the concept of a cycle timestamp, which increases for each audio block calculated. When the various output ugens ( Out , OffsetOut , XOut ) write data to a bus, they mix it with any data from the current cycle, but overwrite any data from the previous cycle. ( ReplaceOut overwrites all data regardless.) Thus depending on node order and what synths are writing to the bus, the data on a given bus may be from the current cycle or be one cycle old at the time of reading.

    In.ar checks the timestamp of any data it reads in and zeros any data from the previous cycle (for use within that node; the data remains on the bus). This is fine for audio data, as it avoids feedback, but for control data it is useful to be able to read data from any place in the node order. For this reason In.kr also reads data that is older than the current cycle.

    In some cases one might also want to read audio from a node later in the current node order. This can be achieved with InFeedback . It reads from the previous cycle, and hence introduces a delay of one block size, which by default is 64 sample frames (equal to about 1.45 ms at 44.1 kHz sample rate).

    Note that no delay occurs when the bus contains a signal which has been written already in the current cycle. The delay is only introduced when no present signal exists.

    Examples
    // feedback frequency modulation
    play {
      val in = InFeedback.ar(0) // read output
      SinOsc.ar(in * 1300 + 300) * 0.4
    }
    // resonator
    val bus = Bus.audio(s) // internal feedback bus
    
    val x = play {
      val imp  = Impulse.ar(1)
      val in   = InFeedback.ar(bus.index)
      val feed = imp + in * 0.995
      // must subtract block-size for correct tuning
      // (try removing the ControlDur to here the pitch change)
      val time = 440.reciprocal - ControlDur.ir
      val dly  = DelayC.ar(feed, time, time)
      Out.ar(bus.index, dly)
    
      // alternate between feedback and reference pitch
      val comp = Seq(dly, SinOsc.ar(440) * 0.2): GE
      comp * LFPulse.kr(1, Seq(0.0, 0.5))
    }
    
    x.free(); bus.free()  // do not forget to free the bus eventually
    See also

    In

    LocalIn

    ControlDur

  182. object InRange extends ProductReader[InRange] with Serializable

    A UGen that tests if a signal is within a given range.

    A UGen that tests if a signal is within a given range. If in >= lo and in <= hi , outputs 1.0, otherwise outputs 0.0.

    Examples
    // detect whether mouse is in specific horizontal range
    play {
      val x = MouseX.kr
      InRange.kr(x, 0.4, 0.6) * PinkNoise.ar(0.3)
    }
    See also

    InRect

    Clip

    Schmidt

  183. object InRect extends ProductReader[InRect] with Serializable

    A UGen that tests if two signals lie both within a given ranges.

    A UGen that tests if two signals lie both within a given ranges. The two input signals can be understood as horizontal and vertical coordinates, therefore the test become one that determines whether the input is within a given "rectangle".

    If x >= left and x <= right and y > top and y <= bottom , outputs 1.0, otherwise outputs 0.0.

    Examples
    // detect whether mouse is in specific horizontal and vertical range
    play {
      val x  = MouseX.kr; val y = MouseY.kr(1, 0)
      val in = InRect.kr(x = x, y = y, left = 0.4, top = 0.2, right = 0.6, bottom = 0.4)
      in * PinkNoise.ar(0.3)
    }
    See also

    InRange

    Clip

  184. object InTrig extends ProductReader[InTrig] with Serializable

    A UGen which generates a trigger anytime a control bus is set.

    A UGen which generates a trigger anytime a control bus is set.

    Any time the bus is "touched" i.e. has its value set (using "/c_set" etc.), a single impulse trigger will be generated. Its amplitude is the value that the bus was set to. Note that if a signal is continuously written to that bus, for instance using Out.kr , only one initial trigger is generated once that ugen starts writing, but no successive triggers are generated.

    Examples
    // envelope trigger
    val c = Bus.control(s)
    
    val x = play {
      val tr = InTrig.kr(c.index)
      SinOsc.ar * EnvGen.kr(Env.perc, gate = tr, levelScale = tr)
    }
    
    c.set(1.0)
    c.set(0.2)
    c.set(0.1)
    
    x.free(); c.free()
    See also

    In

    TrigControl

  185. object Index extends ProductReader[Index] with Serializable

    A UGen which reads a single sample value from a buffer at a given index.

    A UGen which reads a single sample value from a buffer at a given index.

    It uses the in argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are clipped to the valid range.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, index 0 corresponds to frame 0, channel 0, index 1 correspond to frame 0, channel 1, index 2 corresponds to frame 1, channel 0, and index 3 corresponds to frame 1, channel 1.

    See also

    BufRd

    WrapIndex

    IndexL

    IndexInBetween

    DetectIndex

  186. object IndexInBetween extends ProductReader[IndexInBetween] with Serializable

    A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal.

    A UGen which determines the (lowest) index in a buffer at which the two neighboring values contain a given input signal. The output index is a decimal whose fractional part is suitable for linearly interpolating between the buffer slot values.

    For example, if the Buffer contains values 3, 21, 25, 26 and the input signal has the value 22, then the output will be 1.25, because the value 22 is in-between the values stored at indices 1 and 2 and the linear location of 22 is one-quarter of the way along the interval between them: 21 * (1 - 0.25) + 25 * (1 - 0.75) = 22.

    If the input value is smaller than the first sample, the output will be zero. If the input value is larger than any sample in the buffer, the output will be the buffer size minus one.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. For example, if the buffer has two frames and two channels, and the algorithm finds the frame 1 in channel 0, the reported index is 2 (frame * numChannels + channel).

    IndexInBetween is the complement of the IndexL UGen.

    See also

    DetectIndex

    IndexL

  187. object IndexL extends ProductReader[IndexL] with Serializable

    A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.

    A UGen which reads from a buffer at a given index, linearly interpolating between neighboring points.

    It uses the in argument as index into the buffer. Out-of-range index values are clipped to the valid range. If the index has a fractional part, it is used to interpolate between the buffer index at the floor and the buffer index at the ceiling of the index argument.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the Index UGen for details.

    See also

    Index

    IndexInBetween

  188. object InsideOut extends ProductReader[InsideOut] with Serializable

    A UGen that produces distortion by subtracting the input signal's magnitude from 1.

    A UGen that produces distortion by subtracting the input signal's magnitude from 1.

    If the input is positive, it outputs (+1 - input). If the input is negative, it outputs (-1 - input).

    Examples
    // sine plus noise
    play { InsideOut.ar(SinOsc.ar(220) + PinkNoise.ar(0.9)) * 0.1 }

    This is a third-party UGen (MCLDUGens).

  189. object Integrator extends ProductReader[Integrator] with Serializable

    A filter UGen to integrate an input signal with a leak.

    A filter UGen to integrate an input signal with a leak. Implements the formula :

    out(i) = in(i) + (coef * out(i-1))

    Warning: there are bugs when the coefficient is modulated

    See also

    OnePole

    HPZ1

    LPZ1

  190. object JPverb extends ProductReader[JPverb] with Serializable

    An algorithmic reverb UGen, inspired by the lush chorused sound of certain vintage Lexicon and Alesis reverberation units.

    An algorithmic reverb UGen, inspired by the lush chorused sound of certain vintage Lexicon and Alesis reverberation units. Designed to sound great with synthetic sound sources, rather than sound like a realistic space.

    Note: You may need to increase the server's real-time memory

    Examples
    // defaults
    play {
      val src = Splay.ar(Impulse.ar(Seq(1, 3, 5, 7, 9)))
      JPverb.ar(inL = src.left, inR = src.right)
    }
    // dream-verb
    play {
      val src = Splay.ar(Impulse.ar(Seq(1, 3, 5, 7, 9)))
      0.4 * src + 0.8 * JPverb.ar(
        inL = src.left, inR = src.right, revTime = 60, size = 2.8, damp = 0.3, earlyDiff = 0.42,
        low = 0.84, mid = 0.71, high = 0.0,
        lowCut = 2450, highCut = 1024, modFreq = 0.1, modDepth = 4.6)
    }
    // tail modulation
    play {
      val src = Splay.ar(Impulse.ar(Seq(1, 3, 5, 7, 9)))
      val time = LFSaw.ar(0.02).linExp(-1, 1, 0.02, 60)
      JPverb.ar(
        inL = src.left, inR = src.right, revTime = time, size = 1.0, damp = 0.3, earlyDiff = 0.0,
        low = 1, mid = 0, high = 1,
        lowCut = 2450, highCut = 1024, modDepth = 0)
    }

    This is a third-party UGen (DEINDUGens).

    See also

    FreeVerb2

    GVerb

    Greyhole

  191. object K2A extends ProductReader[K2A] with Serializable

    A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation.

    A converter UGen that takes a control-rate input and produces an audio-rate output by means of linear interpolation. The current control input value is always reached in at the beginning of the subsequent control block. A special case is the initialization which begins directly at the first control input value (therefore, the first control block of the audio-rate output is is always constant.)

    For example, if the block size is 64, and the first three input values are -0.5, 0.6, 0.3, then the output signal will be 65 samples of value -0.5, followed by a linear ramp of 64 samples towards 0.6, followed by a linear ramp of 64 samples to towards 0.3.

    Examples
    // compare control and audio rate
    play {
      val a = K2A.ar(WhiteNoise.kr(0.3))
      val b =        WhiteNoise.ar(0.3)
      val c = LFPulse.ar(1, Seq(0, 0.5))
      c * Seq(a, b)
    }
    See also

    A2K

    T2A

    DC

  192. object KeyState extends ProductReader[KeyState] with Serializable

    A UGen that detects a specific keyboard stroke.

    A UGen that detects a specific keyboard stroke. When the given key is not pressed, the lo value is output, while the key is pressed the hi value is output. If lag is greater than zero, a Lag -type operation is applied for a smoother transition between lo and hi .

    Examples
    // determine codes
    play {
      val code = Phasor.kr(lo = 0, hi = 127)
      val k    = KeyState.kr(code, lag = 0)
      val x    = Gate.kr(code, k)
      val ch   = x sig_!= Delay1.kr(x)
      // when a code change is detected, print it
      x.poll(ch, "code")
      ()
    }
    // gate sound using the 'A' key
    play {
      // on Linux, key-code 38 denotes the 'A' key
      SinOsc.ar(800) * KeyState.kr(38, 0, 0.1)
    }
    See also

    MouseX

    MouseY

    MouseButton

  193. object KeyTrack extends ProductReader[KeyTrack] with Serializable

    A (12TET major/minor) key tracker UGen.

    A (12TET major/minor) key tracker UGen. It is based on a pitch class profile of energy across FFT bins and matching this to templates for major and minor scales in all transpositions. It assumes a 440 Hz concert A reference. Output is 0-11 C major to B major, 12-23 C minor to B minor.

  194. object Klang extends ProductReader[Klang] with Serializable
  195. object KlangSpec extends ProductReader[KlangSpec] with Serializable
  196. object Klank extends ProductReader[Klank] with Serializable

    Klank is a UGen of a bank of fixed frequency resonators which can be used to simulate the resonant modes of an object.

    Klank is a UGen of a bank of fixed frequency resonators which can be used to simulate the resonant modes of an object. Each mode is given a ring time, which is the time for the mode to decay by 60 dB.

    Note: Ringz and derived UGens Klank and Formlet produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.

    See also

    Klang

    Ringz

  197. object Kuramoto extends ProductReader[Kuramoto] with Serializable

    A UGen that implements the Kuramoto model of synchronization of coupled oscillators.

    A UGen that implements the Kuramoto model of synchronization of coupled oscillators.

    Examples
    // mouse-x controls coupling
    play {
      val n = 10
      val phases = Kuramoto.ar(
        mode = 0,
        initPhase   = Seq.fill(n)(Rand(0.0, 3.14159)),
        incr        = Seq.fill(n)(Rand(0.02, 0.08)),
        intCoupling = Lag2.ar(MouseX.kr(1.0e-4, 1.0e-1, warp = 1), 0.1)
    	)
    	SplayAz.ar(2, SinOsc.ar(0, phases)) * 0.1
    }
    See also

    Hopf

  198. object LFClipNoise extends ProductReader[LFClipNoise] with Serializable

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument. The difference to LFClipNoise is that this UGen quantizes time to the nearest integer division of the sample-rate, and the frequency input is only polled at the moment a new output value is scheduled.

    Examples
    // generator
    play { LFClipNoise.ar(500) * 0.2 }
    // random panning
    play {
      val pos = LFClipNoise.ar(4)
      Pan2.ar(PinkNoise.ar, pos)
    }
    // modulate frequency
    play { LFClipNoise.ar(XLine.kr(100, 10000, 20)) * 0.2 }
    See also

    ClipNoise

    LFNoise0

    LFDClipNoise

  199. object LFCub extends ProductReader[LFCub] with Serializable

    A sine-like oscillator UGen with a shape made of two cubic pieces.

    A sine-like oscillator UGen with a shape made of two cubic pieces. It is smoother than LFPar .

    Examples
    // modulating frequency
    play { LFPar.ar(XLine.kr(100, 20000, 10)) * 0.1 }
    // modulating amplitude
    play { LFPar.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
    // used as both oscillator and LFO
    play { LFPar.ar(LFPar.kr(LFPar.kr(0.2).mulAdd(8,10)).mulAdd(400,800)) * 0.1 }
    See also

    LFPar

  200. object LFDClipNoise extends ProductReader[LFDClipNoise] with Serializable

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument.

    A UGen that randomly generates the values -1 or +1 at a rate given by the nearest integer division of the sample rate by the frequency argument. The difference to LFClipNoise is that this UGen does not quantize time and recovers fast from frequency input changes.

    Examples
    // generator
    play { LFDClipNoise.ar(500) * 0.2 }
    // random panning
    play {
      val pos = LFDClipNoise.ar(4)
      Pan2.ar(PinkNoise.ar, pos)
    }
    // modulate frequency
    play { LFDClipNoise.ar(XLine.kr(100, 10000, 20)) * 0.2 }
    See also

    LFClipNoise

    LFNoise0

    LFNoise1

    CoinGate

    Schmidt

    GrayNoise

  201. object LFDNoise0 extends ProductReader[LFDNoise0] with Serializable

    A dynamic step noise UGen.

    A dynamic step noise UGen. Like LFNoise0 , it generates abruptly changing random values between -1 and +1 at a rate given by the freq argument, with two differences: There is no time quantization, and it there is fast recovery from low freq values.

    In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.

    If very high or very low frequencies are not needed, or fixed frequencies are used, LFNoise0 is more efficient.

    See also

    LFNoise0

    LFDNoise1

    LFDNoise3

    TRand

  202. object LFDNoise1 extends ProductReader[LFDNoise1] with Serializable

    A dynamic ramp noise UGen.

    A dynamic ramp noise UGen. Like LFNoise1 , it generates linearly interpolated random values between -1 and +1 at a rate given by the freq argument, with two differences: There is no time quantization, and it there is fast recovery from low freq values.

    In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.

    If very high or very low frequencies are not needed, or fixed frequencies are used, LFNoise1 is more efficient.

    See also

    LFNoise1

    LFDNoise0

    LFDNoise3

    Ramp

  203. object LFDNoise3 extends ProductReader[LFDNoise3] with Serializable

    A dynamic ramp noise UGen.

    A dynamic ramp noise UGen. It is similar to LFNoise2 , with three differences: It uses cubic instead of quadratic interpolation for the random values between -1 and +1 at a rate given by the freq argument. There is no time quantization, and it there is fast recovery from low freq values.

    In contrast, LFNoise0 , LFNoise1 , and LFNoise2 quantize to the nearest integer division of the sample rate, and they poll the freq argument only when scheduled, and thus seem to hang when the frequencies get very low.

    Examples
    // compare dynamic and non-dynamic
    play {
      val r    = MouseX.kr(0.1, 1000, 1)
      val a    = LFNoise2 .ar(r)
      val b    = LFDNoise3.ar(r)
      val freq = Select.ar(MouseButton.kr(lag = 0), Seq(a, b))
      SinOsc.ar(freq.mulAdd(200, 500)) * 0.2
    }
    See also

    LFNoise2

    LFDNoise0

    LFDNoise1

  204. object LFGauss extends ProductReader[LFGauss] with Serializable

    A non-band-limited gaussian function oscillator UGen.

    A non-band-limited gaussian function oscillator UGen. Output ranges from minVal to 1. It implements the formula:

    f(x) = exp((x - phase).squared / (-2 * width.squared))

    where x is to vary in the range -1 to 1 over the period dur . minVal is the initial value at -1. E.g. for default parameters, it is exp(-50) or roughly zero.

    Examples
    // dur and width can be modulated at audio rate
    play {
      val dur = SinOsc.ar(MouseX.kr(2, 1000, 1) * Seq(1.0, 1.1)).linLin(-1, 1, 0.0006, 0.01)
      val width = SinOsc.ar(Seq(0.5, 0.55)).linLin(-1, 1, 0.01, 0.3)
      LFGauss.ar(dur, width) * 0.2
    }
    // several frequencies and widths combined
    play {
      val x    = MouseX.kr(1, 0.07, 1)
      val y    = MouseY.kr(1, 3)
      val mod  = LFGauss.ar(x, (-1 to -6 by -1).map(i => y.pow(i)))
      val carr = SinOsc.ar((0 to 5).map(i => 200 * 1.3.pow(i)))
      Mix(carr * mod) * 0.1
    }
    // test spectrum
    play {
      val son = LeakDC.ar(LFGauss.ar(0.005, 0.2))
      BPF.ar(son * 3, MouseX.kr(60, 2000, 1), 0.05)
    }
  205. object LFNoise0 extends ProductReader[LFNoise0] with Serializable

    A step noise UGen.

    A step noise UGen. It generates abruptly changing random values between -1 and +1 at a rate given by the freq argument.

    The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant LFDNoise0 has precise frequency and reacts to frequency changes instantly.

    Examples
    // plain noise
    play { LFNoise0.ar(1000) * 0.25 }
    See also

    LFDNoise0

    LFNoise1

    LFNoise2

    TRand

    WhiteNoise

    Dust

    RandSeed

  206. object LFNoise1 extends ProductReader[LFNoise1] with Serializable

    A ramp noise UGen.

    A ramp noise UGen. It generates line segments whose start and end points are chosen randomly between -1 and +1 . New breakpoints are generated at a specified frequency.

    The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant LFDNoise1 has precise frequency and reacts to frequency changes instantly.

    Examples
    // plain noise
    play { LFNoise1.ar(1000) * 0.25 }
    See also

    LFDNoise1

    LFNoise0

    LFNoise2

    Ramp

  207. object LFNoise2 extends ProductReader[LFNoise2] with Serializable

    A quadratically interpolating noise UGen.

    A quadratically interpolating noise UGen. This interpolation happens between breakpoints chosen randomly between -1 and +1 at a specified frequency.

    The frequency is quantized to the nearest integer division of the sample rate, and changes in frequency are only picked up at the next trigger. In contrast, variant LFDNoise3 has precise frequency and reacts to frequency changes instantly.

    Note: Due to the interpolation, the output values can occasionally extend beyond the normal range of -1 to +1, if the frequency varies in certain ways.

    Examples
    // plain noise
    play { LFNoise2.ar(1000) * 0.25 }
    See also

    LFDNoise3

    LFNoise0

    LFNoise1

  208. object LFPar extends ProductReader[LFPar] with Serializable

    A sine-like oscillator UGen with a shape made of two parabolas.

    A sine-like oscillator UGen with a shape made of two parabolas. It has audible odd harmonics and is non-band-limited. Its output ranges from -1 to +1.

    Examples
    // modulating frequency
    play { LFPar.ar(XLine.kr(100, 20000, 10)) * 0.1 }
    // modulating amplitude
    play { LFPar.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
    // used as both oscillator and LFO
    play { LFPar.ar(LFPar.kr(LFPar.kr(0.2).mulAdd(8,10)).mulAdd(400,800)) * 0.1 }
    See also

    LFCub

  209. object LFPulse extends ProductReader[LFPulse] with Serializable

    A non-band-limited pulse oscillator UGen.

    A non-band-limited pulse oscillator UGen. Outputs a high value of one and a low value of zero.

    Examples
    // modulating frequency
    play { LFPulse.ar(XLine.kr(1, 200, 10), 0, 0.2) * 0.1 }
    // modulating amplitude
    play { LFPulse.kr(XLine.kr(1, 200, 10), 0, 0.2) * SinOsc.ar(440) * 0.1 }
    // used as both oscillator and LFO
    play { LFPulse.ar(LFPulse.kr(3, 0, 0.3).mulAdd(200, 200), 0, 0.2) * 0.1 }
    See also

    Pulse

  210. object LFSaw extends ProductReader[LFSaw] with Serializable

    A sawtooth oscillator UGen.

    A sawtooth oscillator UGen. The oscillator is creating an aliased sawtooth, that is it does not use band-limiting. For a band-limited version use Saw instead. The signal range is -1 to +1.

    Examples
    // modulating frequency
    play { LFSaw.ar(XLine.kr(1, 200, 10)) * 0.1 }
    // modulating amplitude
    play { LFSaw.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
    // neuer deutscher Sägezahn
    play { LFSaw.ar(LFSaw.kr(3).mulAdd(200, 200)) * 0.1 }
    See also

    Saw

  211. object LFTri extends ProductReader[LFTri] with Serializable

    A triangle oscillator UGen designed for low frequency control signals (being non-band-limited).

    A triangle oscillator UGen designed for low frequency control signals (being non-band-limited). The output varies from -1 to 1.

    With an initial phase of zero, the oscillator begins at 0, rises to 1, then falls to -1 and goes back to zero after one complete phase. With an initial phase of 1 (corresponding to 90 degrees), the oscillator begins at 1 and then falls to -1. With an initial phase of 3 (or 270 degrees), the oscillator begins at -1 and then rises to 1.

    Examples
    // modulating frequency
    play { LFTri.ar(XLine.kr(100, 20000, 10)) * 0.1 }
    // modulating amplitude
    play { LFTri.kr(XLine.kr(1, 200, 10)) * SinOsc.ar(440) * 0.1 }
    // used as both oscillator and LFO
    play { LFTri.ar(LFTri.kr(LFTri.kr(0.2).mulAdd(8,10)).mulAdd(400,800)) * 0.1 }
  212. object LPF extends ProductReader[LPF] with Serializable

    A second order low pass filter UGen.

    A second order low pass filter UGen.

    Examples
    // modulated frequency
    play {
      val in   = Saw.ar(200) * 0.5
      val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(3600, 4000)
      LPF.ar(in, freq)
    }
    // mouse controlled frequency
    play {
      val in   = WhiteNoise.ar(0.5)
      val freq = MouseX.kr(200, 10000, 1)
      LPF.ar(in, freq)
    }
    See also

    HPF

    BPF

    BRF

    RLPF

    LPZ1

  213. object LPZ1 extends ProductReader[LPZ1] with Serializable

    two point average filter UGen.

    two point average filter UGen. Implements the formula :

    out(i) = 0.5 * (in(i) + in(i-1))
    Examples
    // engage with mouse button
    play {
      val sig = WhiteNoise.ar(0.5)
      val flt = LPZ1.ar(sig)
      LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
    }
    See also

    OnePole

    HPZ1

    LPZ2

    Integrator

    Delay1

  214. object LPZ2 extends ProductReader[LPZ2] with Serializable

    three point average filter UGen.

    three point average filter UGen. Implements the formula :

    out(i) = 0.25 * (in(i) + 2 * in(i-1) + in(i-2))
    Examples
    // engage with mouse button
    play {
      val sig = WhiteNoise.ar(0.5)
      val flt = LPZ2.ar(sig)
      LinXFade2.ar(sig, flt, MouseButton.kr(-1, 1))
    }
    See also

    LPZ1

    HPZ2

    BPZ2

    BRZ2

  215. object Lag extends ProductReader[Lag] with Serializable

    An exponential lag UGen.

    An exponential lag UGen. This is essentially the same as OnePole except that instead of supplying the coefficient directly, it is calculated from a 60 dB lag time. This is the time required for the filter to converge to within 0.01 % of a value. This is useful for smoothing out control signals.

    See also

    OnePole

    LagUD

    Lag2

    Ramp

  216. object Lag2 extends ProductReader[Lag2] with Serializable

    A cascaded exponential lag UGen.

    A cascaded exponential lag UGen. Lag2.kr(in, time) is equivalent to Lag.kr(Lag.kr(in, time), time) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factor once instead of twice.

    See also

    Lag

    Lag2UD

    Lag3

  217. object Lag2UD extends ProductReader[Lag2UD] with Serializable

    A cascaded exponential lag UGen with separate inputs for up and down slope.

    A cascaded exponential lag UGen with separate inputs for up and down slope. Lag2UD.kr(in, up, down) is equivalent to LagUD.kr(LagUD.kr(in, up, down), up, down) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factors once instead of twice.

    See also

    LagUD

    Lag2

    Lag3UD

  218. object Lag3 extends ProductReader[Lag3] with Serializable

    A cascaded exponential lag UGen.

    A cascaded exponential lag UGen. Lag3.kr(in, time) is equivalent to Lag.kr(Lag.kr(Lag.kr(Lag.kr(in, time), time), time) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factor once instead of three times.

    See also

    Lag

    Lag3UD

    Lag2

  219. object Lag3UD extends ProductReader[Lag3UD] with Serializable

    A cascaded exponential lag UGen with separate inputs for up and down slope.

    A cascaded exponential lag UGen with separate inputs for up and down slope. Lag3UD.kr(in, up, down) is equivalent to LagUD.kr(LagUD.kr(LagUD.kr(in, up, down), up, down), up, down) , thus resulting in a smoother transition. This saves on CPU as you only have to calculate the decay factors once instead of three times.

    See also

    LagUD

    Lag3

    Lag2UD

  220. object LagIn extends ProductReader[LagIn] with Serializable

    A UGen that reads a signal from a control bus and applies a lag filter to it.

    A UGen that reads a signal from a control bus and applies a lag filter to it. This is essentially the same as Lag.kr(In.kr(...), time) .

    Examples
    // portamento
    play {
      val c = Bus.control(s)
      c.set(30)   // initial midi-pitch
    
      play {
        val freq = LagIn.kr(c.index, time = 1).midiCps
        SinOsc.ar(freq) * AmpComp.kr(freq) * 0.1
      }
    
      c.set(70)
      c.set(100)
    }
    See also

    In

    Out

    Lag

  221. object LagUD extends ProductReader[LagUD] with Serializable

    An exponential lag UGen with separate inputs for up and down slope.

    An exponential lag UGen with separate inputs for up and down slope. This is essentially the same as Lag except that you can supply a different 60 dB time for when the signal goes up, from when the signal goes down.

    See also

    Lag

    Lag2UD

  222. object LastValue extends ProductReader[LastValue] with Serializable

    A sample-and-hold UGen that outputs the last value before the input changed more than a threshold.

    A sample-and-hold UGen that outputs the last value before the input changed more than a threshold. Change is based on the absolute of the differentiation of input signal.

    Examples
    // distortion
    play {
      val in     = SinOsc.ar(262)
      val thresh = MouseX.kr(1.0e-3, 2.0, 1, lag = 1)
      thresh.poll(5, "thresh")
      LeakDC.ar(LastValue.ar(in, thresh)) * 0.1
    }
    See also

    Slew

  223. object Latch extends ProductReader[Latch] with Serializable

    A sample-and-hold UGen.

    A sample-and-hold UGen. When triggered, a new value is taken from the input and hold until the next trigger occurs.

    Before the first trigger is registered, this UGen outputs zero.

    See also

    Gate

    Demand

  224. object LatoocarfianC extends ProductReader[LatoocarfianC] with Serializable

    A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.

    A cubic-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:

    x[n+1] = sin(b * y[n]) + c * sin(b * x[n])
    y[n+1] = sin(a * y[n]) + d * sin(a * x[n])

    According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.

    Examples
    // default initial parameters
    play { LatoocarfianC.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // randomly modulate all parameters
    play {
      LatoocarfianC.ar(
        SampleRate.ir/4,
        LFNoise2.kr(2).mulAdd(1.5, 1.5),
        LFNoise2.kr(2).mulAdd(1.5, 1.5),
        LFNoise2.kr(2).mulAdd(0.5, 1.5),
        LFNoise2.kr(2).mulAdd(0.5, 1.5)
      ) * 0.2
    }
    See also

    LatoocarfianN

    LatoocarfianL

  225. object LatoocarfianL extends ProductReader[LatoocarfianL] with Serializable

    A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.

    A linear-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:

    x[n+1] = sin(b * y[n]) + c * sin(b * x[n])
    y[n+1] = sin(a * y[n]) + d * sin(a * x[n])

    According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.

    Examples
    // default initial parameters
    play { LatoocarfianL.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // randomly modulate all parameters
    play {
      LatoocarfianL.ar(
        SampleRate.ir/4,
        LFNoise2.kr(2).mulAdd(1.5, 1.5),
        LFNoise2.kr(2).mulAdd(1.5, 1.5),
        LFNoise2.kr(2).mulAdd(0.5, 1.5),
        LFNoise2.kr(2).mulAdd(0.5, 1.5)
      ) * 0.2
    }
    See also

    LatoocarfianN

    LatoocarfianC

  226. object LatoocarfianN extends ProductReader[LatoocarfianN] with Serializable

    A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26.

    A non-interpolating sound generator based on a function given in Clifford Pickover's book Chaos In Wonderland, pg 26. The function is:

    x[n+1] = sin(b * y[n]) + c * sin(b * x[n])
    y[n+1] = sin(a * y[n]) + d * sin(a * x[n])

    According to Pickover, parameters a and b should be in the range from -3 to +3, and parameters c and d should be in the range from 0.5 to 1.5. The function can, depending on the parameters given, give continuous chaotic output, converge to a single value (silence) or oscillate in a cycle (tone). NOTE: This UGen is experimental and not optimized currently, so is rather hoggish of CPU.

    Examples
    // default initial parameters
    play { LatoocarfianN.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // randomly modulate all parameters
    play {
      LatoocarfianN.ar(
        SampleRate.ir/4,
        LFNoise2.kr(2).mulAdd(1.5, 1.5),
        LFNoise2.kr(2).mulAdd(1.5, 1.5),
        LFNoise2.kr(2).mulAdd(0.5, 1.5),
        LFNoise2.kr(2).mulAdd(0.5, 1.5)
      ) * 0.2
    }
    See also

    LatoocarfianL

    LatoocarfianC

  227. object LeakDC extends ProductReader[LeakDC] with Serializable

    A filter UGen to remove very low frequency content DC offset.

    A filter UGen to remove very low frequency content DC offset.

    This is a one-pole highpass filter implementing the formula

    y[n] = x[n] - x[n-1] + coeff * y[n-1]
    Examples
    // show DC with mouse-controlled coefficient
    play {
      val freq = 800
      val in   = LFPulse.ar(freq).mulAdd(0.5, 0.5)
      val coef = MouseX.kr(0.9, 0.999)
      val flt  = LeakDC.ar(in, coef)
      val dc   = RunningSum.ar(flt, SampleRate.ir/freq)
      coef.poll(2)
      dc  .poll(2)
      0
    }
    See also

    DC

  228. object LeastChange extends ProductReader[LeastChange] with Serializable

    A UGen that switches between two input signal depending on which is changing less.

    A UGen that switches between two input signal depending on which is changing less. Change is based on the absolute of the differentiation of the respective signals.

    Examples
    // mouse-x versus mouse-y
    play {
      val x   = MouseX.kr(lag = 1)
      val y   = MouseY.kr(lag = 1)
      val c   = LeastChange.kr(x, y)
      val isX = c sig_== x
      val isY = 1 - isX
      // if X change weaker, modulate pan position
      val p   = LFTri.ar(c * 10 * isX)
      // if Y change weaker, modulate sine frequency
      val f   = LFTri.ar(c * 10 * isY).linExp(-1, 1, 100, 4000)
      // report current state
      c.poll(5, "c")
      x.poll(isX, "now X")
      y.poll(isY, "now Y")
      Pan2.ar(SinOsc.ar(f) * 0.1, p)
    }
    See also

    MostChange

  229. object Limiter extends ProductReader[Limiter] with Serializable

    Limits the input amplitude to the given level.

    Limits the input amplitude to the given level. Unlike Compander , this UGen will never overshoot, but it needs to look ahead in the input signal, introducing a delay in its output. The delay time is equal to twice the value of the dur parameter (the buffer internally used).

    Examples
    // compare dry and wet
    play {
      val in = Decay2.ar(
        Impulse.ar(8, phase = LFSaw.kr(0.25) * 0.7),
        attack = 0.001, release = 0.3) * FSinOsc.ar(500)
      val flt = Limiter.ar(in, level = 0.4)
      LinXFade2.ar(in, flt, MouseButton.kr(-1, 1))
    }
    See also

    Normalizer

    Compander

  230. object LinCongC extends ProductReader[LinCongC] with Serializable

    A cubic-interpolating sound generator based on the difference equation:

    A cubic-interpolating sound generator based on the difference equation:

    x[n+1] = (a * x[n] + c) % m

    The output signal is automatically scaled to a range of [-1, 1].

    Examples
    // default initial parameters
    play { LinCongC.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // randomly modulate parameters
    play {
      LinCongC.ar(
        LFNoise2.kr(1.0).mulAdd(1e4, 1e4),
        LFNoise2.kr(0.1).mulAdd(0.5, 1.4),
        LFNoise2.kr(0.1).mulAdd(0.1, 0.1),
        LFNoise2.kr(0.1)
      ) * 0.2
    }
    // as frequency control
    play {
      SinOsc.ar(
        LinCongC.ar(
          40,
          LFNoise2.kr(0.1).mulAdd(0.1, 1),
          LFNoise2.kr(0.1).mulAdd(0.1, 0.1),
          LFNoise2.kr(0.1)
        ).mulAdd(500, 600)
      ) * 0.4
    }
    See also

    LinCongN

    LinCongL

  231. object LinCongL extends ProductReader[LinCongL] with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+1] = (a * x[n] + c) % m

    The output signal is automatically scaled to a range of [-1, 1].

    Examples
    // default initial parameters
    play { LinCongL.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // randomly modulate parameters
    play {
      LinCongL.ar(
        LFNoise2.kr(1.0).mulAdd(1e4, 1e4),
        LFNoise2.kr(0.1).mulAdd(0.5, 1.4),
        LFNoise2.kr(0.1).mulAdd(0.1, 0.1),
        LFNoise2.kr(0.1)
      ) * 0.2
    }
    // as frequency control
    play {
      SinOsc.ar(
        LinCongL.ar(
          40,
          LFNoise2.kr(0.1).mulAdd(0.1, 1),
          LFNoise2.kr(0.1).mulAdd(0.1, 0.1),
          LFNoise2.kr(0.1)
        ).mulAdd(500, 600)
      ) * 0.4
    }
    See also

    LinCongN

    LinCongC

  232. object LinCongN extends ProductReader[LinCongN] with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+1] = (a * x[n] + c) % m

    The output signal is automatically scaled to a range of [-1, 1].

    Examples
    // default initial parameters
    play { LinCongN.ar(MouseX.kr(20, SampleRate.ir)) * 0.2 }
    // randomly modulate parameters
    play {
      LinCongN.ar(
        LFNoise2.kr(1.0).mulAdd(1e4, 1e4),
        LFNoise2.kr(0.1).mulAdd(0.5, 1.4),
        LFNoise2.kr(0.1).mulAdd(0.1, 0.1),
        LFNoise2.kr(0.1)
      ) * 0.2
    }
    // as frequency control
    play {
      SinOsc.ar(
        LinCongN.ar(
          40,
          LFNoise2.kr(0.1).mulAdd(0.1, 1),
          LFNoise2.kr(0.1).mulAdd(0.1, 0.1),
          LFNoise2.kr(0.1)
        ).mulAdd(500, 600)
      ) * 0.4
    }
    See also

    LinCongL

    LinCongC

  233. object LinExp extends ProductReader[LinExp] with Serializable

    A UGen which maps a linear range to an exponential range.

    A UGen which maps a linear range to an exponential range. The equivalent formula is (dstHi / dstLo).pow((in - srcLo) / (srcHi - srcLo)) * dstLo .

    Note: No clipping is performed. If the input signal exceeds the input range, the output will also exceed its range.

    Examples
    // translate linear noise into exponential frequencies
    play {
      val mod = LFNoise2.ar(10)
      val lo  = MouseX.kr(200, 8000, 1)
      val hi  = MouseY.kr(200, 8000, 1)
      SinOsc.ar(LinExp.ar(mod, -1, 1, lo, hi)) * 0.1
    }
    See also

    LinExp

    Clip

  234. object LinLin extends ProductReader[LinLin] with Serializable
  235. object LinPan2 extends ProductReader[LinPan2] with Serializable

    A stereo panorama UGen based on linear amplitude control.

    A stereo panorama UGen based on linear amplitude control. When in center position ( pos = 0 ), the signal is attenuated by 0.5 or approx. -6 dB.

    Examples
    // periodic left-right oscillation
    play { LinPan2.ar(PinkNoise.ar(0.4), SinOsc.kr(0.25), 0.3) }
    See also

    Pan2

    PanAz

    Balance2

    LinXFade2

  236. object LinRand extends ProductReader[LinRand] with Serializable

    A scalar UGen that generates a single random decimal value between lo and hi with a selectable skew towards either end.

    A scalar UGen that generates a single random decimal value between lo and hi with a selectable skew towards either end.

    The minMax <= 0 behaves rather odd: If minMax is less than 1, the distribution is skewed towards lo (with lo = 0 and hi = 1 , the mean is approx. 0.33). If minMax is greater than or equal to 1, the distribution is skewed towards hi (with lo = 0 and hi = 1 , the mean is approx 0.66).

    Examples
    // two clusters with opposite skew
    play {
      val z: GE = 0 to 1 map { n =>
        Mix.fill(10)(FSinOsc.ar(LinRand(200, 800, n))) * SinOsc.ar(0.4, n * math.Pi).max(0)
      }
      z * 0.025
    }
    See also

    Rand

    ExpRand

    NRand

    RandSeed

  237. object LinXFade2 extends ProductReader[LinXFade2] with Serializable

    An linear two channel cross fading UGen.

    An linear two channel cross fading UGen. In center position ( pan = 0 ), both input signals are attenuated by 0.5 or approx. -6 dB.

    See also

    LinXFade2

    LinPan2

    XOut

  238. object Line extends ProductReader[Line] with Serializable

    A line generator UGen that moves from a start value to the end value in a given duration.

    A line generator UGen that moves from a start value to the end value in a given duration.

    Warning: Durations greater than around 2.8e6 seconds cause the UGen to misbehave and jump to the end value directly.

    Examples
    // pan from left to right
    play { Pan2.ar(PinkNoise.ar(0.3), Line.kr(-1, 1, 10, freeSelf)) }
    See also

    XLine

    EnvGen

    Ramp

  239. object Linen extends ProductReader[Linen] with Serializable

    A linear ASR-type envelope generator UGen.

    A linear ASR-type envelope generator UGen.

    Examples
    // repeated trigger
    play {
      val gen = Linen.kr(Impulse.kr(2), 0.01, 0.6, 1.0)
      SinOsc.ar(440) * gen * 0.1
    }
    // play once and end the synth
    play {
      val gen = Linen.kr(Impulse.kr(0), 0.01, 0.6, 1.0, doneAction = freeSelf)
      SinOsc.ar(440) * gen * 0.1
    }
    // play once and sustain
    val x = play {
      val gen = Linen.kr("gate".kr(1), 0.01, 0.6, 1.0, doneAction = freeSelf)
      SinOsc.ar(440) * gen * 0.1
    }
    
    x.release(4)    // release envelope with given duration
    // longer gate to sustain for a given duration
    play {
      val gate = Trig.kr(1, dur = 2)
      val gen = Linen.kr(gate, 0.01, 0.6, 1.0, doneAction = freeSelf)
      SinOsc.ar(440) * gen * 0.1
    }
    See also

    EnvGen

  240. object ListTrig extends ProductReader[ListTrig] with Serializable

    A UGen that produces a scheduled sequences of trigger impulses.

    A UGen that produces a scheduled sequences of trigger impulses. Trigger times are provided as a list (buffer) of absolute offsets from time zero. A trigger is output as a single control period of value 1 , after which output returns to zero.

    Examples
    // trigger grains
    val b = Buffer(s)
    b.alloc(10)
    b.setData(Vector(1, 2, 3, 5, 8, 13, 21, 34, 55, 89).map(_ * 0.1f)) // quasi Fibonacci
    
    val x = play {
      val reset = "reset".tr
      val tr  = ListTrig.kr(b.id, BufFrames.kr(b.id), reset)
      Timer.kr(tr).poll(tr, "timer")
      val env = EnvGen.ar(Env.perc(0.01, 0.1), gate = tr)
      SinOsc.ar(Seq(440, 460)) * env * 0.2
    }
    
    x.set("reset" -> 1)  // start anew
    x.free(); b.free()

    This is a third-party UGen (MCLDUGens).

    Note

    The argument order is different from its sclang counterpart.

    See also

    ListTrig2

    Logger

    DemandEnvGen

    Dbufrd

    Timer

  241. object ListTrig2 extends ProductReader[ListTrig2] with Serializable

    A UGen that produces a scheduled sequences of trigger impulses.

    A UGen that produces a scheduled sequences of trigger impulses. Trigger times are provided as a list (buffer) of relative durations between consecutive events. A trigger is output as a single control period of value 1 , after which output returns to zero.

    Examples
    // trigger grains
    val b = Buffer(s)
    b.alloc(11)
    b.setData(Vector(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89).map(_ * 0.1f)) // Fibonacci
    
    val x = play {
      val reset = "reset".tr
      val tr  = ListTrig2.kr(b.id, BufFrames.kr(b.id), reset)
      Timer.kr(tr).poll(tr, "timer")
      val env = EnvGen.ar(Env.perc(0.01, 0.1), gate = tr)
      SinOsc.ar(Seq(440, 460)) * env * 0.2
    }
    
    x.set("reset" -> 1)  // start anew
    x.free(); b.free()

    This is a third-party UGen (MCLDUGens).

    Note

    The argument order is different from its sclang counterpart.

    See also

    ListTrig

    Logger

    DemandEnvGen

    Dbufrd

    ListTrig2

  242. object LocalBuf extends ProductReader[LocalBuf] with Serializable

    A UGen that allocates a buffer local to the synth.

    A UGen that allocates a buffer local to the synth. This is convenient for example when using an FFT chain.

    See also

    de.sciss.synth.ugen.FFT

  243. object LocalIn extends ProductReader[LocalIn] with Serializable

    A UGen that reads buses that are local to the enclosing synth.

    A UGen that reads buses that are local to the enclosing synth. These buses should be written using a LocalOut ugen. They behave like regular buses, but are more convenient for the implementation of a self contained effect that uses a feedback processing loop.

    In a synth, there can be only each one control-rate and audio-rate LocalIn / LocalOut pair. The signal written to a LocalOut will not be read by the LocalIn until the next control block cycle, introducing a delay of ControlDur .

    Warning: The argument has been changed numChannels: Int in version 1.15.3 to init: GE in version 1.16.0. The previous version was incompatible with SuperCollider 3.6.x. A previous usage such as LocalIn.ar(2) to create two channels must now be expressed as LocalIn.ar(Seq(0, 0)) !

    Examples
    // ping-pong delay with feedback
    play {
      val src = Decay.ar(Impulse.ar(0.3), 0.1) * WhiteNoise.ar(0.2)
      val in  = LocalIn.ar(Seq(0, 0)) + Seq[GE](src, 0) // read feedback, add source to left chan
      val dly = DelayN.ar(in, 0.2, 0.2)         // delay sound
      val att = dly * 0.8                       // apply decay factor
    
      // reverse channels to give ping pong effect
      LocalOut.ar(Seq(att.out(1), dly.out(0)))
      dly
    }
    // tank
    play {
      val tones = Mix.fill(12) {
        Pan2.ar(
          Decay2.ar(Dust.ar(0.05), 0.1, 0.5) * 0.1 *
            FSinOsc.ar(IRand(36,84).midiCps).cubed.max(0),
          Rand(-1,1))
      }
      val gen = tones + Pan2.ar(Decay2.ar(Dust.ar(0.03), 0.04, 0.3) * BrownNoise.ar, 0)
    
      val verb = Mix.fold(gen, 4) { z =>
        AllpassN.ar(z, 0.03, Seq.fill(2)(Rand(0.005,0.02)), 1)
      }
    
      val in  = LocalIn.ar(Seq(0, 0)) * 0.98
      val flt = OnePole.ar(in, 0.5)
    
      val pan = Rotate2.ar(flt.out(0), flt.out(1), 0.23)
      val v1  = AllpassN.ar(pan, 0.05, Seq.fill(2)(Rand(0.01,0.05)), 2)
      val v2  = DelayN.ar(v1, 0.3, Seq(0.19,0.26))
      val v3  = AllpassN.ar(v2 , 0.05, Seq.fill(2)(Rand(0.03,0.15)), 2)
      val out = LeakDC.ar(v3)
      val sig = gen + out
    
      LocalOut.ar(sig)
      sig
    }
    // resonator
    play {
      val imp  = Impulse.ar
      val in   = LocalIn.ar
      val feed = imp + in * 0.995
      // must subtract block-size for correct tuning
      // (try removing the ControlDur to here the pitch change)
      val time = 440.reciprocal - ControlDur.ir
      val dly  = DelayC.ar(feed, time, time)
      LocalOut.ar(dly)
    
      // alternate between feedback and reference pitch
      val comp = Seq(dly, SinOsc.ar(440) * 0.2): GE
      comp * LFPulse.kr(1, Seq(0.0, 0.5))
    }
    See also

    LocalOut

    InFeedback

    ControlDur

  244. object LocalOut extends ProductReader[LocalOut] with Serializable

    A UGen that writes to buses that are local to the enclosing synth.

    A UGen that writes to buses that are local to the enclosing synth. These buses should have been defined by a LocalIn ugen. These behave like regular buses, but are more convenient for the implementation of a self contained effect that uses a feedback processing loop.

    In a synth, there can be only each one control-rate and audio-rate LocalIn / LocalOut pair. The signal written to a LocalOut will not be read by the LocalIn until the next control block cycle, introducing a delay of ControlDur .

    For more examples, see LocalIn.

    Examples
    // ping-pong delay with feedback
    play {
      val src = Decay.ar(Impulse.ar(0.3), 0.1) * WhiteNoise.ar(0.2)
      val in  = LocalIn.ar(Seq(0, 0)) + Seq[GE](src, 0) // read feedback, add source to left chan
      val dly = DelayN.ar(in, 0.2, 0.2)         // delay sound
      val att = dly * 0.8                       // apply decay factor
    
      // reverse channels to give ping pong effect
      LocalOut.ar(Seq(att.out(1), dly.out(0)))
      dly
    }
    See also

    LocalIn

    Out

    ControlDur

  245. object Logger extends ProductReader[Logger] with Serializable

    A UGen to store values in a buffer upon receiving a trigger.

    A UGen to store values in a buffer upon receiving a trigger. When a trigger happens, the current input values are sampled and stored as the next consecutive frame of the buffer.

    Storage starts at the buffer beginning and increments the write position until the buffer is full. While the buffer is not yet full, the UGen outputs 1 , then it outputs 0 . The buffer position can be reset using the reset input.

    Note that the UGen zeroes the buffer upon first instantiation, to ensure that out-of-date data is not confused with new data.

    Examples
    // fill buffer and plot on client side
    val b = Buffer(s)
    b.alloc(100)
    
    val x = play {
      val z = LFCub.kr(10) * EnvGen.kr(Env.linen(1, 2, 1), doneAction = freeSelf)
      Logger.kr(b.id, z, Impulse.kr(49), reset = 0)
    }
    
    // after synth has completed:
    b.getData(num = 100).foreach(_.plot())
    
    x.free(); b.free()

    This is a third-party UGen (MCLDUGens).

    Note

    The argument order is different from its sclang counterpart.

    See also

    ListTrig

  246. object Logistic extends ProductReader[Logistic] with Serializable

    A noise generator UGen based on the logistic map.

    A noise generator UGen based on the logistic map. Its formula is

    y[n+1] = chaos * y[n] * (1.0 - y[n])
    Examples
    // increasing parameter
    play { Logistic.ar(Line.kr(3.55, 4.0, 15), 1000) * 0.5 }
    See also

    Crackle

    LatoocarfianN

  247. object LorenzL extends ProductReader[LorenzL] with Serializable

    A strange attractor discovered by Edward N.

    A strange attractor discovered by Edward N. Lorenz while studying mathematical models of the atmosphere. The system is composed of three ordinary differential equations:

    x' = s * (y - x)
    y' = x * (r - z) - y
    z' = x * y - b * z

    The time step amount h determines the rate at which the ODE is evaluated. Higher values will increase the rate, but cause more instability. A safe choice is the default amount of 0.05.

    Examples
    // vary frequency
    play { LorenzL.ar(MouseX.kr(20, SampleRate.ir)) * 0.3 }
    // randomly modulate parameters
    play {
      LorenzL.ar(
        SampleRate.ir,
        LFNoise0.kr(1).mulAdd(2, 10),
        LFNoise0.kr(1).mulAdd(20, 38),
        LFNoise0.kr(1).mulAdd(1.5, 2)
      ) * 0.2
    }
    // as a frequency control
    play { SinOsc.ar(Lag.ar(LorenzL.ar(MouseX.kr(1, 200)), 3e-3) * 800 + 900) * 0.4 }
  248. object Loudness extends ProductReader[Loudness] with Serializable

    A UGen for the extraction of instantaneous loudness.

    A UGen for the extraction of instantaneous loudness. A perceptual loudness function which outputs loudness in sones; this is a variant of an MP3 perceptual model, summing excitation in ERB bands. It models simple spectral and temporal masking, with equal loudness contour correction in ERB bands to obtain phons (relative dB), then a phon to sone transform. The final output is typically in the range of 0 to 64 sones, though higher values can occur with specific synthesised stimuli.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    Warning: the UGen is broken if FFT sizes other than the ones specified for chain are used.

  249. object MFCC extends ProductReader[MFCC] with Serializable

    A UGen for extracting mel frequency cepstral coefficients.

    A UGen for extracting mel frequency cepstral coefficients. It generates a set of MFCCs; these are obtained from a band-based frequency representation (using the Mel scale by default), and then a discrete cosine transform (DCT). The DCT is an efficient approximation for principal components analysis, so that it allows a compression, or reduction of dimensionality, of the data, in this case reducing 42 band readings to a smaller set of MFCCs. A small number of features (the coefficients) end up describing the spectrum. The MFCCs are commonly used as timbral descriptors.

    The output values are somewhat normalised for the range 0.0 to 1.0, but there are no guarantees on exact conformance to this. Commonly, the first coefficient will be the highest value. The number of output channels corresponds to the number of coefficients specified. Technical note: The 0th coefficient is not generated as it consists of multiplying all bands by 1 and summing

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

  250. object MantissaMask extends ProductReader[MantissaMask] with Serializable

    A UGen that masks off bits in the mantissa of the floating point sample value.

    A UGen that masks off bits in the mantissa of the floating point sample value. This introduces a quantization noise, but is less severe than linearly quantizing the signal.

    Examples
    // mouse-x controls resolution
    play {
      val bits = MouseX.kr(0, 12)
      MantissaMask.ar(SinOsc.ar(SinOsc.kr(0.2).mulAdd(400, 500)) * 0.4, bits)
    }
  251. object MdaPiano extends ProductReader[MdaPiano] with Serializable

    A piano synthesiser UGen.

    A piano synthesiser UGen. It is not polyphonic, but it can be retriggered to play notes in sequence.

    The original VST plugin by Paul Kellett was ported to SuperCollider by Dan Stowell. Most likely the arguments are in the normalized range 0 to 1.

    This is a third-party UGen (MdaUGens).

  252. object Median extends ProductReader[Median] with Serializable

    A filter UGen that calculates the median of a running window over its input signal.

    A filter UGen that calculates the median of a running window over its input signal. This non-linear filter can be used to reduce impulse noise from a signal.

    Examples
    // engage with mouse button
    play {
      val in  = Saw.ar(500) * 0.1 + Dust2.ar(100) * 0.9 // signal plus noise
      val flt = Median.ar(in, 3)
      LinXFade2.ar(in, flt, MouseButton.kr(-1, 1))
    }
    // long filter distorts by chopping off peaks in input
    play { Median.ar(SinOsc.ar(1000) * 0.2, 31) }
    Note

    The argument order is different from its sclang counterpart.

    See also

    LPF

    LeakDC

    RunningSum

  253. object MidEQ extends ProductReader[MidEQ] with Serializable

    A single band parametric equalizer UGen.

    A single band parametric equalizer UGen. It attenuates or boosts a frequency band.

    Examples
    // mouse controlled frequency and boost
    play {
      val in   = WhiteNoise.ar(0.25)
      val freq = MouseX.kr(200, 10000, 1)
      val gain = MouseY.kr(-12, 12) // bottom to top
      MidEQ.ar(in, freq, rq = 0.5, gain = gain)
    }
    See also

    BPF

    BRF

    HPF

    LPF

    Resonz

  254. object Mix extends ProductReader[Mix] with Serializable

    A graph element that mixes the channels of a signal together.

    A graph element that mixes the channels of a signal together. It works like the sclang counterpart.

    The Mix companion object contains various useful mixing idioms:

    - Mix.tabulate(n: Int)(fun: Int => GE): corresponds to Seq.tabulate and to Array.fill in sclang. - Mix.fill(n: Int)(thunk: => GE): corresponds to Seq.fill. - Mix.seq(elems: GE*): A shortcut for Mix(GESeq(elems: _*)).

    A separate graph element is Mix.mono. Mix.mono(elem: GE) flattens all channels of the input element before summing them, guaranteeing that the result is monophonic.

    Finally, Mix.fold is an idiom that not actually adds elements, but recursively folds them. Thus, Mix.fold(elem: GE, n: Int)(fun: GE => GE) is equivalent to

    (1 to n).foldLeft(elem) { (res, _) => fun(res) }

    Mix.fold is often used in the SuperCollider examples to apply a filtering process such as reverberation several times. For cases where the iteration index is needed, the full form as shown above can be used instead.

    Examples
    // non-nested multi-channel signal reduced to mono (1)
    play {
      Mix(SinOsc.ar(440 :: 660 :: Nil)) * 0.2 // --> SinOsc.ar(440) + SinOsc.ar(660)
    }
    // non-nested multi-channel signal reduced to mono (2)
    play {
      Mix(Pan2.ar(SinOsc.ar)) * 0.2 // --> left + right
    }
    // mix inner channels
    play {
      // --> [left(440) + left(660), right(440) + right(660)]
      Mix(Pan2.ar(SinOsc.ar(440 :: 660 :: Nil))) * 0.2
    }
    // enforce monophonic mix
    play {
      // --> left(440) + left(660) + right(440) + right(660)
      Mix.mono(Pan2.ar(SinOsc.ar(440 :: 660 :: Nil))) * 0.2
    }
    // combine Mix(), Mix.fill(), Mix.fold()
    // from original SC examples: reverberated sine percussion
    play {
      val d = 6    // number of percolators
      val c = 5    // number of comb delays
      val a = 4    // number of allpass delays
    
      // sine percolation sound :
      val s = Mix.fill(d) { Resonz.ar(Dust.ar(2.0 / d) * 50, Rand(200, 3200), 0.003) }
    
      // reverb pre-delay time :
      val z = DelayN.ar(s, 0.048)
    
      // 'c' length modulated comb delays in parallel :
      val y = Mix(CombL.ar(z, 0.1, LFNoise1.kr(Seq.fill(c)(Rand(0, 0.1))).madd(0.04, 0.05), 15))
    
      // chain of 'a' allpass delays on each of two channels (2 times 'a' total) :
      val x = Mix.fold(y, a) { in =>
        AllpassN.ar(in, 0.050, Seq(Rand(0, 0.050), Rand(0, 0.050)), 1)
      }
    
      // add original sound to reverb and play it :
      s + 0.2 * x
    }
    // Mix.tabulate usage
    // from original SC examples: harmonic swimming
    play {
      val f = 50       // fundamental frequency
      val p = 20       // number of partials per channel
      val offset = Line.kr(0, -0.02, 60, doneAction = freeSelf) // causes sound to separate and fade
      Mix.tabulate(p) { i =>
        FSinOsc.ar(f * (i+1)) * // freq of partial
          LFNoise1.kr(Seq(Rand(2, 10), Rand(2, 10)))  // amplitude rate
          .madd(
            0.02,     // amplitude scale
            offset    // amplitude offset
          ).max(0)    // clip negative amplitudes to zero
      }
    }
    See also

    Reduce

    BinaryOpUGen

  255. object ModDif extends ProductReader[ModDif] with Serializable

    A UGen that returns the minimum difference of two values in modulo arithmetics.

    A UGen that returns the minimum difference of two values in modulo arithmetics. On a circle, there are two distances between two points. This UGen returns the smaller value of the two.

    Examples
    // different moduli
    play {
      val sig = LFSaw.ar(10)
      val dist = ModDif.kr(sig, 0, MouseX.kr(0, 1.0/5) * (0 to 8))
      Splay.ar(SinOsc.ar(dist * 4000 + 400)) * 0.1
    }
    // wrapping amplitude cross-fade
    play {
      val numChan = 12
      val x    = SinOsc.ar(Seq.fill(numChan)(Rand(300.0, 800.0)))
      val dist = ModDif.kr(MouseX.kr(0, numChan * 2), 0 until numChan, numChan)
      val sig  = x * (1 - dist).max(0)
      Splay.ar(sig) * 0.2
    }
    See also

    Clip

    Wrap

  256. object MoogFF extends ProductReader[MoogFF] with Serializable

    A Moog VCF style UGen.

    A Moog VCF style UGen. This is a type of resonant low pass filter.

    The design of this filter is described in Federico Fontana, "Preserving the Digital Structure of the Moog VCF." In: Proceedings of the ICMC, Copenhagen 2007. Ported to SuperCollider by Dan Stowell.

    Examples
    // mouse controlled
    play {
      val in   = WhiteNoise.ar(01.1)
      val freq = MouseY.kr(100, 10000, 1)
      val gain = MouseX.kr(0, 4)
      Limiter.ar(MoogFF.ar(in, freq, gain))
    }
  257. object MostChange extends ProductReader[MostChange] with Serializable

    A UGen that switches between two input signal depending on which is changing more.

    A UGen that switches between two input signal depending on which is changing more. Change is based on the absolute of the differentiation of the respective signals.

    Examples
    // mouse-x versus mouse-y
    play {
      val x   = MouseX.kr(lag = 1)
      val y   = MouseY.kr(lag = 1)
      val c   = MostChange.kr(x, y)
      val isX = c sig_== x
      val isY = 1 - isX
      // if X change stronger, modulate pan position
      val p   = LFTri.ar(c * 10 * isX)
      // if Y change stronger, modulate sine frequency
      val f   = LFTri.ar(c * 10 * isY).linExp(-1, 1, 100, 4000)
      // report current state
      c.poll(5, "c")
      x.poll(isX, "now X")
      y.poll(isY, "now Y")
      Pan2.ar(SinOsc.ar(f) * 0.1, p)
    }
    See also

    LeastChange

  258. object MouseButton extends ProductReader[MouseButton] with Serializable

    A UGen that outputs two different values depending on whether the mouse button is pressed.

    A UGen that outputs two different values depending on whether the mouse button is pressed. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.

    Examples
    // toggle sine frequency
    play { SinOsc.ar(MouseButton.kr(400, 440, 0.1)) * 0.1 }
    See also

    MouseX

    MouseY

    KeyState

  259. object MouseX extends ProductReader[MouseX] with Serializable

    A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range.

    A UGen that maps the horizontal screen location of the mouse to a given linear or exponential range. This is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.

    Examples
    // control sine frequency
    play {
      val freq = MouseX.kr(100, 4000, 1)
      SinOsc.ar(freq) * 0.1 * AmpComp.kr(freq)
    }
    See also

    MouseY

    MouseButton

    KeyState

  260. object MouseY extends ProductReader[MouseY] with Serializable

    A UGen that maps the vertical screen location of the mouse to a given linear or exponential range.

    A UGen that maps the vertical screen location of the mouse to a given linear or exponential range. The lo value corresponds to the bottom of the screen, and the hi value corresponds to the top of the screen (not vice-versa).

    This UGen is useful for testing purposes. Mouse interaction with the regular desktop and windowing system is in no way altered by running this UGen.

    Examples
    // control sine frequency
    play {
      val freq = MouseY.kr(100, 4000, 1)
      SinOsc.ar(freq) * 0.1 * AmpComp.kr(freq)
    }
    See also

    MouseX

    MouseButton

    KeyState

  261. object MulAdd extends ProductReader[MulAdd] with Serializable
  262. object NRand extends ProductReader[NRand] with Serializable

    A scalar UGen that generates a single random decimal value, averaging a given number of samples from a uniform distribution between lo and hi .

    A scalar UGen that generates a single random decimal value, averaging a given number of samples from a uniform distribution between lo and hi .

    Examples
    // three clusters with different distributions
    play {
      val z = 1 to 3 map { n =>
        Mix.fill(10)(FSinOsc.ar(NRand(200, 800, n))) * SinOsc.ar(0.4, n).max(0)
      }
      Splay.ar(z) * 0.025
    }
    See also

    IRand

    TRand

    ExpRand

    RandSeed

  263. object NodeID extends ProductReader[NodeID] with Serializable

    Identifier of the node which contains the UGen.

    Identifier of the node which contains the UGen.

    Examples
    // print the UGen value
    play { NodeID.ir.poll(0) }
    See also

    Free

    Poll

    NumRunningSynths

  264. object Normalizer extends ProductReader[Normalizer] with Serializable

    A UGen that normalizes the input amplitude to the given level.

    A UGen that normalizes the input amplitude to the given level. Unlike Compander , this UGen will not overshoot, but it needs to look ahead in the input signal, introducing a delay in its output. The delay time is equal to twice the value of the dur parameter (the buffer internally used).

    Examples
    // compare dry and wet
    play {
      val z    = Decay2.ar(
        Impulse.ar(8, phase = LFSaw.kr(0.25) * 0.7),
        attack = 0.001, release = 0.3) * FSinOsc.ar(500)
      val in  = z * SinOsc.ar(0.05) * 0.5
      val flt = Normalizer.ar(in, dur = 0.15, level = 0.4)
      LinXFade2.ar(in, flt, MouseButton.kr(-1, 1))
    }
    See also

    Limiter

    Compander

  265. object NumAudioBuses extends ProductReader[NumAudioBuses] with Serializable

    Number of audio buses.

    Number of audio buses.

    Examples
    // print the UGen value
    play { NumAudioBuses.ir.poll(0) }
    See also

    NumControlBuses

    NumBuffers

    NumInputBuses

    NumOutputBuses

    NumRunningSynths

  266. object NumBuffers extends ProductReader[NumBuffers] with Serializable

    Maximum number of audio buffers.

    Maximum number of audio buffers.

    Examples
    // print the UGen value
    play { NumBuffers.ir.poll(0) }
    See also

    NumAudioBuses

    NumControlBuses

    NumInputBuses

    NumOutputBuses

    NumRunningSynths

  267. object NumChannels extends ProductReader[NumChannels] with Serializable
  268. object NumControlBuses extends ProductReader[NumControlBuses] with Serializable

    Number of control buses.

    Number of control buses.

    Examples
    // print the UGen value
    play { NumControlBuses.ir.poll(0) }
    See also

    NumAudioBuses

    NumBuffers

    NumInputBuses

    NumOutputBuses

    NumRunningSynths

  269. object NumInputBuses extends ProductReader[NumInputBuses] with Serializable

    Number of input buses.

    Number of input buses.

    Examples
    // print the UGen value
    play { NumInputBuses.ir.poll(0) }
    See also

    NumAudioBuses

    NumControlBuses

    NumBuffers

    NumOutputBuses

    NumRunningSynths

  270. object NumOutputBuses extends ProductReader[NumOutputBuses] with Serializable

    Number of output buses.

    Number of output buses.

    Examples
    // print the UGen value
    play { NumOutputBuses.ir.poll(0) }
    See also

    NumAudioBuses

    NumControlBuses

    NumBuffers

    NumInputBuses

    NumRunningSynths

  271. object NumRunningSynths extends ProductReader[NumRunningSynths] with Serializable

    Number of currently running synths.

    Number of currently running synths.

    Examples
    // print the UGen value
    play { NumRunningSynths.ir.poll(0) }
    See also

    NumAudioBuses

    NumControlBuses

    NumBuffers

    NumInputBuses

    NumOutputBuses

  272. object Nyquist extends ProductReader[Nyquist] with Serializable

    A helper graph element equivalent to SampleRate.ir * 0.5.

    A helper graph element equivalent to SampleRate.ir * 0.5.

    Examples
    // as frequency argument
    play {
      Dust.ar(Nyquist()).pow(8)
    }
    See also

    SampleRate

  273. object OffsetOut extends ProductReader[OffsetOut] with Serializable

    A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle.

    A UGen that writes a signal onto a bus, delaying the signal such that the input will begin to appear on the bus precisely when the encompassing Synth was scheduled according to its OSC bundle. I.e. if the synth is scheduled to be started part way through a control cycle, OffsetOut will maintain the correct offset by buffering the output and delaying it until the exact time that the synth was scheduled for.

    This UGen adds ("mixes") the input-signal to the existing contents of the bus.

    Multi-channel input signals, for example a PanAz , are written as such to the bus without expansion. That is, the bus index argument is used for the first channel, the second channel will appear on bus + 1 , etc.

    If you have an expanding multi-channel input, however, you have to be careful. For example, if you have PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results in one output UGen carrying one channel, and another one carrying two channels. (The way this works is consistent with SCLang). In order to get the correct behaviour (left outputs of the PanAz summed, and right output of the PanAz summed), wrap this expression in a Mix(...) before passing it to the output UGen.

    Note: You cannot currently achieve sample accurate scheduling in SuperCollider. This UGen is therefore more or less useless.

    Examples
    // compare left-right
    val sd = SynthDef.recv("offset-out") {
      val x = Impulse.ar(2)
      val y = SubsampleOffset.ir
      y.poll(0, "offset")
      Out      .ar(0, x)
      OffsetOut.ar(1, x)    // right channel will be delayed against left
    }
    
    val x = Synth(s)
    s ! osc.Bundle.millis(System.currentTimeMillis + 1000, x.newMsg(sd.name, s))
    See also

    Out

    ReplaceOut

    XOut

    SubsampleOffset

  274. object OnePole extends ProductReader[OnePole] with Serializable

    A one pole (IIR) filter UGen.

    A one pole (IIR) filter UGen. Implements the formula :

    out(i) = ((1 - abs(coef)) * in(i)) + (coef * out(i-1))

    Warning: there are bugs when the coefficient is modulated

    See also

    OneZero

    TwoPole

    Lag

  275. object OneZero extends ProductReader[OneZero] with Serializable

    A one zero (FIR) filter UGen.

    A one zero (FIR) filter UGen. Implements the formula :

    out(i) = ((1 - abs(coef)) * in(i)) + (coef * in(i-1))
    See also

    OnePole

    TwoZero

    LPZ1

    HPZ1

    Delay1

    Integrator

  276. object Onsets extends ProductReader[Onsets] with Serializable

    An onset detecting UGen for musical audio signals.

    An onset detecting UGen for musical audio signals. It detects the beginning of notes/drumbeats/etc. Outputs a control-rate trigger signal which is 1 when an onset is detected, and 0 otherwise.

    The onset detection should work well for a general range of monophonic and polyphonic audio signals. The onset detection is purely based on signal analysis and does not make use of any "top-down" inferences such as tempo.

    There are different functions available for the analysis:

    - 0 "power" -- generally OK, good for percussive input, and also very efficient - 1 "magsum" -- generally OK, good for percussive input, and also very efficient - 2 "complex" -- performs generally very well, but more CPU-intensive - 3 "rcomplex" (default) -- performs generally very well, and slightly more efficient than "complex" - 4 "phase" -- generally good, especially for tonal input, medium efficiency - 5 "wphase" -- generally very good, especially for tonal input, medium efficiency - 6 "mkl" -- generally very good, medium efficiency, pretty different from the other methods

    The differences aren't large, so it is recommended you stick with the default "rcomplex" unless you find specific problems with it. Then maybe try "wphase". The "mkl" type is a bit different from the others so maybe try that too. They all have slightly different characteristics, and in tests perform at a similar quality level.

    See also

    PV_JensenAndersen

    PV_HainsworthFoote

  277. object Osc extends ProductReader[Osc] with Serializable

    An oscillator UGen that linearly interpolates a wavetable.

    An oscillator UGen that linearly interpolates a wavetable. It has frequency and phase modulation inputs. The wave table is provided by a buffer filled with a wavetable format signal. The buffer size must be a power of 2.

    The buffer is typically filled by a b_gen OSC message. (e.g. buf.sine1(...) , buf.sine2(...) etc.)

    Examples
    // sine1 example
    val b = Buffer.alloc(s, 512)
    b.sine1(partials = (1 to 6).map(1.0f / _),
      normalize = true, wavetable = true, clear = true)
    
    play {
      Osc.ar(b.id, 200) * 0.3
    }
    See also

    OscN

    COsc

    VOsc

    SinOsc

  278. object OscN extends ProductReader[OscN] with Serializable
  279. object Out extends ProductReader[Out] with Serializable

    A UGen that writes a signal onto a bus.

    A UGen that writes a signal onto a bus. It adds ("mixes") the input-signal to the existing contents of the bus.

    Multi-channel input signals, for example a PanAz , are written as such to the bus without expansion. That is, the bus index argument is used for the first channel, the second channel will appear on bus + 1 , etc.

    If you have an expanding multi-channel input, however, you have to be careful. For example, if you have PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results in one output UGen carrying one channel, and another one carrying two channels. (The way this works is consistent with SCLang). In order to get the correct behaviour (left outputs of the PanAz summed, and right output of the PanAz summed), wrap this expression in a Mix(...) before passing it to the output UGen.

    Examples
    // cross-synth routing
    // allocate an internal stereo audio-bus
    val bus = Bus.audio(s, 2)
    
    // writes to internal bus (initially inaudible)
    val x = play {
      Out.ar(bus.index, Dust.ar(Seq(345, 345)))
    }
    
    // reads internal bus and makes it audible.
    // must be after `x` to be able to read the bus signal
    val y = play(target = x, addAction = addAfter) {
      val in = In.ar(bus.index, 2)
      Resonz.ar(in, 555, 0.1) * 10
    }
    
    // when done, do not forget to free the bus
    y.free(); x.free(); bus.free()
    See also

    In

    PhysicalOut

    ReplaceOut

    XOut

    LocalOut

    Bus

  280. object PV_Add extends ProductReader[PV_Add] with Serializable

    A phase vocoder UGen that performs a complex addition of the two inputs.

    A phase vocoder UGen that performs a complex addition of the two inputs. The formula is (Re(A) + Re(B)) + i(Im(A) + Im(B)) .

  281. object PV_BinScramble extends ProductReader[PV_BinScramble] with Serializable

    A phase vocoder UGen that randomizes the order of the bins.

    A phase vocoder UGen that randomizes the order of the bins. The trigger will select a new random ordering.

  282. object PV_BinShift extends ProductReader[PV_BinShift] with Serializable

    A phase vocoder UGen that stretches and shifts the spectrum.

    A phase vocoder UGen that stretches and shifts the spectrum. It takes each bin, first stretches (scales) its position (bin number) with a given factor, and then adds a shift to it.

  283. object PV_BinWipe extends ProductReader[PV_BinWipe] with Serializable

    A phase vocoder UGen that combine low and high bins from two inputs.

    A phase vocoder UGen that combine low and high bins from two inputs. It does so by copying low bins from one input and the high bins of the other, thus realizes a kind of "wipe" between the two input signals.

    See also

    PV_RandWipe

  284. object PV_BrickWall extends ProductReader[PV_BrickWall] with Serializable

    A phase vocoder UGen that clears bins above or below a cutoff point.

  285. object PV_ConformalMap extends ProductReader[PV_ConformalMap] with Serializable

    A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its input FFT bins z .

    A UGen that applies the conformal mapping z => (z - a) / (1 - za*) to its input FFT bins z .

    It makes a transformation of the complex plane so the output is full of phase vocoder artifacts but may be musically interesting. One should usually keep |a| < 1 , although bigger values may be used to produce noise. A value of a = 0 gives back the input mostly unperturbed.

    Examples
    // mouse control
    play {
      val sf   = Seq.fill(3)(Rand(0.1, 0.5))
      val sadd = Seq(1, 1.1, 1.5, 1.78, 2.45, 6.7).map(_ * 220)
      val in   = Mix(LFSaw.ar(SinOsc.kr(sf).mulAdd(10, sadd)) * 0.3)
      val fft  = FFT(LocalBuf(2048), in)
      val re   = MouseX.kr(0.01,  2.0, 1)
      val im   = MouseY.kr(0.01, 10.0, 1)
      val pv   = PV_ConformalMap(fft, re, im)
      val out  = IFFT.ar(pv)
      val vrb  = CombN.ar(out, 0.1, 0.1, 10)
      Pan2.ar(out + vrb * 0.5, 0, 0.3)
    }
  286. object PV_Conj extends ProductReader[PV_Conj] with Serializable

    A phase vocoder UGen that converts the bins into their complex conjugate counterparts.

    A phase vocoder UGen that converts the bins into their complex conjugate counterparts. The complex conjugate is equal to the input, but with reversed sign of the imaginary part.

  287. object PV_Copy extends ProductReader[PV_Copy] with Serializable

    A phase vocoder UGen that copies the spectral frames from chainA to chainB.

    A phase vocoder UGen that copies the spectral frames from chainA to chainB. This allows for parallel processing of spectral data without the need for multiple FFT UGens, and to copy out data at that point in the chain for other purposes. chainA and chainB must be the same size. The output will carry further chainA, so you chan insert the ugen at the appropriate place in the signal chain.

  288. object PV_CopyPhase extends ProductReader[PV_CopyPhase] with Serializable

    A phase vocoder UGen that combines the magnitudes of first input and phases of the second input.

    A phase vocoder UGen that combines the magnitudes of first input and phases of the second input. phases of the first input.

  289. object PV_Diffuser extends ProductReader[PV_Diffuser] with Serializable

    A phase vocoder UGen that adds a different constant random phase shift to each bin.

    A phase vocoder UGen that adds a different constant random phase shift to each bin. The trigger will select a new set of random phases.

  290. object PV_Div extends ProductReader[PV_Div] with Serializable

    A phase vocoder UGen that performs a complex division of the two inputs.

    A phase vocoder UGen that performs a complex division of the two inputs. Be careful that chainB , the divisor, does not contain zeroes as they would obviously blow up the division.

  291. object PV_HainsworthFoote extends ProductReader[PV_HainsworthFoote] with Serializable

    An FFT based onset detector UGen using a balance of two features.

    An FFT based onset detector UGen using a balance of two features. It is based on work described in Hainsworth (2003), "Techniques for the Automated Analysis of Musical Audio," PhD thesis, University of Cambridge. See especially p. 128. The Hainsworth metric is a modification of the Kullback Liebler distance.

    Examples
    // observe detection
    play {
      val sig = Decay.ar(Dust.ar(2), 0.1) * WhiteNoise.ar(0.25)
      val th  = MouseX.kr(0.3, 1.0, lag = 0)
      th.poll(HPZ1.kr(th).abs, "thresh")
      val h   = MouseY.kr(1.0, 0.1, lag = 0)
      val f   = 1 - h
      h.poll(HPZ1.kr(h).abs, "h-f")
      val tr  = PV_HainsworthFoote.ar(FFT(LocalBuf(2048), sig), h, f, thresh = th)
      Seq(sig, SinOsc.ar(440) * Decay.ar(tr * 0.01, 0.1))
    }
    See also

    Onsets

    PV_JensenAndersen

  292. object PV_JensenAndersen extends ProductReader[PV_JensenAndersen] with Serializable

    An FFT based onset detector UGen using a mix of extracted features.

    An FFT based onset detector UGen using a mix of extracted features. It is based on work described in Jensen and Andersen (2003), "Real-time Beat Estimation Using Feature Extraction," in: Proceedings of the Computer Music Modeling and Retrieval Symposium.

    First order derivatives of the features are taken. The threshold may need to be set low to pick up on changes.

    Examples
    // observe detection
    play {
      val sig = Decay.ar(Dust.ar(2), 0.1) * WhiteNoise.ar(0.25)
      val th  = MouseX.kr(0.1, 1.0, lag = 0)
      th.poll(HPZ1.kr(th).abs, "thresh")
      val tr  = PV_JensenAndersen.ar(FFT(LocalBuf(2048), sig), thresh = th)
      Seq(sig, SinOsc.ar(440) * Decay.ar(tr * 0.01, 0.1))
    }
    See also

    Onsets

    PV_HainsworthFoote

  293. object PV_LocalMax extends ProductReader[PV_LocalMax] with Serializable

    A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima.

    A phase vocoder UGen that passes only those bins whose magnitudes constitute local maxima. Additionally, the given threshold is also used to filter out bins whose magnitude lies below this threshold.

  294. object PV_MagAbove extends ProductReader[PV_MagAbove] with Serializable

    A phase vocoder UGen that passes only those bins whose magnitudes are above a given threshold.

  295. object PV_MagBelow extends ProductReader[PV_MagBelow] with Serializable

    A phase vocoder UGen that passes only those bins whose magnitudes are below a given threshold.

  296. object PV_MagClip extends ProductReader[PV_MagClip] with Serializable

    A phase vocoder UGen that limits (clips) the magnitude of the bins to a given threshold.

  297. object PV_MagDiv extends ProductReader[PV_MagDiv] with Serializable

    A phase vocoder UGen that divides magnitudes of two inputs and keeps the phases of the first input.

  298. object PV_MagFreeze extends ProductReader[PV_MagFreeze] with Serializable

    A phase vocoder UGen that freezes the magnitudes at current levels.

    A phase vocoder UGen that freezes the magnitudes at current levels. Freezing happens when the freeze input has a value of > 0.

  299. object PV_MagMul extends ProductReader[PV_MagMul] with Serializable

    A phase vocoder UGen that multiplies the magnitudes of two inputs and keeps the phases of the first input.

  300. object PV_MagNoise extends ProductReader[PV_MagNoise] with Serializable

    A phase vocoder UGen that multiplies the magnitudes by random noise.

  301. object PV_MagShift extends ProductReader[PV_MagShift] with Serializable

    A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum.

    A phase vocoder UGen that stretches and shifts the magnitudes of the spectrum. This is live PV_BinShift but instead of scaling and shifting the whole complex bins (magnitude and phase), this only operates on the magnitudes and leaves the phases in their original bins.

  302. object PV_MagSmear extends ProductReader[PV_MagSmear] with Serializable

    A phase vocoder UGen that averages each bin's magnitude with its neighbors.

  303. object PV_MagSquared extends ProductReader[PV_MagSquared] with Serializable

    A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak.

    A phase vocoder UGen that squares the magnitudes and re-normalizes to previous peak. This makes weak bins weaker.

  304. object PV_Max extends ProductReader[PV_Max] with Serializable

    A phase vocoder UGen that outputs the bins with the maximum magnitude of the two inputs.

  305. object PV_Min extends ProductReader[PV_Min] with Serializable

    A phase vocoder UGen that outputs the bins with the minimum magnitude of the two inputs.

  306. object PV_Mul extends ProductReader[PV_Mul] with Serializable

    A phase vocoder UGen that performs a complex multiplication of the two inputs.

    A phase vocoder UGen that performs a complex multiplication of the two inputs. The formula is (Re(A) * Re(B) - Im(A) * Im(B)) + i(Im(A) * Re(B) + Re(A) * Im(B)) .

  307. object PV_PhaseShift extends ProductReader[PV_PhaseShift] with Serializable

    A phase vocoder UGen that shifts the phase of each bins by a given amount.

  308. object PV_PhaseShift270 extends ProductReader[PV_PhaseShift270] with Serializable

    A phase vocoder UGen that shift the phase of all bins by 270 (or -90) degrees.

  309. object PV_PhaseShift90 extends ProductReader[PV_PhaseShift90] with Serializable

    A phase vocoder UGen that shift the phase of all bins by 90 degrees.

  310. object PV_RandComb extends ProductReader[PV_RandComb] with Serializable

    A phase vocoder UGen that randomly clears out bins of the signal.

    A phase vocoder UGen that randomly clears out bins of the signal. Which bins are wiped out is subject to a random choice (only the amount is specified) that remains constant between triggers.

  311. object PV_RandWipe extends ProductReader[PV_RandWipe] with Serializable

    A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.

    A phase vocoder UGen that cross-fades between two input spectra by taking bins randomly from them according to a given probability.

    See also

    PV_BinWipe

  312. object PV_RectComb extends ProductReader[PV_RectComb] with Serializable

    A phase vocoder UGen that makes a series of gaps in a spectrum.

    A phase vocoder UGen that makes a series of gaps in a spectrum. This is done by multiplying the spectrum with a kind of rectangle wave that goes from zero to nyquist. The high slope of the rectangle lets the input bins pass (quasi pass-band), the low slope filters them out (quasi stop-band).

    See also

    PV_RectComb2

  313. object PV_RectComb2 extends ProductReader[PV_RectComb2] with Serializable

    A phase vocoder UGen that switches between two input spectra according to a rectangle wave.

    A phase vocoder UGen that switches between two input spectra according to a rectangle wave. This is basically identical to PV_RectComb , however during the low slopes of the rectangle wave, instead of clearing out the bins, it copies over the corresponding bins of the second fft input buffer.

    See also

    PV_RectComb

  314. object PackFFT extends ProductReader[PackFFT] with Serializable

    A UGen that writes a complex input signal into an FFT buffer.

    A UGen that writes a complex input signal into an FFT buffer. The input is a sequence of interleaved magnitudes and phases. It is written to an FFT buffer ready for transforming it back into time-domain audio using IFFT.

    Examples
    // harmonic sound with changing overtone intensities
    play {
      // create simple undulating magnitudes
      val m0 = FSinOsc.kr(Seq.fill(100)(ExpRand(0.1, 1))) * 0.5 + 0.5
      // give them a "rolloff" to make the sound less unpleasant
      val m1 = m0 * Seq.tabulate(100)(_.linLin(0, 99, 1.0, 0.01).squared)
      // turn the bins on and off at different rates
      val mags = m1 * LFPulse.kr(Seq.fill(100)(2 pow IRand(-3, 5)))
      // ignore phase
      val phases: GE = Seq.fill(100)(0)
      // We need to create an FFT chain to feed our data in to.
      // The easiest way is to do an FFT on some signal which we then ignore!
      val buf = FFT(LocalBuf(512), DC.ar(0))
      // now we can do the packing
      val chain = PackFFT(buf, 512, Zip(mags, phases), 0, 99, 1)
      val sig = IFFT.ar(chain)
      Pan2.ar(sig)
    }
    See also

    Unpack1FFT

    FFT

    IFFT

    SetBuf

  315. object Pad extends ProductReader[Pad] with Serializable

    A graph element that controls the multi-channel expansion of its in argument to match the to argument by padding (extending and wrapping) it.

  316. object Pan2 extends ProductReader[Pan2] with Serializable

    A stereo panorama UGen based on equal-power amplitude control.

    A stereo panorama UGen based on equal-power amplitude control. When in center position ( pos = 0 ), the signal is attenuated by sqrt(0.5) or approx. -3 dB.

    Examples
    // periodic left-right oscillation
    play { Pan2.ar(PinkNoise.ar(0.4), SinOsc.kr(0.25), 0.3) }
    See also

    LinPan2

    PanAz

    Pan4

    Balance2

    XFade2

  317. object Pan4 extends ProductReader[Pan4] with Serializable

    A four channel equal-power panorama UGen.

    A four channel equal-power panorama UGen. The outputs are in order leftFront , rightFront , leftBack , rightBack .

    Examples
    // mouse controlled pan position
    play {
      val x = MouseX.kr(-1, 1)
      val y = MouseY.kr(-1, 1)
      val p = Pan4.ar(PinkNoise.ar, x, y)
      // make a stereo mix with different timbre front and back
      val f = Resonz.ar(Seq(p.leftFront, p.rightFront), 4000, 0.2) * 4
      val r = Resonz.ar(Seq(p.leftBack , p.rightBack ), 1500, 0.2) * 4
      f + r
    }
    See also

    Pan2

    PanAz

  318. object PanAz extends ProductReader[PanAz] with Serializable

    An azimuth-based panorama UGen.

    An azimuth-based panorama UGen. It uses vector-based-amplitude panning where the arbitrary number of speakers is supposed to be distributed in a circle with even spacing between them. It uses an equal-power-curve to transition between adjacent speakers. Note the different default value for the orient argument!

    Use case: To spread an multi-channel input signal across an output bus with a different number of channels, such that the first input channel is played on the first output channel (no spread to adjacent channels) and the last input channel is played to the last output channel (no spread to adjacent channels), you would create a dedicated PanAz per input channel where the pan position is inChanIdx * 2f / (inChannels - 1) * (outChannels - 1) / outChannels .

    See also

    Pan2

    SplayAz

  319. object PanB extends ProductReader[PanB] with Serializable

    An Ambisonics B-format encoding UGen.

    An Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the X and Y channels.

    Note that unlike PanB2, azimuth is in radians.

    See also

    PanB2

    DecodeB2

  320. object PanB2 extends ProductReader[PanB2] with Serializable

    A two dimensional Ambisonics B-format encoding UGen.

    A two dimensional Ambisonics B-format encoding UGen. B-format is the name for first order Ambisonics which normally has four channels W, X, Y, Z. By omitting the elevation control, we get a two dimensional planar encoded signal consisting only of the W, X and Y channels.

    Note that unlike PanB, azimuth is normalized between -1 and +1.

    Examples
    // 4-channel rotation of opposite sounds
    play {
      val p = WhiteNoise.ar(0.05)                     // first source
      val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03  // second source
      // B-format encode 2 signals at opposite sides of the circle
      val enc = PanB2.ar(p, -0.5) + PanB2.ar(q, +0.5)
      val Seq(w, x, y) = (0 to 2).map(enc out _)
      val rot = Rotate2.ar(x, y, MouseX.kr(-1, +1))
      // B-format decode to quad (front-left, front-right, rear-left, rear-right)
      DecodeB2.ar(4, w, rot.xr, rot.yr)
    }
    See also

    PanB

    BiPanB2

    DecodeB2

    Pan2

  321. object PartConv extends ProductReader[PartConv] with Serializable

    A UGen for partitioned convolution.

    A UGen for partitioned convolution. Its advantage over non-partitioning UGens such as Convolution2 is that the impulse response can be arbitrarily large amortization is used to spread processing and avoid CPU spikes.

    The impulse response buffer must be specially prepared, using a /b_gen command that transforms an existing regularly formatted buffer to a new partitioned convolution ready buffer.

    Examples
    // Dan Stowell's reverb
    // synthesize impulse response
    val ir = (1f +: Vector.fill(100)(0f)) ++ (1f to 0f by -0.00002f).map { f =>
      if (math.random < 0.5)
        0f
      else
        f.pow(8) * (math.random - 0.5).signum * 0.1f
    }
    
    // ir.plot()
    
    // send the IR to a regular buffer
    val irBuf = Buffer(s)
    irBuf.alloc(ir.size)
    irBuf.setData(ir)
    
    // calculate the partitioning parameters
    val fftSize  = 2048
    val numPart  = (ir.size * 2.0 / fftSize).ceil.toInt  // 49
    val partSize = fftSize * numPart  // 100352
    
    // create the specially formatted partitioned buffer
    val partBuf  = Buffer(s)
    partBuf.alloc(partSize)
    // currently no predefined method for this command!
    s ! osc.Message("/b_gen", partBuf.id, "PreparePartConv", irBuf.id, fftSize)
    
    // now we can forget about the input buffer
    irBuf.free()
    
    val x = play {
      // trigger IR every 4 seconds
      val in = Impulse.ar(0.25) * 0.5
      PartConv.ar(in, fftSize, partBuf.id)
    }
    
    // do not forget to free the buffer eventually
    x.free(); partBuf.free()
    See also

    Convolution

    Convolution2

  322. object Pause extends ProductReader[Pause] with Serializable

    A UGen which pauses and resumes another node.

    A UGen which pauses and resumes another node. Note that the UGen initially assumes the node is running, that is, if gate is initially 1, this will not resume a paused node. Instead, the gate must go to zero and back to one to resume the node. Additionally, this UGen will only cause action if the gate value changes, that is, if the node is paused or resumed otherwise, this UGen will not interfere with that action, unless the gate value is adjusted.

    See also

    Free

    PauseSelf

  323. object PauseSelf extends ProductReader[PauseSelf] with Serializable

    A UGen that, when triggered, pauses enclosing synth.

    A UGen that, when triggered, pauses enclosing synth. It pauses the enclosing synth when the input signal crosses from non-positive to positive.

    Note that if the trigger is initially high the UGen will not react. For example, PauseSelf.kr("foo".kr) will not work if the control is initially 1 . A work-around is to wrap the input in this case in a Trig object: PauseSelf.kr(Trig.kr("foo".kr)) . This is most likely a bug.

    This UGen outputs its input signal for convenience.

    See also

    Pause

    FreeSelf

  324. object PauseSelfWhenDone extends ProductReader[PauseSelfWhenDone] with Serializable

    A UGen that, when its input UGen is finished, pauses enclosing synth.

    A UGen that, when its input UGen is finished, pauses enclosing synth. This is essentially a shortcut for PauseSelf.kr(Done.kr(src)) , so instead of providing a trigger signal it reads directly the done flag of an appropriate ugen (such as Line or PlayBuf ).

    This UGen outputs its input signal for convenience.

    See also

    Pause

    PauseSelf

    FreeSelfWhenDone

    Done

  325. object Peak extends ProductReader[Peak] with Serializable

    A UGen to measure a signal's peak amplitude.

    A UGen to measure a signal's peak amplitude. Technically, this UGen works like RunningMax after the absolute value of the input signal is taken.

    The UGen keeps an internal state that reflects the maximum absolute input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current absolute input value. This way, the peak value seen from the outside at trigger time is the correct peak value up to that moment. See the 'illustrate timing' example to understand this timing.

    Examples
    // illustrate timing
    play {
      val i  = Impulse.ar(0)
      // first impulse after 100ms
      val t1 = DelayN.ar(i * 1.0 , 0.100, 0.100)
      // one sample later
      val t2 = Delay1.ar(t1) * 0.5
      // another sample later
      val t3 = Delay1.ar(t2)
      val p  = Peak.ar(t1 + t2, t2)
      // at t1, peak has already seen t1
      p.poll(t1, "t1")
      // at t2, peak still reports 1.0, while internally resetting
      p.poll(t2, "t2")
      // at t3, we observe 0.5, therefore peak did reset at t2
      p.poll(t3, "t3")
      ()
    }
    See also

    RunningMin

    RunningMax

    RunningSum

    PeakFollower

    Amplitude

  326. object PeakFollower extends ProductReader[PeakFollower] with Serializable

    A UGen that continually reports the peak amplitude of the signal received at the input.

    A UGen that continually reports the peak amplitude of the signal received at the input. If the absolute input level drops below the observed peak value, this value decreases by the factor given as decay parameter (but no more than the current absolute input level).

    Examples
    // mouse-controlled decay
    play {
      val in    = Impulse.ar(2)
      val decay = MouseX.kr(0.995, 1.0001, 1).min(1.0)
      decay.poll(HPZ1.kr(decay).abs, "decay")
      val p     = PeakFollower.ar(in, decay)
      val tr    = Impulse.ar(20)
      val pm    = RunningMax.ar(p, tr)
      pm.roundTo(0.001).poll(20, "peak")
      in
    }
    See also

    Peak

    Amplitude

    RunningSum

    LagUD

  327. object Phasor extends ProductReader[Phasor] with Serializable

    A linear repeating ramp UGen between start and end values.

    A linear repeating ramp UGen between start and end values. Using a trigger input, it can be reset to a specific position. Upon reaching the end of its ramp, Phasor will wrap back to its start value. Note: Since end is defined as the wrap point, its value is never actually output.

    Examples
    // glissandi
    play {
      // mouse-x controls phasor speed
      val freq  = MouseX.kr(0.2, 2, 1)
      // mouse button can be used to jump back
      val reset = MouseButton.kr(lag = 0)
      val p     = Phasor.ar(reset, freq / SampleRate.ir)
      SinOsc.ar(p.linLin(0, 1, 600, 1000)) * 0.1
    }
    See also

    Ramp

    Stepper

    Line

    LFSaw

  328. object PhysicalIn extends ProductReader[PhysicalIn] with Serializable

    A graph element which reads from a connected sound driver input.

    A graph element which reads from a connected sound driver input. This is a convenience element for accessing physical input signals, e.g. from a microphone connected to your audio interface. It expands to a regular In UGen offset by NumOutputBuses.ir.

    For example, consider an audio interface with channels 1 to 8 being analog line inputs, channels 9 and 10 being AES/EBU and channels 11 to 18 being ADAT inputs. To read a combination of the analog and ADAT inputs, either of the following statement can be used:

    PhysicalIn(Seq(0, 8), Seq(8, 8))
    PhysicalIn(Seq(0, 8), Seq(8))      // numChannels wraps!

    If SuperCollider runs with less physical inputs than requested by this UGen, invalid channels are muted.

  329. object PhysicalOut extends ProductReader[PhysicalOut] with Serializable

    A graph element which writes to a connected sound driver output.

    A graph element which writes to a connected sound driver output. This is a convenience element for Out with the ability to provide a set of discrete indices to which corresponding channels of the input signal are mapped, whereas multichannel expansion with respect to the index argument of Out typically do not achieve what you expect.

    If SuperCollider runs with less physical outputs than requested by this UGen, the output is muted.

    Examples
    // flip left and right when writing a stereo signal
    play {
      val indices = Seq(1, 0)
      val in:GE   = Seq(SinOsc.ar * LFPulse.ar(4), WhiteNoise.ar)
      // sine appears on the right channel, and noise on the left
      PhysicalOut(indices, in * 0.2)
    }
  330. object PinkNoise extends ProductReader[PinkNoise] with Serializable

    A noise generator UGen whose spectrum falls off in power by 3 dB per octave.

    A noise generator UGen whose spectrum falls off in power by 3 dB per octave. This gives equal power over the span of each octave. This version gives 8 octaves of pink noise.

    The values produced by this UGen were observed to lie with very high probability between approx. -0.65 and +0.81 (before being multiplied by mul ). The RMS is approx. -16 dB.

    Examples
    // plain noise
    play { PinkNoise.ar(Seq(0.2, 0.2)) }
    See also

    WhiteNoise

    BrownNoise

    GrayNoise

    ClipNoise

    RandSeed

  331. object Pitch extends ProductReader[Pitch] with Serializable

    An autocorrelation based pitch following UGen.

    An autocorrelation based pitch following UGen. It is more accurate than ZeroCrossing , but more also more CPU costly. For most purposes the default settings can be used and only in needs to be supplied.

    The UGen has two outputs: The first output is the frequency estimate in Hertz, the second output is a toggle hasFreq , which tells whether a pitch was found (1) or not (0). If the clarify argument is used, hasFreq has more fine grained information.

    The pitch follower executes periodically at the rate specified by execFreq in cps. First it detects whether the input peak to peak amplitude is above the ampThresh . If it is not then no pitch estimation is performed, the hasFreq output is set to zero and the freq output is held at its previous value. Otherwise, the autocorrelation is calculated, and the first peak after the peak around the lag of zero that is above peakThresh times the amplitude of the peak at lag zero is reported.

    Examples
    // pitch-follower resynthesizing with saw tooth
    play {
      // be careful and use headphones!
      val in      = Mix(PhysicalIn.ar(0, 2))
      val amp     = Amplitude.kr(in, 0.05, 0.05)
      val p       = Pitch.kr(in, ampThresh = 0.02, median = 7)
      val saw     = Mix(VarSaw.ar(p.freq * Seq(0.5, 1, 2), 0, LFNoise1.kr(0.3,0.1,0.1)) * amp)
      Mix.fold(saw, 6) { res =>
        AllpassN.ar(res, 0.040, Rand(0, 0.040), Rand(0, 0.040), 2)
      }
    }
  332. object PitchShift extends ProductReader[PitchShift] with Serializable

    A time domain granular pitch shifter.

    A time domain granular pitch shifter. Grains have a triangular amplitude envelope and an overlap of 4:1.

  333. object PlayBuf extends ProductReader[PlayBuf] with Serializable

    A UGen to play back samples from a buffer in memory.

    A UGen to play back samples from a buffer in memory.

    PlayBuf provides a kind of high-level interface to sample-playback, whereas BufRd represents a kind of lower-level access. While BufRd has a random-access-pointer in the form of a phase input, PlayBuf advances the phase automatically based on a given playback speed. PlayBuf uses cubic interpolation.

    See also

    BufRd

    DiskIn

    RecordBuf

    DoneAction

    Done

    BufRateScale

    BufFrames

  334. object Pluck extends ProductReader[Pluck] with Serializable

    A Karplus-Strong UGen.

  335. object Poll extends ProductReader[Poll] with Serializable

    A UGen for printing the current output value of its input to the console.

    A UGen for printing the current output value of its input to the console.

    See also

    SendTrig

  336. object Pulse extends ProductReader[Pulse] with Serializable

    A band-limited pulse wave generator UGen, capable of pulse width modulation.

    A band-limited pulse wave generator UGen, capable of pulse width modulation.

    Note: The fine behavior depends on the server's block-size which interacts with the pulse width. The behavior is more regular if the duty period sr / freq * width is an integer multiple of the block-size. A width of 1.0 can produce strange results.

    Examples
    // modulate frequency
    play { Pulse.ar(XLine.kr(40, 4000, 6)) * 0.2 }
    // modulate pulse width
    play { Pulse.ar(200, Line.kr(0.01, 0.99, 8)) * 0.2 }
    // two pulses with different frequencies through resonant filter
    play { RLPF.ar(Pulse.ar(Seq(100, 250)) * 0.2, XLine.kr(8000, 400, 6), 0.05) }
    See also

    LFPulse

  337. object PulseCount extends ProductReader[PulseCount] with Serializable

    A UGen that counts the number of triggers observed.

    A UGen that counts the number of triggers observed.

    Examples
    // count mouse clicks, reset at 10
    play {
      val tr    = MouseButton.kr(lag = 0)
      val reset = PulseDivider.kr(tr, 10)
      val c     = PulseCount.kr(tr, reset)
      c.poll(tr + Impulse.kr(0), "count")
      ()
    }
    See also

    Stepper

  338. object PulseDivider extends ProductReader[PulseDivider] with Serializable

    A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.

    A UGen that decimates trigger by outputting one impulse each time a certain number of triggers at its input have been received.

    Examples
    // every two mouse-button clicks
    play {
      val in  = MouseButton.kr(lag = 0)
      in.poll(in, "in")
      val out = PulseDivider.kr(in, 2, -1)
      out.poll(out, "out")
      ()
    }
    // rhythmic 1:4 pattern
    play {
      val p = Impulse.ar(8)
      val d = PulseDivider.ar(p, 4)
      val a = SinOsc.ar(1200) * Decay2.ar(p, 0.005, 0.1) * 0.3
      val b = SinOsc.ar( 600) * Decay2.ar(d, 0.005, 0.5) * 0.3
      Seq(a, b)
    }
    See also

    PulseCount

    Stepper

  339. object QuadC extends ProductReader[QuadC] with Serializable

    A cubic-interpolating sound generator based on the difference equation:

    A cubic-interpolating sound generator based on the difference equation:

    x[n+1] = a * pow(x[n], 2) + b * x[n] + c
    Examples
    // default parameters
    play { QuadC.ar(SampleRate.ir/4) * 0.2 }
    // logistic map
    play {
      // equation: x1 = -r*x0^2 + r*x0
      val r = MouseX.kr(3.5441, 4)    // stable range
      QuadC.ar(SampleRate.ir/4, -r, r, 0, 0.1) * 0.4
    }
    // logistic map as frequency control
    play {
      val r = MouseX.kr(3.5441, 4)    // stable range
      SinOsc.ar(QuadC.ar(40, -r, r, 0, 0.1).mulAdd(800, 900)) * 0.4
    }
    See also

    QuadN

    QuadL

  340. object QuadL extends ProductReader[QuadL] with Serializable

    A linear-interpolating sound generator based on the difference equation:

    A linear-interpolating sound generator based on the difference equation:

    x[n+1] = a * pow(x[n], 2) + b * x[n] + c
    Examples
    // default parameters
    play { QuadL.ar(SampleRate.ir/4) * 0.2 }
    // logistic map
    play {
      // equation: x1 = -r*x0^2 + r*x0
      val r = MouseX.kr(3.5441, 4)    // stable range
      QuadL.ar(SampleRate.ir/4, -r, r, 0, 0.1) * 0.4
    }
    // logistic map as frequency control
    play {
      val r = MouseX.kr(3.5441, 4)    // stable range
      SinOsc.ar(QuadL.ar(40, -r, r, 0, 0.1).mulAdd(800, 900)) * 0.4
    }
    See also

    QuadN

    QuadC

  341. object QuadN extends ProductReader[QuadN] with Serializable

    A non-interpolating sound generator based on the difference equation:

    A non-interpolating sound generator based on the difference equation:

    x[n+1] = a * pow(x[n], 2) + b * x[n] + c
    Examples
    // default parameters
    play { QuadN.ar(SampleRate.ir/4) * 0.2 }
    // logistic map
    play {
      // equation: x1 = -r*x0^2 + r*x0
      val r = MouseX.kr(3.5441, 4)    // stable range
      QuadN.ar(SampleRate.ir/4, -r, r, 0, 0.1) * 0.4
    }
    // logistic map as frequency control
    play {
      val r = MouseX.kr(3.5441, 4)    // stable range
      SinOsc.ar(QuadN.ar(40, -r, r, 0, 0.1).mulAdd(800, 900)) * 0.4
    }
    See also

    QuadL

    QuadC

  342. object RHPF extends ProductReader[RHPF] with Serializable

    A resonant high pass filter UGen.

    A resonant high pass filter UGen.

    Examples
    // mouse controlled frequency and Q
    play {
      val in   = WhiteNoise.ar(0.5)
      val freq = MouseX.kr(200, 10000, 1)
      val q    = MouseY.kr(1, 100, 1) // bottom to top
      val flt  = RHPF.ar(in, freq, q.reciprocal)
      flt / q.sqrt // compensate for energy loss
    }
    See also

    HPF

    RLPF

    Resonz

  343. object RLPF extends ProductReader[RLPF] with Serializable

    A resonant low pass filter UGen.

    A resonant low pass filter UGen.

    Examples
    // mouse controlled frequency and Q
    play {
      val in   = WhiteNoise.ar(0.5)
      val freq = MouseX.kr(200, 10000, 1)
      val q    = MouseY.kr(1, 100, 1) // bottom to top
      val flt  = RLPF.ar(in, freq, q.reciprocal)
      flt / q.sqrt // compensate for energy loss
    }
    See also

    LPF

    RHPF

    Resonz

  344. object RMS extends ProductReader[RMS] with Serializable

    A UGen that calculates the root-mean-square of a first order low-pass filtered input signal.

    A UGen that calculates the root-mean-square of a first order low-pass filtered input signal. The formula is 'rms = sqrt(lpf1(x^2))'.

    Examples
    // measure mouse-controlled sine
    play {
      // with MouseX at maximum, you'll see that the sine has -3 dB RMS
      val sig = SinOsc.ar(300) * MouseX.kr(0, 1) * LFPulse.ar(0.5)
      val rms = RMS.ar(sig, 10).ampDb.roundTo(0.1).poll(8, "RMS (dB)")
      sig
    }

    This is a third-party UGen (DEINDUGens).

    See also

    Amplitude

  345. object RadiansPerSample extends ProductReader[RadiansPerSample] with Serializable

    A UGen that delivers the conversion factor from frequency in Hertz to radians (normalized frequency).

    A UGen that delivers the conversion factor from frequency in Hertz to radians (normalized frequency). The relation is RadiansPerSample * sr = 2pi , thus multiplying the UGen with a frequency between zero and nyquist (sr/2) yields the normalized frequency between zero and pi.

    Examples
    // print the UGen value
    play { RadiansPerSample.ir.poll(0) }
    See also

    SampleRate

  346. object Ramp extends ProductReader[Ramp] with Serializable

    A UGen which produces a linear lag (time smear) regarding and input signal.

    A UGen which produces a linear lag (time smear) regarding and input signal. Other than Lag which is a feedback filter with exponential decay, Ramp applies a linear ramp. This is achieved by sampling the input signal at regular intervals given by the lagTime and starting a new line segment after each interval.

    See also

    Lag

    Sweep

  347. object Rand extends ProductReader[Rand] with Serializable

    A scalar UGen that generates a single random decimal value, using a uniform distribution from lo to hi .

    A scalar UGen that generates a single random decimal value, using a uniform distribution from lo to hi .

    Examples
    // random sine frequencies
    play {
      val m = Mix.fill(10)(FSinOsc.ar(Rand(200.0, 800.0)))
      m * Line.kr(0.025, 0, 4, doneAction = freeSelf)
    }
    See also

    IRand

    TRand

    ExpRand

    RandSeed

  348. object RandID extends ProductReader[RandID] with Serializable

    A UGen that determines which random number generator is used for the enclosing synth.

    A UGen that determines which random number generator is used for the enclosing synth. All synths that use the same generator reproduce the same sequence of numbers when the same seed is set again.

    Examples
    // button alternatingly resets left and right seed
    0 to 1 map { i =>
      play {
        RandID.ir(i)
        val x     = Impulse.kr(4)
        val pch   = TIRand.kr(40, 100, x)
        val b     = MouseButton.kr(lag = 0)
        val tr    = PulseDivider.kr(b, 2, i)
        pch.poll(x, if (i == 0) "left " else "right")
        RandSeed.kr(tr + Impulse.kr(0), 234)
        Out.ar(i, SinOsc.ar(pch.midiCps) * 0.2)
      }
    }
    See also

    Rand

    RandSeed

    IRand

    WhiteNoise

  349. object RandSeed extends ProductReader[RandSeed] with Serializable

    A UGen that resets the seed of the synth's random number generator upon receiving a trigger.

    A UGen that resets the seed of the synth's random number generator upon receiving a trigger. All synths that use the same random number generator reproduce the same sequence of numbers again. The generator can be set using the RandID UGen.

    Examples
    // reset seed via mouse button
    play {
      val freq = TIRand.kr(40, 100, Impulse.kr(4)).midiCps
      RandSeed.kr(MouseButton.kr(lag = 0) + Impulse.kr(0), 234)
      SinOsc.ar(freq) * 0.2
    }
    See also

    Rand

    RandID

    IRand

    WhiteNoise

  350. object RecordBuf extends ProductReader[RecordBuf] with Serializable

    Records input into a Buffer.

    Records input into a Buffer. If recLevel is 1.0 and preLevel is 0.0 then the new input overwrites the old data. If they are both 1.0 then the new data is added to the existing data. (Any other settings are also valid.)

    Examples
    // record and replay
    // a four second mono buffer
    val b = Buffer.alloc(s, s.sampleRate.toInt * 4)
    
    // record for four seconds
    play {
      val sig = Formant.ar(XLine.kr(400, 1000, 4), 2000, 800) * 0.125
      RecordBuf.ar(sig, b.id, doneAction = freeSelf, loop = 0)
    }
    
    // play it back
    play {
      PlayBuf.ar(1, b.id, doneAction = freeSelf, loop = 0)
    }
    See also

    BufWr

    DiskOut

    PlayBuf

    DoneAction

    Done

    BufRateScale

    BufFrames

  351. object Reduce extends ProductReader[Reduce] with Serializable
  352. object RepeatChannels extends ProductReader[RepeatChannels] with Serializable
  353. object ReplaceOut extends ProductReader[ReplaceOut] with Serializable

    A UGen that replace the contents of a bus with an input signal.

    A UGen that replace the contents of a bus with an input signal. Other than Out , the signal is not added to the previous contents of the bus but replaces it, allowing for a simple way of an "insert" effect.

    Multi-channel input signals, for example a PanAz , are written as such to the bus without expansion. That is, the bus index argument is used for the first channel, the second channel will appear on bus + 1 , etc.

    If you have an expanding multi-channel input, however, you have to be careful. For example, if you have PanAz.ar(2, SinOsc.ar(Seq(444, 555, 666)) * 0.2, Seq(-1, 0, 1)) , this results in one output UGen carrying one channel, and another one carrying two channels. (The way this works is consistent with SCLang). In order to get the correct behaviour (left outputs of the PanAz summed, and right output of the PanAz summed), wrap this expression in a Mix(...) before passing it to the output UGen.

    Examples
    // insert-effect
    val noise = play {
      Out.ar(0, WhiteNoise.ar(Seq(0.1, 0.1)))
    }
    
    val filter = play(target = noise, addAction = addAfter) {
      val in = In.ar(0, 2)
      val f  = Resonz.ar(in, 444, 0.1) * 20
      ReplaceOut.ar(0, f)
    }
    
    filter.run(false)  // bypass
    filter.run(true )  // engage
    See also

    In

    Out

    XOut

  354. object Resonz extends ProductReader[Resonz] with Serializable

    A two pole resonant filter UGen.

    A two pole resonant filter UGen. It has zeroes at z = +1 and z = -1.

    Based on K. Steiglitz, "A Note on Constant-Gain Digital Resonators", Computer Music Journal, vol 18, no. 4, pp. 8-10, Winter 1994.

    Examples
    // modulated frequency
    play {
      val in   = Saw.ar(200) * 0.5
      val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(3600, 4000)
      Resonz.ar(in, freq)
    }
    // mouse controlled frequency and Q
    play {
      val in   = WhiteNoise.ar(0.5)
      val freq = MouseX.kr(200, 10000, 1)
      val q    = MouseY.kr(1, 100, 1) // bottom to top
      val flt  = Resonz.ar(in, freq, q.reciprocal)
      flt * q.sqrt // compensate for energy loss
    }
    See also

    BPF

    Ringz

    HPF

    LPF

    MidEQ

  355. object Ringz extends ProductReader[Ringz] with Serializable

    A resonant or "ringing" filter UGen.

    A resonant or "ringing" filter UGen. This is the same as Resonz , except that instead of a Q parameter, the bandwidth is specified as a 60 dB ring decay time. One Ringz is equivalent to one component of the Klank UGen.

    Note: Ringz and derived UGens Klank and Formlet produce output RMS depending on the server's sampling rate. This is to achieve the same amplitude for single-sample impulse inputs.

    Examples
    // module ring time
    play { Ringz.ar(Impulse.ar(6) * 0.3, 2000, XLine.kr(4, 0.04, 8)) }
    // modulated frequency
    play {
      val in   = Saw.ar(200) * 0.02
      val freq = SinOsc.ar(XLine.ar(0.3, 100, 20)).mulAdd(2800, 4800)
      Ringz.ar(in, freq)
    }
    // multiple glissandi excited by noise
    play {
      val ex = WhiteNoise.ar(0.001)
      Mix.fill(10) {
        Ringz.ar(ex,
          XLine.kr(ExpRand(100, 5000), ExpRand(100, 5000), 20),
        0.5)
      }
    }
    See also

    Resonz

    Formlet

    BPF

    Klank

    MidEQ

  356. object Rotate2 extends ProductReader[Rotate2] with Serializable

    A UGen that can be used for rotating an ambisonic B-format sound field around an axis.

    A UGen that can be used for rotating an ambisonic B-format sound field around an axis. It uses an equal-power rotation so it also works well on stereo sounds. It takes two audio inputs ( x , y ) and an angle control ( pos ). It outputs again two channels, using these formulas:

    xr = cos(angle) * x + sin(angle) * y
    yr = cos(angle) * y - sin(angle) * x

    where angle = pos * Pi . This allows, for example, the use of LFSaw to create a continuous rotation around a circle. Note: Be careful when accessing the output channels. xr and yr are the X and Y output channels, whereas x and y refers to the X and Y input channel.

    Examples
    // 4-channel rotation of opposite sounds
    play {
      val p = WhiteNoise.ar(0.05)                     // first source
      val q = Mix(LFSaw.ar(Seq(200, 200.37))) * 0.03  // second source
      // B-format encode 2 signals at opposite sides of the circle
      val enc = PanB2.ar(p, -0.5) + PanB2.ar(q, +0.5)
      val Seq(w, x, y) = (0 to 2).map(enc out _)
      val rot = Rotate2.ar(x, y, MouseX.kr(-1, +1))
      // B-format decode to quad (front-left, front-right, rear-left, rear-right)
      DecodeB2.ar(4, w, rot.xr, rot.yr)
    }
  357. object RunningMax extends ProductReader[RunningMax] with Serializable

    A UGen to measure a signal's maximum value between triggers.

    A UGen to measure a signal's maximum value between triggers.

    The UGen keeps an internal state that reflects the maximum input value observed. When a trigger occurs at the reset input, it first copies the current maximum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.

    Examples
    // illustrate timing
    play {
      val n = BrownNoise.ar
      val t = Impulse.ar(4)
      val r = RunningMax.ar(n, t)
      // value at the moment the reset
      // is triggered
      n.poll(t, "cur")
      // this is the maximum of the
      // recent two input samples
      // (the one during reset and
      // the current one), therefore
      // equal or slightly greater than
      // the 'cur' value
      r.poll(Delay1.ar(t), "max")
      ()
    }
    See also

    RunningMin

    Peak

    RunningSum

  358. object RunningMin extends ProductReader[RunningMin] with Serializable

    A UGen to measure a signal's minimum value between triggers.

    A UGen to measure a signal's minimum value between triggers.

    The UGen keeps an internal state that reflects the minimum input value observed. When a trigger occurs at the reset input, it first copies the current minimum value to its output and then (quasi-simultaneously) resets its internal state to the current input value.

    Examples
    // illustrate timing
    play {
      val n = BrownNoise.ar
      val t = Impulse.ar(4)
      val r = RunningMin.ar(n, t)
      // value at the moment the reset
      // is triggered
      n.poll(t, "cur")
      // this is the minimum of the
      // recent two input samples
      // (the one during reset and
      // the current one), therefore
      // equal or slightly less than
      // the 'cur' value
      r.poll(Delay1.ar(t), "min")
      ()
    }
    See also

    RunningMax

    Peak

    RunningSum

  359. object RunningSum extends ProductReader[RunningSum] with Serializable

    A UGen calculating the sum of an input signal over a sliding window of given number of samples.

    A UGen calculating the sum of an input signal over a sliding window of given number of samples.

    Note: Unlike RunningMin and RunningMax , this is not a trigger based operation, but at any one time, the sum of the past length values is reported, continuously sliding the analysis window.

    Examples
    // poll waveform's DC offset
    play {
      val freq = 441
      val n    = SampleRate.ir / freq
      // mean over period of a pulse with 50% duty is 0.5
      val mean = RunningSum.ar(LFPulse.ar(freq), n) / n
      mean.roundTo(0.01).poll(label = "mean")
      ()
    }
    See also

    Integrator

    Median

    PulseCount

  360. object SOS extends ProductReader[SOS] with Serializable

    A second order filter section (biquad) UGen.

    A second order filter section (biquad) UGen. Filter coefficients are given directly rather than calculated for you. The formula is equivalent to:

    out(i) = a0 * in(i) + a1 * in(i-1) + a2 * in(i-2) + b1 * out(i-1) + b2 * out(i-2)
    Examples
    // same as TwoPole
    play {
      val theta = MouseX.kr(0.2*math.Pi, 0.9*math.Pi)
      val rho   = MouseY.kr(0.6, 0.98)
      val b1    = 2.0 * rho * theta.cos
      val b2    = -(rho.squared)
      SOS.ar(WhiteNoise.ar(Seq(0.05, 0.05)), 1.0, 0.0, 0.0, b1, b2)
    }
    // used as control signal
    play {
      val theta = MouseX.kr(0.2*math.Pi, math.Pi)
      val rho   = MouseY.kr(0.6, 0.99)
      val b1    = 2.0 * rho * theta.cos
      val b2    = -(rho.squared)
      val vib   = SOS.kr(LFSaw.kr(3.16), 1.0, 0.0, 0.0, b1, b2)
      SinOsc.ar(vib * 200 + 600) * 0.2
    }
    See also

    FOS

  361. object SampleDur extends ProductReader[SampleDur] with Serializable

    A UGen that reports the server's current (audio) sample period in seconds.

    A UGen that reports the server's current (audio) sample period in seconds. This is equivalent to the reciprocal of SampleRate

    Examples
    // print the sample period
    play { SampleDur.ir.poll(0) }
    See also

    SampleRate

    ControlDur

  362. object SampleRate extends ProductReader[SampleRate] with Serializable

    A UGen that reports the server's current (audio) sample rate.

    A UGen that reports the server's current (audio) sample rate. This is equivalent to the reciprocal of SampleDur

    Examples
    // print the sample rate
    play { SampleRate.ir.poll(0) }
    // use a fraction as oscillator frequency
    play {
      val div    = MouseX.kr(512, 2, 1, 0).roundTo(1)
      val change = HPZ1.kr(div).abs
      val freq   = SampleRate.ir / div
      freq.poll(change, label = "freq")
      SinOsc.ar(freq) * 0.1
    }
    See also

    SampleDur

    ControlRate

    RadiansPerSample

  363. object Saw extends ProductReader[Saw] with Serializable

    A band-limited sawtooth wave generator UGen.

    A band-limited sawtooth wave generator UGen.

    Examples
    // modulate frequency
    play { Saw.ar(XLine.kr(40, 4000, 6)) * 0.2 }
    // two saws with different frequencies through resonant filter
    play { RLPF.ar(Saw.ar(Seq(100, 250)) * 0.2, XLine.kr(8000, 400, 6), 0.05) }
    See also

    LFSaw

  364. object Schmidt extends ProductReader[Schmidt] with Serializable

    A Schmidt trigger UGen.

    A Schmidt trigger UGen. Initially it outputs zero. When the input signal rises above hi , its output switches to 1.0, which is hold until the signal falls below lo , switching the output again to 0.0. The produces a kind of hysteresis behavior, preventing heavy oscillations in a noisy system which might occur with a single-threshold trigger.

  365. object ScopeOut extends ProductReader[ScopeOut] with Serializable
  366. object ScopeOut2 extends ProductReader[ScopeOut2] with Serializable
  367. object Select extends ProductReader[Select] with Serializable

    A UGen which selects among a sequence of inputs, according to an index signal.

    A UGen which selects among a sequence of inputs, according to an index signal. Note that, although only one signal of the multi input is let through at a time, still all ugens are continuously running.

    See also

    TWindex

  368. object SendReply extends ProductReader[SendReply] with Serializable

    A UGen which sends an sequence of values from the server to all notified clients upon receiving triggers.

    A UGen which sends an sequence of values from the server to all notified clients upon receiving triggers. The message sent is osc.Message(<(String) msgName>, <(Int) nodeId>, <(Int) replyId>, <(Float) values>*) .

    For sending a single value, SendTrig provides an alternative.

    Note

    The argument order is different from its sclang counterpart.

    See also

    SendTrig

  369. object SendTrig extends ProductReader[SendTrig] with Serializable

    A UGen that sends a value from the server to all notified clients upon receiving triggers.

    A UGen that sends a value from the server to all notified clients upon receiving triggers. The message sent is osc.Message("/tr", <(Int) nodeId>, <(Int) trigId>, <(Float) value>) .

    For sending an array of values, or using an arbitrary reply command, see SendReply .

    Note

    The argument order is different from its sclang counterpart.

    See also

    SendReply

  370. object SetBuf extends ProductReader[SetBuf] with Serializable

    A scalar (init-time) UGen that overwrites contents of a buffer with given values.

    A scalar (init-time) UGen that overwrites contents of a buffer with given values.

    See also

    LocalBuf

    ClearBuf

  371. object SetResetFF extends ProductReader[SetResetFF] with Serializable

    A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0.

    A flip-flop UGen with two inputs, one (set) triggering an output of 1.0, the other (reset) triggering an output of 0.0. Subsequent triggers happening within the same input slot have no effect. If both inputs receive a trigger at the same time, the reset input takes precedence.

    Examples
    // mouse-button toggle
    play {
      // make sure lag is zero, otherwise the output
      // never falls back exactly to zero!
      val set   = MouseButton.kr(lag = 0)
      val reset = Impulse.kr(1)
      val ff    = SetResetFF.kr(set, reset)
      SinOsc.ar(ff.mulAdd(400, 800)) * 0.1
    }
    // limit trigger rate
    play {
      // with a combination of TDelay and SetResetFF
      // we can build a filter that lets triggers
      // pass at a maximum rate.
      val dur   = 1.0  // minimum spacing between triggers
      val in    = Dust.ar(10)  // high frequency trigger
      val lim   = SetResetFF.ar(in, TDelay.ar(in, dur))
      val time  = Timer.ar(lim)
      time.poll(lim, "bang")
      ()
    }
    See also

    ToggleFF

  372. object Shaper extends ProductReader[Shaper] with Serializable

    A waveshaping UGen.

    A waveshaping UGen. Waveshaping is a the process of translating an input signal by indexing a table (buffer).

    Advanced notes: wavetable format:

    Signal: [a0, a1, a2...]
    Wavetable: [2*a0-a1, a1-a0, 2*a1-a2, a2-a1, 2*a2-a3, a3-a2...]

    This strange format is not a standard linear interpolation (integer + frac), but for (integer part -1) and (1+frac)) due to some efficient maths for integer to float conversion in the underlying C code.

    See also

    Index

    WrapIndex

  373. object Silent extends ProductReader[Silent] with Serializable

    A graph element that produces a constant silent (zero) audio-rate output signal.

    A graph element that produces a constant silent (zero) audio-rate output signal.

    See also

    DC

  374. object SinOsc extends ProductReader[SinOsc] with Serializable

    A sinusoidal (sine tone) oscillator UGen.

    A sinusoidal (sine tone) oscillator UGen. This is the same as Osc except that it uses a built-in interpolating sine table of 8192 entries.

    Note that currently (SC 3.7.x), the first frame generated is not zero (i.e. the value of the sine oscillation at time zero) but the value at time 1 / SampleRate.ir .

    Examples
    // plain oscillator
    play { SinOsc.ar(441) * 0.2 }
    // modulate frequency
    play { SinOsc.ar(SinOsc.ar(XLine.kr(1, 1000, 9)).mulAdd(200, 800)) * 0.25 }
    // modulate phase
    play { SinOsc.ar(800, SinOsc.ar(XLine.kr(1, 1000, 9)) * 2*math.Pi) * 0.25 }
    See also

    Osc

    FSinOsc

    SinOscFB

  375. object SinOscFB extends ProductReader[SinOscFB] with Serializable

    A sine oscillator UGen that has phase modulation feedback.

    A sine oscillator UGen that has phase modulation feedback. Its output plugs back into the phase input, allowing a modulation between a sine wave and a sawtooth-like wave. "Over-modulation" causes chaotic oscillation. It may be useful to simulate feedback FM synths.

    Examples
    // mouse-controlled feedback
    play { SinOscFB.ar(441, MouseX.kr(0, math.Pi)) * 0.1 }
    See also

    SinOsc

    FSinOsc

  376. object Slew extends ProductReader[Slew] with Serializable

    A slew rate limiter UGen.

    A slew rate limiter UGen. Limits the slope of an input signal. The slope is expressed in units per second.

    Since the UGen is initialized with the initial value of the input signal, some tricks must be applied to set it to an alternative start value. For example:

    val in = Select.kr(ToggleFF.kr(1), Seq("start".ir, "target".kr))
    Slew.kr(in)  // begins at "start" and moves towards "target"
  377. object Slope extends ProductReader[Slope] with Serializable

    A UGen measuring the slope of signal.

    A UGen measuring the slope of signal. It calculates the rate of change per second of a signal, as given by the following formula:

    out(i) = (in(i) - in(i-1)) * sampleRate

    It thus equal to HPZ1.ar(_) * 2 * SampleRate.ir

  378. object SpecCentroid extends ProductReader[SpecCentroid] with Serializable

    A UGen to measure the spectral centroid.

    A UGen to measure the spectral centroid. Given an FFT chain, this measures the spectral centroid, which is the weighted mean frequency, or the "centre of mass" of the spectrum. (DC is ignored.) This can be a useful indicator of the perceptual brightness of a signal.

    Note that the output frequency is pretty close to the correct value when feeding in a sine signal, but the estimate is usually too high when using for example filtered noise. In that case, you will get better results using SpecPcile at 50%.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    See also

    SpecPcile

  379. object SpecFlatness extends ProductReader[SpecFlatness] with Serializable

    A UGen to measure spectral flatness.

    A UGen to measure spectral flatness. Given an FFT chain this calculates the Spectral Flatness measure, defined as a power spectrum's geometric mean divided by its arithmetic mean. This gives a measure which ranges from approx 0 for a pure sinusoid, to approx 1 for white noise.

    The measure is calculated linearly. For some applications you may wish to convert the value to a decibel scale. Note that this UGen may output NaN when the input is zero (probably due to division by zero). In that case, CheckBadValues can be used to prevent further problems.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

    See also

    CheckBadValues

  380. object SpecPcile extends ProductReader[SpecPcile] with Serializable

    A UGen to find the percentile of a signal's magnitude spectrum.

    A UGen to find the percentile of a signal's magnitude spectrum. Given an FFT chain this calculates the cumulative distribution of the frequency spectrum, and outputs the frequency value which corresponds to the desired percentile. For example, to find the frequency at which 90% of the spectral energy lies below that frequency, you want the 90-percentile, which means the value of percent should be 0.9. The 90-percentile or 95-percentile is often used as a measure of spectral roll-off.

    Note that despite running at control-rate, the output remains constant for each FFT frame. E.g. with an FFT size of 1024 and 50% overlap, a new measure is generated every 512 audio frames, or (at control block size 64) every 8 control blocks.

  381. object Splay extends ProductReader[Splay] with Serializable

    A graph element that spreads a sequence of input channels across a stereo pair of channels.

    A graph element that spreads a sequence of input channels across a stereo pair of channels. This works by feeding each input channel through a dedicated Pan2 UGen, and mixing the results together.

    The stereo panning position from -1 to +1 for each input channel with index ch is calculated by the formula:

    (ch * 2.0 / (num-in-channels - 1) - 1) + center

    Note: the spread argument is currently not implemented, and thus channels will always be distributed with a spread of 1.0.

    See also

    Pan

    SplayAz

  382. object SplayAz extends ProductReader[SplayAz] with Serializable

    A graph element that spreads a sequence of input channels across a ring of output channels.

    A graph element that spreads a sequence of input channels across a ring of output channels. This works by feeding each input channel through a dedicated PanAz UGen, and mixing the results together.

    The panning position of each input channel with index ch is calculated by the formula:

    val pf = 2.0 / (num-in-channels - 1) * (num-out-channels - 1) / num-out-channels
    ch * pf + center

    Note: the spread argument is currently not implemented, and thus channels will always be distributed with a spread of 1.0.

    See also

    PanAz

    Splay

  383. object Spring extends ProductReader[Spring] with Serializable
  384. object Squiz extends ProductReader[Squiz] with Serializable

    A UGen implementing a simplistic pitch-raising algorithm.

    A UGen implementing a simplistic pitch-raising algorithm. It is not meant to sound natural, and its sound is reminiscent of some weird mixture of filter, ring-modulator and pitch-shifter, depending on the input.

    The algorithm works by cutting the signal into fragments (delimited by upwards-going zero-crossings) and squeezing those fragments in the time domain (i.e. simply playing them back faster than they came in), leaving silences in between.

    Examples
    // trigger grains
    play { Squiz.ar(SinOsc.ar(440), MouseX.kr(1, 10, 1), zeroCrossings = MouseY.kr(1, 10)) * 0.1 }

    This is a third-party UGen (MCLDUGens).

  385. object StandardL extends ProductReader[StandardL] with Serializable

    A linear-interpolating sound generator based on the difference equations:

    A linear-interpolating sound generator based on the difference equations:

    x[n+1] = (x[n] + y[n+1]) % 2pi
    y[n+1] = (y[n] + k * sin(x[n])) % 2pi

    The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.

    Examples
    // vary frequency
    play { StandardL.ar(MouseX.kr(20, SampleRate.ir)) * 0.3 }
    // mouse-controlled parameter
    play { StandardL.ar(SampleRate.ir/2, MouseX.kr(0.9, 4)) * 0.3 }
    // as a frequency control
    play { SinOsc.ar(StandardL.ar(40, MouseX.kr(0.9, 4)) * 800 + 900) * 0.4 }
    See also

    StandardN

  386. object StandardN extends ProductReader[StandardN] with Serializable

    A non-interpolating sound generator based on the difference equations:

    A non-interpolating sound generator based on the difference equations:

    x[n+1] = (x[n] + y[n+1]) % 2pi
    y[n+1] = (y[n] + k * sin(x[n])) % 2pi

    The standard map is an area preserving map of a cylinder discovered by the plasma physicist Boris Chirikov.

    Examples
    // vary frequency
    play { StandardN.ar(MouseX.kr(20, SampleRate.ir)) * 0.3 }
    // mouse-controlled parameter
    play { StandardN.ar(SampleRate.ir/2, MouseX.kr(0.9, 4)) * 0.3 }
    // as a frequency control
    play { SinOsc.ar(StandardN.ar(40, MouseX.kr(0.9, 4)) * 800 + 900) * 0.4 }
    See also

    StandardL

  387. object Stepper extends ProductReader[Stepper] with Serializable

    A pulse counting UGen.

    A pulse counting UGen. Each trigger increments a counter which is output as a signal. The counter wraps inside the interval from lo to hi (inclusive). That if you use a lo other than zero, you might want to adjust resetVal as well. Stepper always starts with the value in resetVal , no matter what lo is or whether the reset trigger is high or not.

    Examples
    // arpeggio
    play {
      val tr    = Impulse.ar(10)
      val step  = Stepper.ar(tr, lo = 4, hi = 16)
      val freq  = step * 100
      SinOsc.ar(freq) * AmpComp.ar(freq) * 0.1
    }
    See also

    PulseCount

  388. object StereoConvolution2L extends ProductReader[StereoConvolution2L] with Serializable

    A frequency domain stereo convolution UGen, capable of performing linear cross-fades between kernel updates.

    A frequency domain stereo convolution UGen, capable of performing linear cross-fades between kernel updates. When receiving a trigger, there is a linear cross-fade between the old kernel the new buffer contents. It operates similar to Convolution2L , however uses two buffers and outputs a stereo signal, resulting in better CPU usage than two discrete instances of Convolution2L as this way one FFT transformation per period is saved.

    Warning: This UGen seems currently broken (SC 3.6.3)

    See also

    PartConv

    Convolution2

    Convolution

    Convolution2L

  389. object SubsampleOffset extends ProductReader[SubsampleOffset] with Serializable

    A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.

    A UGen that reports the fractional sample offset of the current Synth from its requested scheduled start.

    When a synth is created from a time stamped osc-bundle, it starts calculation at the next possible block (normally 64 samples). Using an OffsetOut UGen, one can delay the audio so that it matches sample accurately.

    For some synthesis methods, one even needs subsample accuracy. SubsampleOffset provides the information where, within the current sample, the synth was scheduled. It can be used to offset envelopes or resample the audio output.

    Examples
    // print offset
    SynthDef.recv("SubsampleOffset") {
      SubsampleOffset.ir.poll(0, "offset")
    }
    
    // create 2 pulse trains 1 sample apart, move one relatively to the other.
    // when cursor is at the left, the impulses are adjacent, on the right, they are
    // exactly 1 sample apart.
    
    val dt = s.sampleRate.reciprocal // 1 sample delay
    
    val x1, x2 = Synth(s)
    
    // needed to use System.currentTimeMillis with osc.Bundle.secs
    val SECONDS_FROM_1900_TO_1970 = 2208988800L
    
    // We create two identical synths with a delay of half a sample,
    // they should thus report offsets 0.5 apart (plus some floating point noise).
    
    // execute the following three lines together!
    val t0 = System.currentTimeMillis * 0.001 + SECONDS_FROM_1900_TO_1970
    s ! osc.Bundle.secs(t0 + 0.2        , x1.newMsg("SubsampleOffset"))
    s ! osc.Bundle.secs(t0 + 0.2 + dt/2 , x2.newMsg("SubsampleOffset"))
    See also

    ControlRate

    SampleDur

    OffsetOut

  390. object Sum3 extends ProductReader[Sum3] with Serializable

    A UGen to efficiently add three signals together.

    A UGen to efficiently add three signals together. Usually used indirectly through Mix.

    See also

    BinaryOpUGen

    MulAdd

    Sum4

  391. object Sum4 extends ProductReader[Sum4] with Serializable

    A UGen to efficiently add four signals together.

    A UGen to efficiently add four signals together. Usually used indirectly through Mix.

    See also

    BinaryOpUGen

    MulAdd

    Sum3

  392. object Sweep extends ProductReader[Sweep] with Serializable

    A UGen which starts a linear raise from zero each time it is triggered.

    A UGen which starts a linear raise from zero each time it is triggered.

    When speed is one, one gets a continually-updating measurement of the time (in seconds) since the last trigger.

    See also

    Ramp

    Phasor

    Line

  393. object SyncSaw extends ProductReader[SyncSaw] with Serializable

    A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch.

    A sawtooth oscillator UGen that is hard sync'ed to a fundamental pitch. That is, a sawtooth waveform is produced at one frequency, sawFreq , whereas a trigger at a another frequency, syncFreq , resets the phase of the sawtooth to zero.

    This produces an effect similar to moving formants or pulse width modulation. This is not a band limited waveform, so it may alias.

    Examples
    // modulate saw frequency
    play { SyncSaw.ar(100, Line.kr(100, 800, 12)) * 0.2 }
    See also

    Saw

    VarSaw

    LFSaw

  394. object T2A extends ProductReader[T2A] with Serializable

    A UGen that converts a control-rate trigger input into an audio-rate trigger output.

    A UGen that converts a control-rate trigger input into an audio-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The output will have a single sample spike of the input trigger's amplitude at the beginning of the calculation block.

    Examples
    // up-sample control-rate impulses
    play {
      val trig = Impulse.kr(MouseX.kr(1, 100, 1))
      Ringz.ar(T2A.ar(trig), 800, 0.01) * 0.4
    }
    See also

    K2A

    T2K

    Trig

  395. object T2K extends ProductReader[T2K] with Serializable

    A UGen that converts an audio-rate trigger input into a control-rate trigger output.

    A UGen that converts an audio-rate trigger input into a control-rate trigger output. A trigger occurs when a signal changes from less than or equal to zero to greater than zero. The UGen behaves strangely in that for a rising slope input signal, it will report the maximum value seen within the calculation block, but if the slope extends to the next block, it will output that second's block maximum value again instead of waiting for a fall to <= 0.

    Examples
    // down-sample audio-rate dust
    play {
      val trig = T2K.kr(Dust.ar(4))
      Trig.kr(trig, 0.1) * SinOsc.ar(800) * 0.1
    }
    See also

    K2A

    T2K

    Trig

  396. object TBall extends ProductReader[TBall] with Serializable
  397. object TDelay extends ProductReader[TDelay] with Serializable

    A delay UGen for trigger signals.

    A delay UGen for trigger signals. Other than a normal buffer delay, any new trigger arriving in the time between the previous trigger and the passing of the delay time is ignored.

  398. object TDuty extends ProductReader[TDuty] with Serializable

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input, and outputs them as trigger values.

    A UGen which polls results from demand-rate ugens in intervals specified by a duration input, and outputs them as trigger values. A value from the level ugen is demanded and output for one sample (when running at audio-rate) or one block (when running at control-rate) according to a stream of duration values. When there is a trigger at the reset input, the level and the dur input are reset.

    Note

    The argument order is different from its sclang counterpart.

    See also

    Duty

    Demand

    DoneAction

  399. object TExpRand extends ProductReader[TExpRand] with Serializable

    A UGen that generates a new random decimal value each time it is triggered, using an exponential distribution from lo to hi .

    A UGen that generates a new random decimal value each time it is triggered, using an exponential distribution from lo to hi . Values lo and hi must both have the same sign and be non-zero.

    Note: Audio-rate inputs for lo and hi are currently broken in SuperCollider, and will therefore be converted to control-rate inputs.

    Examples
    // random sine frequencies, triggered by mouse button
    play {
      val tr = MouseButton.kr(lag = 0)
      val m  = Mix.fill(10)(SinOsc.ar(TExpRand.kr(200.0, 800.0, tr)))
      m * Linen.kr(tr, sustain = 0.025, release = 2)
    }
    See also

    TRand

    ExpRand

    RandSeed

  400. object TGrains extends ProductReader[TGrains] with Serializable

    Triggers generate grains from a buffer.

    Triggers generate grains from a buffer. Each grain has a Hanning envelope

    (sin2(x) for x from 0 to pi)

    and is panned between two channels of multiple outputs. Warning: Due to a bug (SC 3.6.6), this UGen does not work with LocalBuf but requires a regular buffer.

    See also

    GrainBuf

  401. object TIRand extends ProductReader[TIRand] with Serializable

    A UGen that outputs integer random numbers when triggered.

    A UGen that outputs integer random numbers when triggered. The values have a uniform distribution from lo to hi (inclusive).

    Note: Audio-rate inputs for lo and hi are currently broken in SuperCollider, and will therefore be converted to control-rate inputs.

    Examples
    // random sine frequencies, triggered by mouse button
    play {
      val tr = MouseButton.kr(lag = 0)
      val m  = Mix.fill(10)(SinOsc.ar(TIRand.kr(40, 100, tr).midiCps))
      m * Linen.kr(tr, sustain = 0.025, release = 2)
    }
    See also

    IRand

    TRand

  402. object TRand extends ProductReader[TRand] with Serializable

    A UGen that generates a new random decimal value each time it is triggered, using a uniform distribution from lo to hi .

    A UGen that generates a new random decimal value each time it is triggered, using a uniform distribution from lo to hi .

    Note: Audio-rate inputs for lo and hi are currently broken in SuperCollider, and will therefore be converted to control-rate inputs.

    Examples
    // random sine frequencies, triggered by mouse button
    play {
      val tr = MouseButton.kr(lag = 0)
      val m  = Mix.fill(10)(SinOsc.ar(TRand.kr(200.0, 800.0, tr)))
      m * Linen.kr(tr, sustain = 0.025, release = 2)
    }
    See also

    IRand

    TRand

    ExpRand

    RandSeed

  403. object TWindex extends ProductReader[TWindex] with Serializable

    A UGen providing a probability-weighted index into a sequence upon receiving a trigger.

    A UGen providing a probability-weighted index into a sequence upon receiving a trigger.

    When triggered, returns a random index value based the values of the channels of the prob argument functioning as probabilities. The index is zero based, hence goes from 0 to prob.numOutputs - 1 .

    By default the sequence of probabilities should sum to 1.0, however for convenience, this can be achieved by the ugen when the normalize flag is set to 1 (less efficient).

    See also

    Select

  404. object Timer extends ProductReader[Timer] with Serializable

    A UGen that returns time since last triggered.

    A UGen that returns time since last triggered. The time returned is in seconds and is measured from the last received trigger. Note that currently it seems the initial memory is at -1 sample, so for Impulse.ar(1) the result (at 44.1 kHz) is 2.26757e-05, followed strangely by 1.00002, and then (as expected) 1.0.

    See also

    Sweep

  405. object ToggleFF extends ProductReader[ToggleFF] with Serializable

    A UGen that toggles like a flip-flop between zero and one upon receiving a trigger.

    A UGen that toggles like a flip-flop between zero and one upon receiving a trigger. The flip-flop initially outputs zero and changes to one when the first trigger arrives.

    Examples
    // mouse-button toggle
    play {
      // make sure lag is zero, otherwise the output
      // never falls back exactly to zero!
      val tr = MouseButton.kr(lag = 0)
      val ff = ToggleFF.kr(tr)
      SinOsc.ar(ff.mulAdd(400, 800)) * 0.1
    }
    See also

    SetResetFF

  406. object Trig extends ProductReader[Trig] with Serializable

    A UGen which holds and outputs an input value for a given duration when triggered.

    A UGen which holds and outputs an input value for a given duration when triggered.

    When a trigger occurs at the input, the input value is sampled and output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.

    Warning: The hold-time is subject to a bug that depends on the input signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one actually gets a high signal for five sample frames instead of four.

    Examples
    // hold dust spikes
    play { Trig.ar(Dust.ar(1), 0.2) * SinOsc.ar(800) * 0.2 }
    See also

    Trig1

  407. object Trig1 extends ProductReader[Trig1] with Serializable

    A UGen which outputs a value of 1 for a given duration when triggered.

    A UGen which outputs a value of 1 for a given duration when triggered.

    When a trigger occurs at the input, a value of 1 is output for the specified duration, otherwise zero is output. When a new trigger occurs while this ugens outputs 1, the hold-time is reset to the duration.

    Warning: The hold-time is subject to a bug that depends on the input signal. For example with Trig1.ar(Impulse.ar(0), 4 * SampleDur.ir) one actually gets a high signal for five sample frames instead of four.

    Examples
    // hold dust spikes
    play { Trig1.ar(Dust.ar(1), 0.2) * SinOsc.ar(800) * 0.2 }
    See also

    Trig

  408. object TrigControl extends ProductReader[TrigControl] with Serializable
  409. object TrigControlProxy extends ProductReader[TrigControlProxy] with Serializable
  410. object TwoPole extends ProductReader[TwoPole] with Serializable

    A two pole filter UGen.

    A two pole filter UGen. This provides lower level access to setting of pole location. For general purposes Resonz is better.

    Examples
    // static frequency
    play { TwoPole.ar(WhiteNoise.ar(0.005), 2000, 0.95) }
    // sweeping frequency
    play { TwoPole.ar(WhiteNoise.ar(0.005), XLine.kr(800, 8000, 8), 0.95) }
    // mouse controlled frequency
    play { TwoPole.ar(WhiteNoise.ar(0.005), MouseX.kr(800, 8000, 1), 0.95) }
    See also

    OnePole

    TwoZero

    Resonz

  411. object TwoZero extends ProductReader[TwoZero] with Serializable

    A two zero filter UGen.

    A two zero filter UGen.

    Examples
    // frequency sweep
    play { TwoZero.ar(WhiteNoise.ar(0.125), XLine.kr(20, 20000, 8), 1) }
    See also

    OneZero

    TwoPole

  412. object UGenInGroup
  413. object UnaryOpUGen extends ProductReader[UnaryOpUGen]

    Unary operations are generally constructed by calling one of the methods of GEOps.

    Unary operations are generally constructed by calling one of the methods of GEOps.

    See also

    GEOps

    BinaryOpUGen

  414. object Unpack1FFT extends ProductReader[Unpack1FFT] with Serializable
  415. object VBAP extends ProductReader[VBAP] with Serializable

    A UGen for Vector Base Amplitude Panning (VBAP).

    A UGen for Vector Base Amplitude Panning (VBAP). This allows for equal power panning of a source over an arbitrary array of equidistant speakers. Normally this would be a ring, a dome, or partial dome.

    VBAP was created by Ville Pulkki. For more information on VBAP see http://www.acoustics.hut.fi/research/cat/vbap/ This version of VBAP for SC was ported from the ver. 0.99 PD code by Scott Wilson.

    Examples
    // two-dimensional
    val a = VBAPSetup(2, Seq(0, 45, 90, 135, 180, -135, -90, -45)) // 8 channel ring
    
    val b = Buffer.alloc(s, a.bufferData.size)
    b.setn(a.bufferData)
    
    val x = play {
      val azi = "azi".kr(0)
      val ele = "ele".kr(0)
      val spr = "spr".kr(0)
      VBAP.ar(8, PinkNoise.ar(0.2), b.id, azi, ele, spr)
    }
    
    // test them out
    x.set("azi" -> a.directions(1).azi)
    x.set("azi" -> a.directions(2).azi)
    x.set("azi" -> a.directions(3).azi)
    // ...
    x.set("azi" -> a.directions(7).azi)
    x.set("azi" -> a.directions(0).azi)
    
    // try the spread
    x.set("spr" ->  20)
    x.set("spr" -> 100) // all speakers
    
    x.free(); b.free();

    This is a third-party UGen (VBAPUGens).

    See also

    CircleRamp

  416. object VBAPSetup
  417. object VDiskIn extends ProductReader[VDiskIn] with Serializable

    A UGen to stream in a signal from an audio file with variable playback speed.

    A UGen to stream in a signal from an audio file with variable playback speed. Continuously plays a longer audio file from disk. This requires a buffer to be preloaded with one buffer size of sound. If loop is set to 1, the file will loop.

    Note: The buffer size must be a multiple of (2 * the server's block size). See Buffer#cue for details.

    If the speed is too high, the UGen will not execute, posting a warning.

    See also

    Buffer#cue

    DiskIn

    DiskOut

    PlayBuf

  418. object VOsc extends ProductReader[VOsc] with Serializable
  419. object VOsc3 extends ProductReader[VOsc3] with Serializable
  420. object VarSaw extends ProductReader[VarSaw] with Serializable

    A sawtooth-triangle oscillator UGen with variable duty.

    A sawtooth-triangle oscillator UGen with variable duty. A width of zero produces a sawtooth of falling slope, with an initial phase of zero making it start at +1. A width of 0.5 produces a triangle wave, starting at -1 then raising to +1, then falling again to -1. A width of 1.0 produces a sawtooth of rising slope, starting -1.

    Increasing the initial wave will increase the offset into the waveform. For example, with a phase of 0.5 and a width of 0.5, the result is a triangle waveform that starts at +1.

    There is a strange anomaly for the falling sawtooth (zero width): Instead of starting directly at +1, the first sample is -1 and only from the second sample at +1 the waveform starts falling. In other words, the waveform has a delay of one sample.

    Examples
    // width modulation
    play {
      val freq  = LFPulse.kr(3, 0, 0.3).mulAdd(200, 200)
      val width = LFTri.kr(1.0).mulAdd(0.5, 0.5)
      VarSaw.ar(freq, 0, width) * 0.2
    }
    See also

    Saw

    LFSaw

    SyncSaw

  421. object Vibrato extends ProductReader[Vibrato] with Serializable

    A low frequency oscillator UGen for modelling vibrato.

    A low frequency oscillator UGen for modelling vibrato. It produces a modulating frequency value in Hertz that can be used as the frequency parameter of another UGen.

    By setting more extreme settings, one can get back to the timbres of FM synthesis. One can also add in some noise to the vibrato rate and vibrato size (modulation depth) to make for a more realistic motor pattern.

    The vibrato output is a waveform based on a squared envelope shape with four stages marking out 0.0 to 1.0, 1.0 to 0.0, 0.0 to -1.0, and -1.0 back to 0.0. The vibrato rate determines how quickly one moves through these stages.

    Examples
    // constant setting
    play { SinOsc.ar(Vibrato.ar(DC.ar(400.0), 1, 0.02)) * 0.2 }
    // beat and beatVar mouse control
    play {
      val beat    = MouseX.kr(2.0, 100.0)
      val beatVar = MouseY.kr(0.0, 1.0)
      val freq    = Vibrato.ar(DC.ar(400.0), beat, 0.1, 1.0, 1.0, beatVar, 0.1)
      SinOsc.ar(freq) * 0.2
    }
  422. object Warp1 extends ProductReader[Warp1] with Serializable
  423. object WaveLoss extends ProductReader[WaveLoss] with Serializable

    A UGen which uses zero-crossings to divide an input signal into tiny segments.

    A UGen which uses zero-crossings to divide an input signal into tiny segments. It simply discards a fraction of the segments (replacing them with silence).

    The technique was described in a lecture by Trevor Wishart.

    Examples
    // sine plus noise
    play {
      val sig  = (SinOsc.ar + PinkNoise.ar) * 0.5
      val mode = MouseY.kr(1, 2).roundTo(1)
      WaveLoss.ar(sig, drop = MouseX.kr(0, 40), chunk = 40, mode = mode) * 0.1
    }

    This is a third-party UGen (MCLDUGens).

  424. object WhiteNoise extends ProductReader[WhiteNoise] with Serializable

    A noise generator UGens whose spectrum has equal power at all frequencies.

    A noise generator UGens whose spectrum has equal power at all frequencies. Output values range from -1 to +1 (before being multiplied by mul ). The RMS is approx. -4.8 dB.

    Examples
    // plain noise
    play { WhiteNoise.ar(Seq(0.25, 0.25)) }
    See also

    PinkNoise

    BrownNoise

    GrayNoise

    ClipNoise

    RandSeed

    LFNoise0

    Dust

  425. object Wrap extends ProductReader[Wrap] with Serializable

    A UGen that constrains a signal to a given range, by "wrapping" values outside the range.

    A UGen that constrains a signal to a given range, by "wrapping" values outside the range. This is similar to the wrap2 binary operator but permits both a lower range value lo and an upper range value hi .

    An input value greater than or equal to hi will be wrapped back to (in - hi) % (hi - lo) + lo . An input value less than lo will be wrapped back to hi - (lo - in) % (hi - lo) .

    Examples
    // wrap pulse wave to modulate timbre
    play {
      val hi = SinOsc.ar(0.1).linExp(-1, 1, 0.01, 1.0)
      Wrap.ar(Pulse.ar(300), 0, hi) * 0.2 / hi
    }
    See also

    Fold

    Clip

  426. object WrapIndex extends ProductReader[WrapIndex] with Serializable

    A UGen which reads a single sample value from a buffer at a given index.

    A UGen which reads a single sample value from a buffer at a given index.

    It uses the in argument as index into the buffer, truncating that argument to an integer. Out-of-range index values are wrapped around the valid range. For example, if the buffer has four samples, index 4 is wrapped to index 0, index 5 is wrapped to index 1, index -1 is wrapped to index 3, index -2 is wrapped to index 2, etc.

    While designed for monophonic buffers, it works with multi-channel buffers by treating them as de-interleaved. See the Index UGen for details.

    See also

    Index

    FoldIndex

    IndexL

  427. object WrapOut extends ProductReader[WrapOut] with Serializable

    An element which writes an input signal to a bus, optionally applying a short fade-in.

    An element which writes an input signal to a bus, optionally applying a short fade-in. This is automatically added when using the play { ... } syntax. If the fade time is given, an envelope is added with a control named "gate" which can be used to release the synth. The bus is given by a control named "out" and defaults to zero.

  428. object XFade2 extends ProductReader[XFade2] with Serializable

    An equal power two channel cross fading UGen.

    An equal power two channel cross fading UGen. In center position ( pan = 0 ), both input signals are attenuated by sqrt(0.5) or approx. -3 dB.

    See also

    LinXFade2

    Pan2

    XOut

  429. object XLine extends ProductReader[XLine] with Serializable

    An exponential curve generator UGen that moves from a start value to the end value in a given duration.

    An exponential curve generator UGen that moves from a start value to the end value in a given duration.

    At a given point in time 0 <= t <= dur , the output value is start * (stop/start).pow(t/dur) .

    Warning: It must be ensured that the both start is not zero and start and end have the same sign (e.g. a start of -1 and an end of -0.001 are valid), otherwise the UGen will output a NaN ! While in the case of end being zero the UGen will also output zero, it is recommended to treat this case as pathological as well.

    Warning: Durations greater than around 2.8e6 seconds cause the UGen to misbehave and jump to the end value directly.

    Examples
    // glissando
    play { SinOsc.ar(Line.kr(200, 2000, 10, freeSelf)) * 0.2 }
    See also

    Line

  430. object XOut extends ProductReader[XOut] with Serializable

    A UGen that cross-fades the contents of a bus with an input signal.

    A UGen that cross-fades the contents of a bus with an input signal. A linear cross-fade can go from 0.0 (previous bus contents preserved, no input signal added) via 0.5 (previous signal attenuated by -6 dB, input signal attenuated by -6 dB and added) to 1.0 (contents completely replaced by input signal).

    Examples
    // cross-fade two synths
    val sin = play {
      Out.ar(0, SinOsc.ar(440) * 0.1)
    }
    
    val noise = play(target = sin, addAction = addAfter) {
      XOut.ar(0, PinkNoise.ar(0.1), xfade = "xfade".kr(0))
    }
    
    noise.set("xfade" -> 0.5) // both signals heard
    noise.set("xfade" -> 1.0) // just noise
    noise.set("xfade" -> 0.0) // just sine
    Note

    The argument order is different from its sclang counterpart.

    See also

    In

    Out

    XOut

  431. object ZeroCrossing extends ProductReader[ZeroCrossing] with Serializable

    A pitch estimation UGen based on counting the zero-crossings of the input signal.

    A pitch estimation UGen based on counting the zero-crossings of the input signal. This is a very crude pitch follower, but can be useful in some situations.

    Examples
    // reconstruct sine frequency
    play {
      val f1 = SinOsc.kr(0.2).mulAdd(600, 700).roundTo(100)
      val a  = SinOsc.ar(f1) * 0.1
      val f2 = ZeroCrossing.ar(a)
      f2.poll(10, "estimation")
      val b  = SinOsc.ar(f2) * 0.1
      Seq(a, b)
    }
    See also

    Pitch

  432. object Zip extends ProductReader[Zip] with Serializable

Ungrouped