diff --git a/src/components/monaco/chuck-lang.ts b/src/components/monaco/chuck-lang.ts index 8bc0753..b4e1bee 100644 --- a/src/components/monaco/chuck-lang.ts +++ b/src/components/monaco/chuck-lang.ts @@ -2,14 +2,14 @@ import { monaco } from "./monacoLite"; import { chuck_modules, chuck_libraries } from "./chuck-modules"; -import ckdocJSON from "./ckdoc.json"; +import ckdocJSON from "./output.json"; // Documentation Type for ckdoc interface docType { title: string; - description: string[]; - method: string[]; - example: string[]; + description: string; + functions: string[]; + examples: string[]; link: string; } const ckdoc: { [key: string]: docType } = ckdocJSON; @@ -343,7 +343,8 @@ monaco.languages.registerHoverProvider("chuck", { const token: string = word?.word; // If we have a hover for that word - if (chuck_modules.includes(token)) { + // if (chuck_modules.includes(token)) { + if (ckdoc[token]) { const word_doc: docType = ckdoc[token]; return { // Where to show the hover @@ -359,13 +360,14 @@ monaco.languages.registerHoverProvider("chuck", { value: word_doc.title, }, { - value: word_doc.description.join("\n\n"), + value: word_doc.description, }, { - value: word_doc.method.join("\n\n"), + supportHtml: true, + value: word_doc.functions.join("\n\n"), }, { - value: word_doc.example.join("\n\n"), + value: word_doc.examples.join("\n\n"), }, { value: word_doc.link, diff --git a/src/components/monaco/output.json b/src/components/monaco/output.json new file mode 100644 index 0000000..beddd59 --- /dev/null +++ b/src/components/monaco/output.json @@ -0,0 +1,3819 @@ +{ + "@array": { + "functions": [ + "**Methods:**", + "int **cap**() (deprecated) For historical/compatibilty reasons, .cap() is always equal to .size(); instead of using .cap(), it is recommended to explicitly use .size() or .capacity().", + "int **capacity**(int val) Ensure capacity of the array (number of addressable elements).", + "int **capacity**() Get current capacity of the array (number of addressable elements).", + "void **clear**() Clear the contents of the array.", + "int **erase**(int position) Remove element at 'position' from the array (same as popOut(int)).", + "int **erase**(int begin, int end) Remove element(s) in the range [begin,end).", + "int **erase**(string key) (map only) Erase all elements with the specified key.", + "void **getKeys**(string[] keys) Return all keys found in associative array in keys.", + "int **isInMap**(string key) (map only) test if 'key' is in the map; (historical) this was renamed from .find() to avoid confusion with the vector part of array.", + "void **popBack**() Remove the last element of the array.", + "void **popFront**() Remove the first element of the array.", + "void **popOut**(int position) Remove the element at 'position' from the array (same as erase(int)).", + "void **reset**() Reset array size to 0, set capacity to (at least) 8.", + "void **reverse**() Reverses the array in-place.", + "void **shuffle**() Shuffle the contents of the array.", + "int **size**() Get the number of elements in the array.", + "int **size**(int newSize) Set the size of the array. If the new size is less than the current size, elements will be deleted from the end; if the new size is larger than the current size, 0 or null elements will be added to the end.", + "void **sort**() Sort the contents of the array in ascending order.", + "void **zero**() Zero out the contents of the array; size is unchanged." + ], + "examples": [ + "Examples: \t [array_append.ck](https://chuck.stanford.edu/doc/examples/array/array_append.ck), [array_argument.ck](https://chuck.stanford.edu/doc/examples/array/array_argument.ck), [array_assign.ck](https://chuck.stanford.edu/doc/examples/array/array_assign.ck), [array_associative.ck](https://chuck.stanford.edu/doc/examples/array/array_associative.ck), [array_capacity.ck](https://chuck.stanford.edu/doc/examples/array/array_capacity.ck), [array_dynamic.ck](https://chuck.stanford.edu/doc/examples/array/array_dynamic.ck), [array_erase.ck](https://chuck.stanford.edu/doc/examples/array/array_erase.ck), [array_erase2.ck](https://chuck.stanford.edu/doc/examples/array/array_erase2.ck), [array_mdim.ck](https://chuck.stanford.edu/doc/examples/array/array_mdim.ck), [array_mmixed.ck](https://chuck.stanford.edu/doc/examples/array/array_mmixed.ck), [array_negative.ck](https://chuck.stanford.edu/doc/examples/array/array_negative.ck), [array_range.ck](https://chuck.stanford.edu/doc/examples/array/array_range.ck), [array_resize.ck](https://chuck.stanford.edu/doc/examples/array/array_resize.ck), [array_reverse.ck](https://chuck.stanford.edu/doc/examples/array/array_reverse.ck), [array_shuffle.ck](https://chuck.stanford.edu/doc/examples/array/array_shuffle.ck), [array_sort.ck](https://chuck.stanford.edu/doc/examples/array/array_sort.ck), [array_storage.ck](https://chuck.stanford.edu/doc/examples/array/array_storage.ck), [array_sub_assign.ck](https://chuck.stanford.edu/doc/examples/array/array_sub_assign.ck), [array_zero.ck](https://chuck.stanford.edu/doc/examples/array/array_zero.ck)" + ], + "description": "Storage construct for sequential data of the same type; can also be used as an associative map data structure; also can be used as a stack with << operator to append/push and popBack to pop.", + "title": "**Array**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#@array)" + }, + "ABSaturator": { + "functions": [ + "**Methods:**", + "float **dcOffset**(float arg) Constant linear offset applied to the signal. A small offset will introduce odd harmonics into the distoration spectrum, whereas a zero offset will have only even harmonics.", + "float **dcOffset**() Constant linear offset applied to the signal. A small offset will introduce odd harmonics into the distoration spectrum, whereas a zero offset will have only even harmonics.", + "float **drive**(float arg) Input gain into the distortion section, in decibels. Controls overall amount of distortion.", + "float **drive**() Input gain into the distortion section, in decibels. Controls overall amount of distortion." + ], + "examples": [ + "Examples: \t [ABSaturator.ck](https://chuck.stanford.edu/doc/examples/effects/ABSaturator.ck)" + ], + "description": "Soft clip saturating distortion, based on examples from Abel/Berners' Music 424 course at Stanford.", + "title": "**Absolute Value Saturator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#ABSaturator)" + }, + "ADSR": { + "functions": [ + "**Methods:**", + "float **attackRate**(float value) Set attack rate.", + "float **attackRate**() Get attack rate.", + "dur **attackTime**(dur value) Set attack time.", + "dur **attackTime**() Get attack time.", + "float **decayRate**(float value) Set decay rate.", + "float **decayRate**() Get decay rate.", + "dur **decayTime**(dur value) Set decay time.", + "dur **decayTime**() Get decay time.", + "float **releaseRate**(float value) Set release rate.", + "float **releaseRate**() Get release rate.", + "dur **releaseTime**(dur value) Set release time.", + "dur **releaseTime**() Get release time.", + "void **set**(float attackTime, float decayTime, float sustainLevel, float releaseTime) Set attack, decay, sustain, and release all at once (in seconds).", + "void **set**(dur attackDuration, dur decayDuration, float sustainLevel, dur releaseDuration) Set attack, decay, sustain, and release all at once.", + "int **state**() Get state; attack=0, decay=1, sustain=2, release=3, done=4.", + "float **sustainLevel**(float value) Set sustain level.", + "float **sustainLevel**() Get sustain level.", + "static member variables int ATTACK", + "See **state**() function. Denotes that the envelope is in the attack stage. int DECAY", + "See **state**() function. Denotes that the envelope is in the decay stage. int DONE", + "See **state**() function. Denotes that the envelope has completed all stages. int RELEASE", + "See **state**() function. Denotes that the envelope is in the release stage. int SUSTAIN", + "See **state**() function. Denotes that the envelope is in the sustain stage. [ top ]" + ], + "examples": [ + "Examples: \t [adsr.ck](https://chuck.stanford.edu/doc/examples/basic/adsr.ck), [blit2.ck](https://chuck.stanford.edu/doc/examples/basic/blit2.ck)" + ], + "description": "This Envelope subclass implements a traditional ADSR (Attack, Decay, Sustain, Release) envelope. It responds to simple `keyOn` and `keyOff` messages, keeping track of its state. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**ADSR Envelope**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#ADSR)" + }, + "AI": { + "functions": [], + "examples": [], + "description": "AI class library.", + "title": "**AI Class Library**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#AI)" + }, + "AmbPan3": { + "functions": [ + "**Methods:**", + "float **azimuth**(float arg) Set horizontal angle of point source.", + "float **azimuth**() Get horizontal angle of point source.", + "void **channelMap**(int[] arg) Set the mapping of channels for the amibsonic system.", + "float **elevation**(float arg) Set vertical angle of point source.", + "float **elevation**() Get vertical angle of point source." + ], + "examples": [ + "Examples: \t [AmbPan3-CCRMA.ck](https://chuck.stanford.edu/doc/examples/spatial/AmbPan3-CCRMA.ck)" + ], + "description": "Third-order ambisonics panner (https://en.wikipedia.org/wiki/Ambisonics)", + "title": "**3D Ambisonic Panner**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#AmbPan3)" + }, + "AutoCorr": { + "functions": [ + "**Methods:**", + "int **normalize**(int flag) No description available", + "int **normalize**() No description available", + "float[] **compute**(float[] input, int normalize, float[] output) No description available" + ], + "examples": [ + "Examples: \t [autocorr.ck](https://chuck.stanford.edu/doc/examples/analysis/autocorr.ck)" + ], + "description": "A unit analyzer that computes auto-correlation of the incoming analysis frame.", + "title": "**Autocorrelation**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#AutoCorr)" + }, + "BLT": { + "functions": [ + "**Methods:**", + "float **freq**(float value) Set frequency.", + "float **freq**() Set frequency.", + "int **harmonics**(int value) Set harmonics.", + "int **harmonics**() Get harmonics.", + "float **phase**(float value) Set phase.", + "float **phase**() Get phase." + ], + "examples": [], + "description": "Super-class for band-limited oscillators.", + "title": "**Band-Limited Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#BLT)" + }, + "BPF": { + "functions": [ + "**Methods:**", + "float **Q**(float val) Set filter resonance.", + "float **Q**() Get filter resonance.", + "float **freq**(float val) Set filter center frequency.", + "float **freq**() Set filter center frequency.", + "void **set**(float freq, float Q) Get filter frequency and resonance at the same time." + ], + "examples": [ + "Examples: \t [bpf.ck](https://chuck.stanford.edu/doc/examples/filter/bpf.ck)" + ], + "description": "A bandpass filter (2nd order Butterworth).", + "title": "**Band-Pass Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#BPF)" + }, + "BRF": { + "functions": [ + "**Methods:**", + "float **Q**(float val) Set filter resonance.", + "float **Q**() Get filter resonance.", + "float **freq**(float val) Set filter center frequency.", + "float **freq**() Get filter center frequency.", + "void **set**(float freq, float Q) Set filter frequency and resonance at the same time." + ], + "examples": [ + "Examples: \t [brf.ck](https://chuck.stanford.edu/doc/examples/filter/brf.ck)" + ], + "description": "A band-reject filter (2nd order Butterworth).", + "title": "**Band-Reject Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#BRF)" + }, + "BandedWG": { + "functions": [ + "**Methods:**", + "float **bowMotion**(float value) Set bow motion, [0.0-1.0].", + "float **bowMotion**() Get bow motion, [0.0-1.0].", + "float **bowPressure**(float value) Set bow pressure, [0.0-1.0].", + "float **bowPressure**() Get bow pressure, [0.0-1.0].", + "float **bowRate**(float value) Set bowing rate (seconds).", + "float **bowRate**() Get bowing rate (seconds).", + "float **integrationConstant**(float value) Set integration constant, vibrato frequency.", + "float **integrationConstant**() Get integration constant, vibrato frequency.", + "float **modesGain**(float value) Set amplitude for modes.", + "float **modesGain**() Get amplitude for modes.", + "float **pluck**(float value) Pluck instrument, [0.0-1.0].", + "int **preset**(int value) Set instrument preset, (0-3, see above).", + "int **preset**() Get instrument preset, (0-3, see above).", + "float **startBowing**(float value) Start bowing, [0.0-1.0].", + "float **stopBowing**(float value) Stop bowing, [0.0-1.0].", + "float **strikePosition**(float value) Set strike position, [0.0-1.0].", + "float **strikePosition**() Get strike position, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [band-o-matic.ck](https://chuck.stanford.edu/doc/examples/stk/band-o-matic.ck), [bandedwg.ck](https://chuck.stanford.edu/doc/examples/stk/bandedwg.ck), [bandedwg2.ck](https://chuck.stanford.edu/doc/examples/stk/bandedwg2.ck)" + ], + "description": "This class uses banded waveguide techniques to model a variety of sounds, including bowed bars, glasses, and bowls. For more information, see Essl, G. and Cook, P. 'Banded Waveguides: Towards Physical Modelling of Bar Percussion Instruments', Proceedings of the 1999 International Computer Music Conference. Control Change Numbers: - Bow Pressure = 2 - Bow Motion = 4 - Strike Position = 8 (not implemented) - Vibrato Frequency = 11 - Gain = 1 - Bow Velocity = 128 - Instrument Presets = 16 - Uniform Bar = 0 - Tuned Bar = 1 - Glass Harmonica = 2 - Tibetan Bowl = 3 by Georg Essl, 1999 - 2002. Modified for Stk 4.0 by Gary Scavone.", + "title": "**Banded Waveguide**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#BandedWG)" + }, + "BeeThree": { + "functions": [], + "examples": [ + "Examples: \t [keyboard-organ.ck](https://chuck.stanford.edu/doc/examples/hid/keyboard-organ.ck)" + ], + "description": "STK Hammond-oid organ FM synthesis instrument. This class implements a simple 4 operator topology, also referred to as algorithm 8 of the TX81Z. Algorithm 8 is : 1 --. 2 -\\| +-> Out 3 -/| 4 --. Control Change Numbers: - Operator 4 (feedback) Gain = 2 (.controlOne) - Operator 3 Gain = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Organ**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#BeeThree)" + }, + "BiQuad": { + "functions": [ + "**Methods:**", + "float **a0**(float value) Set filter coefficient.", + "float **a0**() Get filter coefficient.", + "float **a1**(float value) Set filter coefficient.", + "float **a1**() Get filter coefficient.", + "float **a2**(float value) Set filter coefficient.", + "float **a2**() Get filter coefficient.", + "float **b0**(float value) Set filter coefficient.", + "float **b0**() Get filter coefficient.", + "float **b1**(float value) Set filter coefficient.", + "float **b1**() Get filter coefficient.", + "float **b2**(float value) Set filter coefficient.", + "float **b2**() Get filter coefficient.", + "int **eqzs**(int value) Enable equal-gain zeroes.", + "int **norm**(int value) Toggle normalization.", + "int **norm**() Get normalization setting.", + "float **pfreq**(float freq) Set resonance frequency (poles).", + "float **pfreq**() Get resonance frequency (poles).", + "float **prad**(float value) Set Pole radius (values greater than 1 will be unstable).", + "float **prad**() Get pole radius.", + "float **pregain**(float level) Set pregain.", + "float **pregain**() Get pregain.", + "float **zfreq**(float freq) Set notch frequency.", + "float **zfreq**() Get notch frequency.", + "float **zrad**(float value) Set zero radius.", + "float **zrad**() Get zero radius." + ], + "examples": [ + "Examples: \t [wind.ck](https://chuck.stanford.edu/doc/examples/basic/wind.ck), [moe.ck](https://chuck.stanford.edu/doc/examples/basic/moe.ck)" + ], + "description": "A BiQuad (two-pole, two-zero) filter section from STK. A method is provided for creating a resonance in the frequency response while maintaining a constant filter gain.", + "title": "**BiQuadratic Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#BiQuad)" + }, + "Bitcrusher": { + "functions": [ + "**Methods:**", + "int **bits**(int arg) Number of bits to reduce signal to [1-32].", + "int **bits**() Number of bits to reduce signal to [1-32].", + "int **downsample**(int arg) Factor by which to downsample signal by decimation [≥1].", + "int **downsample**() Factor by which to downsample signal by decimation [≥1].", + "int **downsampleFactor**(int arg) Factor by which to downsample signal by decimation [≥1].", + "int **downsampleFactor**() Factor by which to downsample signal by decimation [≥1]." + ], + "examples": [ + "Examples: \t [Bitcrusher.ck](https://chuck.stanford.edu/doc/examples/effects/Bitcrusher.ck)" + ], + "description": "Applies aliased downsampling and sample-width reduction to create a variety of distortion effects.", + "title": "**Bitcrusher Effect**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Bitcrusher)" + }, + "Blit": { + "functions": [], + "examples": [ + "Examples: \t [blit.ck](https://chuck.stanford.edu/doc/examples/basic/blit.ck), [blit2.ck](https://chuck.stanford.edu/doc/examples/basic/blit2.ck), [foo2.ck](https://chuck.stanford.edu/doc/examples/basic/foo2.ck)" + ], + "description": "This class generates a band-limited impulse train using a closed-form algorithm reported by Stilson and Smith in 'Alias-Free Digital Synthesis of Classic Analog Waveforms', 1996. The user can specify both the fundamental frequency of the impulse train and the number of harmonics contained in the resulting signal. The signal is normalized so that the peak value is +/-1.0. If `nHarmonics` is 0, then the signal will contain all harmonics up to half the sample rate. Note, however, that this setting may produce aliasing in the signal when the frequency is changing (no automatic modification of the number of harmonics is performed by the `setFrequency()` function). Original code by Robin Davies, 2005. Revisions by Gary Scavone for STK, 2005.", + "title": "**Band-Limited Impulse Train**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Blit)" + }, + "BlitSaw": { + "functions": [], + "examples": [], + "description": "This class generates a band-limited sawtooth waveform using a closed-form algorithm reported by Stilson and Smith in 'Alias-Free Digital Synthesis of Classic Analog Waveforms', 1996. The user can specify both the fundamental frequency of the sawtooth and the number of harmonics contained in the resulting signal. If `nHarmonics` is 0, then the signal will contain all harmonics up to half the sample rate. Note, however, that this setting may produce aliasing in the signal when the frequency is changing (no automatic modification of the number of harmonics is performed by the `setFrequency()` function). Based on initial code of Robin Davies, 2005. Modified algorithm code by Gary Scavone, 2005.", + "title": "**Band-Limited Sawtooth Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#BlitSaw)" + }, + "BlitSquare": { + "functions": [], + "examples": [], + "description": "This class generates a band-limited square wave signal. It is derived in part from the approach reported by Stilson and Smith in 'Alias-Free Digital Synthesis of Classic Analog Waveforms', 1996. The algorithm implemented in this class uses a SincM function with an even M value to achieve a bipolar bandlimited impulse train. This signal is then integrated to achieve a square waveform. The integration process has an associated DC offset but that is subtracted off the output signal. The user can specify both the fundamental frequency of the waveform and the number of harmonics contained in the resulting signal. If `nHarmonics` is 0, then the signal will contain all harmonics up to half the sample rate. Note, however, that this setting may produce aliasing in the signal when the frequency is changing (no automatic modification of the number of harmonics is performed by the `setFrequency()` function). Based on initial code of Robin Davies, 2005. Modified algorithm code by Gary Scavone, 2005.", + "title": "**Band-Limited Square Wave Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#BlitSquare)" + }, + "BlowBotl": { + "functions": [ + "**Methods:**", + "float **noiseGain**(float value) Set noise component gain, [0.0-1.0].", + "float **noiseGain**() Get noise component gain, [0.0-1.0].", + "float **rate**(float value) Set rate of attack.", + "float **rate**() Get rate of attack.", + "float **startBlowing**(float value) Start blowing, [0.0-1.0].", + "float **stopBlowing**(float value) Stop blowing, [0.0-1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0].", + "float **volume**(float value) Set volume, [0.0-1.0].", + "float **volume**() Get volume, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [blowbotl.ck](https://chuck.stanford.edu/doc/examples/stk/blowbotl.ck), [blowbotl2.ck](https://chuck.stanford.edu/doc/examples/stk/blowbotl2.ck)" + ], + "description": "This class implements a helmholtz resonator (biquad filter) with a polynomial jet excitation (a la Cook). Control Change Numbers: - Noise Gain = 4 - Vibrato Frequency = 11 - Vibrato Gain = 1 - Volume = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Blow Bottle**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#BlowBotl)" + }, + "BlowHole": { + "functions": [ + "**Methods:**", + "float **noiseGain**(float value) Set noise component gain, [0.0-1.0].", + "float **noiseGain**() Get noise component gain, [0.0-1.0].", + "float **pressure**(float value) Set pressure, [0.0-1.0].", + "float **pressure**() Get pressure, [0.0-1.0].", + "float **rate**(float value) Set rate of attack, [0.0-1.0].", + "float **rate**() Get rate of attack, [0.0-1.0].", + "float **reed**(float value) Set reed stiffness, [0.0-1.0].", + "float **reed**() Get reed stiffness, [0.0-1.0].", + "float **startBlowing**(float value) Start blowing, [0.0-1.0].", + "float **stopBlowing**(float value) Stop blowing, [0.0-1.0].", + "float **tonehole**(float value) Set tonehole size, [0.0-1.0].", + "float **tonehole**() Get tonehole size, [0.0-1.0].", + "float **vent**(float value) Set vent frequency, [0.0-1.0].", + "float **vent**() Get vent frequency, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [blowhole.ck](https://chuck.stanford.edu/doc/examples/stk/blowhole.ck), [blowhole2.ck](https://chuck.stanford.edu/doc/examples/stk/blowhole2.ck)" + ], + "description": "This class is based on the clarinet model, with the addition of a two-port register hole and a three-port dynamic tonehole implementation, as discussed by Scavone and Cook (1998). In this implementation, the distances between the reed/register hole and tonehole/bell are fixed. As a result, both the tonehole and register hole will have variable influence on the playing frequency, which is dependent on the length of the air column. In addition, the highest playing freqeuency is limited by these fixed lengths. This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Control Change Numbers: - Reed Stiffness = 2 - Noise Gain = 4 - Tonehole State = 11 - Register State = 1 - Breath Pressure = 128 Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Blow Hole**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#BlowHole)" + }, + "Bowed": { + "functions": [ + "**Methods:**", + "float **bowPosition**(float value) Set bow position, [0.0-1.0].", + "float **bowPosition**() Get bow position, [0.0-1.0].", + "float **bowPressure**(float value) Set bow pressure, [0.0-1.0].", + "float **bowPressure**() Get bow pressure, [0.0-1.0].", + "float **startBowing**(float value) Start bowing, [0.0-1.0].", + "float **stopBowing**(float value) Stop bowing, [0.0-1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0].", + "float **volume**(float value) Set volume, [0.0-1.0].", + "float **volume**() Get volume, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [bowed.ck](https://chuck.stanford.edu/doc/examples/stk/bowed.ck), [bowed2.ck](https://chuck.stanford.edu/doc/examples/stk/bowed2.ck)" + ], + "description": "This class implements a bowed string model, a la Smith (1986), after McIntyre, Schumacher, Woodhouse (1983). This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Control Change Numbers: - Bow Pressure = 2 - Bow Position = 4 - Vibrato Frequency = 11 - Vibrato Gain = 1 - Volume = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Bowed String**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Bowed)" + }, + "Brass": { + "functions": [ + "**Methods:**", + "float **clear**(float value) Clear instrument.", + "float **lip**(float value) Set lip tension, [0.0-1.0].", + "float **lip**() Get lip tension, [0.0-1.0].", + "float **rate**(float value) Set rate of attack (seconds).", + "float **rate**() Get rate of attack (seconds).", + "float **slide**(float value) Set slide length, [0.0-1.0].", + "float **slide**() Get slide length, [0.0-1.0].", + "float **startBlowing**(float value) Start blowing, [0.0-1.0].", + "float **stopBlowing**(float value) Stop blowing, [0.0-1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0].", + "float **volume**(float value) Set volume, [0.0-1.0].", + "float **volume**() Get volume, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [brass.ck](https://chuck.stanford.edu/doc/examples/stk/brass.ck), [brass2.ck](https://chuck.stanford.edu/doc/examples/stk/brass2.ck)" + ], + "description": "This class implements a simple brass instrument waveguide model, a la Cook (TBone, HosePlayer). This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Control Change Numbers: - Lip Tension = 2 - Slide Length = 4 - Vibrato Frequency = 11 - Vibrato Gain = 1 - Volume = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Brass**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Brass)" + }, + "CKDoc": { + "functions": [ + "**Methods:**", + "void **addGroup**(Type[] types, string name, string shortName, string description) Add a group of types to be documented, including group 'name', a 'shortName' to be used for any files, and a group 'description'.", + "void **addGroup**(string[] typeNames, string name, string shortName, string description) Add a group of types (by type name) to be documented, including group 'name', a 'shortName' to be used for any files, and a group 'description'.", + "void **addGroupExternal**(string name, string URL, string description, string longDesc) Add a group documention at an external URL location.", + "void **clear**() Clear all added groups.", + "string **examplesRoot**(string path) Set the examples directory root path; returns what was set.", + "string **examplesRoot**() Get the current examples directory root path.", + "string **genCSS**() Generate CSS; return as string.", + "void **genGroups**(string[] results) Generate documentation for all added groups, return each in a separate entry.", + "string **genIndex**(string indexTitle) Generate top-level index; return as string.", + "string **genType**(Type type) Generate documentation for a single Type.", + "string **genType**(string typeName) Generate documentation for a single Type (by name).", + "int **numGroups**() Get the number of groups added.", + "int **outputFormat**(int which) Set which output format to use; see CKDoc.HTML, CKDoc.TEXT, CKDoc.MARKDOWN, CKDoc.JSON.", + "int **outputFormat**() Set which output format is selected; see CKDoc.HTML, CKDoc.TEXT, CKDoc.MARKDOWN, CKDoc.JSON.", + "int **outputToDir**(string path, string indexTitle) Generate everything as files into the output directory." + ], + "examples": [], + "description": "A ChucK documentation generator. Based on Spencer Salazar's ckdoc utility.", + "title": "**ChucK Documentation Generator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/utils.html#CKDoc)" + }, + "CNoise": { + "functions": [ + "**Methods:**", + "float **fprob**(float fprob) Probability [0-1] used for calculating XOR noise.", + "string **mode**(string mode) Noise synthesis mode. Supported modes are \"white\", \"pink\", \"flip\", and \"xor\"." + ], + "examples": [], + "description": "A noise generator with multiple noise synthesis modes.", + "title": "**Colored Noise Generator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#CNoise)" + }, + "Centroid": { + "description": "A unit analyzer that computes the spectral centroid from a magnitude spectrum (either from incoming UAna or manually given), and outputs a single number.", + "examples": [ + "Examples: \t [centroid.ck](https://chuck.stanford.edu/doc/examples/ai/features/centroid.ck), [feature-extract.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/feature-extract.ck), [genre-classify.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/genre-classify.ck)" + ], + "functions": [ + "**Methods:**", + "float **compute**(float[] input) Manually computes the centroid from a float array." + ], + "title": "**Spectral Centroid Analysis**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#Centroid)" + }, + "Chorus": { + "functions": [ + "**Methods:**", + "dur **baseDelay**(dur value) Set base delay.", + "dur **baseDelay**() Get base delay.", + "void **max**(dur baseDelay, float modDepth) No description available", + "float **mix**(float value) Set effect mix.", + "float **mix**() Get effect mix.", + "float **modDepth**(float value) Set modulation depth.", + "float **modDepth**() Get modulation depth.", + "float **modFreq**(float value) Set modulation frequency.", + "float **modFreq**() Get modulation frequency." + ], + "examples": [ + "Examples: \t [chorus.ck](https://chuck.stanford.edu/doc/examples/effects/chorus.ck)" + ], + "description": "A chorus effect. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Chorus Effect**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Chorus)" + }, + "Chroma": { + "functions": [ + "**Methods:**", + "float **compute**(float[] input, float[] output) Manually computes the Chroma of the input (an FFT spectrum), and stores the results in the output array (Chroma coefficients).", + "int **highOctNum**(int high_oct_num) Set the highest octave number for Chroma analysis.", + "int **highOctNum**() Get the highest octave number for Chroma analysis.", + "int **lowOctNum**(int low_oct_num) Set the lowest octave number for Chroma analysis.", + "int **lowOctNum**() Get the lowest octave number for Chroma analysis.", + "float **sampleRate**(float sample_rate) Set the sample rate for Chroma analysis.", + "float **sampleRate**() Get the sample rate for Chroma analysis." + ], + "examples": [ + "Examples: \t [chroma.ck](https://chuck.stanford.edu/doc/examples/ai/features/chroma.ck)" + ], + "description": "A unit analyzer that computes the Chroma features from a magnitude spectrum (either from an incoming UAna, or given manually), and outputs a vector of coefficients.", + "title": "**Chroma Feature Analyzer**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#Chroma)" + }, + "Chugen": { + "functions": [], + "examples": [ + "Examples: \t [chugen.ck](https://chuck.stanford.edu/doc/examples/extend/chugen.ck)" + ], + "description": "Base class for user-created in-language unit generators.", + "title": "**User-Created UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Chugen)" + }, + "Chugraph": { + "functions": [], + "examples": [ + "Examples: \t [chugraph.ck](https://chuck.stanford.edu/doc/examples/extend/chugraph.ck), [dinky.ck](https://chuck.stanford.edu/doc/examples/class/dinky.ck), [try.ck](https://chuck.stanford.edu/doc/examples/class/try.ck), [ks-chord.ck](https://chuck.stanford.edu/doc/examples/deep/ks-chord.ck)" + ], + "description": "Base class for subgraph-based user-created in-language unit generators.", + "title": "**Subgraph-Based UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Chugraph)" + }, + "Clarinet": { + "functions": [ + "**Methods:**", + "float **clear**(float value) Clear instrument.", + "float **noiseGain**(float value) Set noise component gain, [0.0-1.0].", + "float **noiseGain**() Get noise component gain, [0.0-1.0].", + "float **pressure**(float value) Set pressure, [0.0-1.0].", + "float **pressure**() Get pressure, [0.0-1.0].", + "float **rate**(float value) Set rate of attack (seconds).", + "float **rate**() Get rate of attack (seconds).", + "float **reed**(float value) Set reed stiffness, [0.0-1.0].", + "float **reed**() Get reed stiffness, [0.0-1.0].", + "float **startBlowing**(float value) Start blowing, [0.0-1.0].", + "float **stopBlowing**(float value) Stop blowing, [0.0-1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [clarinet.ck](https://chuck.stanford.edu/doc/examples/stk/clarinet.ck), [clarinet2.ck](https://chuck.stanford.edu/doc/examples/stk/clarinet2.ck), [polyfony2.ck](https://chuck.stanford.edu/doc/examples/midi/polyfony2.ck)" + ], + "description": "This class implements a simple clarinet physical model, as discussed by Smith (1986), McIntyre, Schumacher, Woodhouse (1983), and others. This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Control Change Numbers: - Reed Stiffness = 2 - Noise Gain = 4 - Vibrato Frequency = 11 - Vibrato Gain = 1 - Breath Pressure = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Clarinet**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Clarinet)" + }, + "ConsoleInput": { + "functions": [ + "**Methods:**", + "int **can_wait**() (internal) used by virtual machine for synthronization.", + "string **getLine**() Return the next line of input as a string.", + "int **more**() Return whether there is more input to read.", + "Event **prompt**() Return an Event to wait on.", + "Event **prompt**(string what) Print a prompt text and return an Event to wait on." + ], + "examples": [ + "Examples: \t [readline.ck](https://chuck.stanford.edu/doc/examples/string/readline.ck), [word2vec-prompt.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/word2vec-prompt.ck), [poem-ungenerate.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/poem-ungenerate.ck)" + ], + "description": "(Terminal only) a utility for prompting user input on the command line.", + "title": "**Console Input Utility**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/utils.html#ConsoleInput)" + }, + "CurveTable": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients." + ], + "examples": [ + "Examples: \t [GenX-CurveTable-test.ck](https://chuck.stanford.edu/doc/examples/special/GenX-CurveTable-test.ck)" + ], + "description": "Constructs a wavetable composed of segments of variable times, values, and curvatures. Coefficients are specified as a single linear array of triplets of [ time, value, curvature ] followed by a final duple of [ time, value ] to specify the final value of the table. time values are expressed in unitless, ascending values. For curvature equal to 0, the segment is a line; for curvature less than 0, the segment is a convex curve; for curvature greater than 0, the segment is a concave curve.", + "title": "**Curve Table**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#CurveTable)" + }, + "DCT": { + "functions": [ + "**Methods:**", + "int **size**(int size) Set the DCT size.", + "int **size**() Get the DCT size.", + "void **spectrum**(float[] buffer) Manually retrieve the results of a transform.", + "void **transform**(float[] from) Manually take DCT (as opposed to using .upchuck() / upchuck operator).", + "float[] **window**(float[] win) Set/get the transform window/size.", + "int **windowSize**() Get the current window size." + ], + "examples": [ + "Examples: \t [dct.ck](https://chuck.stanford.edu/doc/examples/analysis/dct.ck)" + ], + "description": "Computes the Discrete Cosine Transform on incoming audio samples, and outputs the result via its UAnaBlob as real values in the D.C. spectrum. A buffering mechanism maintains the previous DCT size # of samples, allowing DCT to be taken at any point in time, on demand (via .upchuck() or by upchucking a downstream UAna; see UAna documentation). The window size (along with an arbitrary window shape) is controlled via the .window method. The hop size is complete dynamic, and is throttled by how time is advanced.", + "title": "**Discrete Cosine Transform**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#DCT)" + }, + "Delay": { + "functions": [ + "**Methods:**", + "void **clear**() Clear delay line.", + "dur **delay**(dur value) Set length of delay.", + "dur **delay**() Get length of delay.", + "dur **max**(dur value) Set max delay (buffer size).", + "dur **max**() Get max delay (buffer size)." + ], + "examples": [ + "Examples: \t [comb.ck](https://chuck.stanford.edu/doc/examples/basic/comb.ck), [plu.ck](https://chuck.stanford.edu/doc/examples/deep/plu.ck)" + ], + "description": "A non-interpolating digital delay-line. A fixed maximum length of 4095 and a delay of zero is set using the default constructor. Alternatively, the delay and maximum length can be set during instantiation with an overloaded constructor. A non-interpolating delay line is typically used in fixed delay-length applications, such as for reverberation. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Digital Delay Line**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Delay)" + }, + "DelayA": { + "functions": [ + "**Methods:**", + "void **clear**() Clear delay line.", + "dur **delay**(dur value) Set length of delay.", + "dur **delay**() Get length of delay.", + "dur **max**(dur value) Set max delay (buffer size).", + "dur **max**() Get max delay (buffer size)." + ], + "examples": [ + "Examples: \t [ks-chord.ck](https://chuck.stanford.edu/doc/examples/deep/ks-chord.ck)" + ], + "description": "A fractional-length digital delay-line using a first-order allpass filter. A fixed maximum length of 4095 and a delay of 0.5 is set using the default constructor. Alternatively, the delay and maximum length can be set during instantiation with an overloaded constructor. An allpass filter has unity magnitude gain but variable phase delay properties, making it useful in achieving fractional delays without affecting a signal's frequency magnitude response. In order to achieve a maximally flat phase delay response, the minimum delay possible in this implementation is limited to a value of 0.5. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**All-Pass Interpolating Delay Line**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#DelayA)" + }, + "DelayL": { + "functions": [ + "**Methods:**", + "void **clear**() Clear delay line.", + "dur **delay**(dur value) Set length of delay.", + "dur **delay**() Get length of delay.", + "dur **max**(dur value) Set max delay (buffer size).", + "dur **max**() Get max delay (buffer size)." + ], + "examples": [ + "Examples: \t [delay.ck](https://chuck.stanford.edu/doc/examples/basic/delay.ck), [i-robot.ck](https://chuck.stanford.edu/doc/examples/basic/i-robot.ck), [we-robot.ck](https://chuck.stanford.edu/doc/examples/multi/we-robot.ck), [xcorr.ck](https://chuck.stanford.edu/doc/examples/analysis/xcorr.ck), [poem-i-feel.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/poem-i-feel.ck)" + ], + "description": "A fractional-length digital delay-line using first-order linear interpolation. A fixed maximum length of 4095 and a delay of zero is set using the default constructor. Alternatively, the delay and maximum length can be set during instantiation with an overloaded constructor. Linear interpolation is an efficient technique for achieving fractional delay lengths, though it does introduce high-frequency signal attenuation to varying degrees depending on the fractional delay setting. The use of higher order Lagrange interpolators can typically improve (minimize) this attenuation characteristic. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Linear Interpolating Delay Line**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#DelayL)" + }, + "Dyno": { + "functions": [ + "**Methods:**", + "dur **attackTime**(dur aTime) Set duration for the envelope to move linearly from current value to the absolute value of the signal's amplitude.", + "dur **attackTime**() Get duration for the envelope to move linearly from current value to the absolute value of the signal's amplitude.", + "void **compress**() Set parameters to default compressor values: slopeAbove = 0.5, slopeBelow = 1.0, thresh = 0.5, attackTime = 5 ms, releaseTime = 500 ms, externalSideInput = 0 (false)", + "void **duck**() Set parameters to default ducker values: slopeAbove = 0.5, slopeBelow = 1.0, thresh = 0.5, attackTime = 10 ms, releaseTime = 1000 ms, externalSideInput = 1 (true)", + "void **expand**() Set parameters to default expander values: slopeAbove = 2.0, slopeBelow = 1.0, thresh = 0.5, attackTime = 20 ms, releaseTime = 400 ms, externalSideInput = 0 (false)", + "int **externalSideInput**(int externalSideInput) Set to true to cue the amplitude envelope off sideInput instead of the input signal. Note that this means you will need to manually set sideInput every so often.", + "int **externalSideInput**() Get externalSideInput state. If set to true, the amplitude envelope will be cued off sideInput instead of the input signal. Note that this means you will need to manually set sideInput every so often.", + "void **gate**() Set parameters to default noise gate values: slopeAbove = 1.0, slopeBelow = 1.0E08, thresh = 0.1, attackTime = 11 ms, releaseTime = 100 ms, externalSideInput = 0 (false)", + "void **limit**() Set parameters to default limiter values: slopeAbove = 0.1, slopeBelow = 1.0, thresh = 0.5, attackTime = 5 ms, releaseTime = 300 ms, externalSideInput = 0 (false)", + "float **ratio**(float ratio) An alternate way of setting slopeAbove and slopeBelow; sets slopeBelow to 1.0 and slopeAbove to 1.0 / ratio.", + "float **ratio**() Get the ratio set by .ratio(float); slopeBelow to 1.0 and slopeAbove to 1.0 / ratio.", + "dur **releaseTime**(dur rTime) Set duration for the envelope to decay down to around 1/10 of its current amplitude, if not brought back up by the signal.", + "dur **releaseTime**() Get duration for the envelope to decay down to around 1/10 of its current amplitude, if not brought back up by the signal.", + "float **sideInput**(float sideInput) If externalSideInput is set to true, replace the signal being processed as the input to the amplitude envelope.", + "float **sideInput**() If externalSideInput is set to true, replaces the signal being processed as the input to the amplitude envelope.", + "float **slopeAbove**(float slopeAbove) Set the slope of the output gain vs the input envelope's level when the envelope is above thresh.", + "float **slopeAbove**() Get the slope of the output gain vs the input envelope's level when the envelope is above thresh.", + "float **slopeBelow**(float slopeBelow) Set the slope of the output gain vs the input envelope's level when the envelope is below thresh.", + "float **slopeBelow**() Get the slope of the output gain vs the input envelope's level when the envelope is below thresh.", + "float **thresh**(float thresh) Set threshold, above which to stop using slopeBelow and start using slopeAbove to determine output gain vs input gain.", + "float **thresh**() Get threshold, above which to stop using slopeBelow and start using slopeAbove to determine output gain vs input gain." + ], + "examples": [ + "Examples: \t [Dyno-compress.ck](https://chuck.stanford.edu/doc/examples/special/Dyno-compress.ck), [Dyno-duck.ck](https://chuck.stanford.edu/doc/examples/special/Dyno-duck.ck), [Dyno-limit.ck](https://chuck.stanford.edu/doc/examples/special/Dyno-limit.ck)" + ], + "description": "A dynamics processor. Includes presets for limiter, compressor, expander, noise gate, and ducker.", + "title": "**Dynamics Processor**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#Dyno)" + }, + "Echo": { + "functions": [ + "**Methods:**", + "dur **delay**(dur value) Set length of echo.", + "dur **delay**() Get length of echo.", + "dur **max**(dur value) Set max delay (buffer size).", + "dur **max**() Get max delay (buffer size).", + "float **mix**(float value) Set mix level (wet/dry).", + "float **mix**() Get mix level (wet/dry)." + ], + "examples": [ + "Examples: \t [echo.ck](https://chuck.stanford.edu/doc/examples/basic/echo.ck), [rhodey.ck](https://chuck.stanford.edu/doc/examples/stk/rhodey.ck), [wurley2.ck](https://chuck.stanford.edu/doc/examples/stk/wurley2.ck)" + ], + "description": "An echo effect. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Echo Effect**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Echo)" + }, + "Elliptic": { + "functions": [ + "**Methods:**", + "float **atten**(float arg) Set filter attenuation in dB. Default 90.0.", + "float **atten**() Get filter attenuation in dB.", + "void **bpf**(float stop, float hip, float lop) Create a band-pass filter.", + "int **bypass**(int arg) Set switch bypass. 1 is on, 0 is off. Default 0.", + "int **bypass**() Get switch bypass. 1 is on, 0 is off.", + "void **hpf**(float stop, float pass) Create a high-pass filter.", + "void **lpf**(float stop, float pass) Create a low-pass filter.", + "float **ripple**(float arg) Set filter ripple in dB. Default 0.2.", + "float **ripple**() Get filter ripple in dB." + ], + "examples": [ + "Examples: \t [Elliptic-help.ck](https://chuck.stanford.edu/doc/examples/filter/Elliptic-help.ck)" + ], + "description": "Elliptic implements cascaded IIR filters and a built-in elliptical filter design. It is capable of low-pass, high-pass, or bandpass filtering with very steep slopes. The atten determines how much of the signal is attenuated outside the passband. Elliptic filters come with a trade-off for their steep slopes: they have a certain amount of ripple outside the passbands. A very small ripple (0.1 or 0.2 dB) produces very little ringing, whereas a large ripple (eg. 20 dB) produces a very strong harmonic ring. The filter design algorithm sometimes can't fulfill the design criteria -- a particular combination of cutoff frequencies, ripple, and attenuation. If that happens, the user is warned that the filter is not initialized, and the filter is bypassed. This may happen, for instance, if you ask for a very steep attenuation with very low ripple.", + "title": "**Elliptic Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Elliptic)" + }, + "Envelope": { + "description": "This class implements a simple envelope generator which is capable of ramping to a target value by a specified rate. It also responds to simple `keyOn` and `keyOff` messages, ramping to 1.0 on `keyOn` and to 0.0 on `keyOff`. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "examples": [ + "Examples: \t [envelope.ck](https://chuck.stanford.edu/doc/examples/basic/envelope.ck), [chirp2.ck](https://chuck.stanford.edu/doc/examples/basic/chirp2.ck), [say-chu.ck](https://chuck.stanford.edu/doc/examples/deep/say-chu.ck)" + ], + "functions": [ + "**Methods:**", + "dur **duration**(dur value) Set duration to reach target.", + "dur **duration**() Get duration to reach target.", + "int **keyOff**() Get keyOff state.", + "int **keyOff**(int value) Ramp to 0.0.", + "int **keyOn**() Get keyOn state.", + "int **keyOn**(int value) Ramp to 1.0.", + "float **rate**(float value) Set rate of change.", + "float **rate**() Get rate of change.", + "float **target**(float value) Set value to ramp to.", + "float **target**() Get value to ramp to.", + "float **time**(float value) Set time to reach target (in seconds).", + "float **time**() Get time to reach target (in seconds).", + "float **value**(float value) Set immediate value.", + "float **value**() Get immediate value." + ], + "title": "**Envelope UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Envelope)" + }, + "Event": { + "functions": [ + "**Methods:**", + "void **broadcast**() Signal all shreds that are waiting on this event.", + "int **can_wait**() Can the event can be waited on? (internal) used by virtual machine for synchronization.", + "void **signal**() Signal one shred that is waiting on this event.", + "void **waiting_on**() (internal) used by virtual machine to be notified when a shred starts waiting on this Event." + ], + "examples": [ + "Examples: \t [broadcast.ck](https://chuck.stanford.edu/doc/examples/event/broadcast.ck), [signal.ck](https://chuck.stanford.edu/doc/examples/event/signal.ck), [signal4.ck](https://chuck.stanford.edu/doc/examples/event/signal4.ck), [event-extend.ck](https://chuck.stanford.edu/doc/examples/event/event-extend.ck), [event-extend2.ck](https://chuck.stanford.edu/doc/examples/event/event-extend2.ck), [event-x-bpm-1.ck](https://chuck.stanford.edu/doc/examples/event/event-x-bpm-1.ck), [event-x-bpm-2.ck](https://chuck.stanford.edu/doc/examples/event/event-x-bpm-2.ck)" + ], + "description": "A mechanism for precise synchronization across shreds.", + "title": "**ChucK Event Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#Event)" + }, + "ExpDelay": { + "functions": [ + "**Methods:**", + "float **ampcurve**(float ampcurve) Set steepness of amplitude decay [0.0001-inf].", + "float **ampcurve**() Get steepness of amplitude decay [0.0001-inf].", + "dur **delay**(dur delay) Set duration of delay.", + "dur **delay**() Get duration of delay.", + "float **durcurve**(float durcurve) Set steepness of delay curve [0.0001-inf]: 1 = steady <1 = starts fast and slows down >1 = starts slow and speeds up.", + "float **durcurve**() Get steepness of delay curve [0.0001-inf].", + "dur **max**(dur max) Set maximum possible delay duration.", + "dur **max**() Get maximum possible delay duration.", + "float **mix**(float mix) Set dry/wet mix [0-1].", + "float **mix**() Get dry/wet mix [0-1].", + "int **reps**(int reps) Set number of repetitions.", + "int **reps**() Get number of repetitions." + ], + "examples": [ + "Examples: \t [ExpDelay.ck](https://chuck.stanford.edu/doc/examples/effects/ExpDelay.ck)" + ], + "description": "Feedback delay at exponentially changing delay times.", + "title": "**Exponential Delay**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#ExpDelay)" + }, + "ExpEnv": { + "functions": [ + "**Methods:**", + "dur **T60**(dur arg) Set T60 delay time (time for sounds to decay by 60dB.", + "dur **T60**() Get T60 delay time (time for sounds to decay by 60dB.", + "int **keyOn**(int arg) No description available", + "float **radius**(float arg) No description available", + "float **radius**() No description available", + "float **value**(float arg) No description available", + "float **value**() No description available" + ], + "examples": [ + "Examples: \t [ExpEnv.ck](https://chuck.stanford.edu/doc/examples/effects/ExpEnv.ck), [ExpEnv-modes.ck](https://chuck.stanford.edu/doc/examples/effects/ExpEnv-modes.ck)" + ], + "description": "ChucK Simple Decaying Exponential Envelope UGen Simple single time constant exponential decay, applied to any signal passed through it. Obeys: value, T60, radius, and keyOn Especially useful for Modal synthesis. One of these for each mode: SinOsc s => ExpEnv e => dac; Also useful for noise excitation pulse, using it like: Noise n => ExpEnv e => dac;.", + "title": "**Exponential Envelope**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#ExpEnv)" + }, + "FFT": { + "functions": [ + "**Methods:**", + "int **size**(int size) Set the FFT-size.", + "int **size**() Get the FFT-size.", + "void **spectrum**(complex[] buffer) Manually retrieve the results of a transform.", + "void **transform**(float[] from) Manually take FFT (as opposed to using .upchuck() / upchuck operator)", + "float[] **window**(float[] win) Set/get the transform window/size.", + "int **windowSize**() Get the current window size." + ], + "examples": [ + "Examples: \t [fft.ck](https://chuck.stanford.edu/doc/examples/analysis/fft.ck), [fft2.ck](https://chuck.stanford.edu/doc/examples/analysis/fft2.ck), [fft3.ck](https://chuck.stanford.edu/doc/examples/analysis/fft3.ck), [ifft.ck](https://chuck.stanford.edu/doc/examples/analysis/ifft.ck), [feature-extract.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/feature-extract.ck), [genre-classify.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/genre-classify.ck)" + ], + "description": "Computes the Fast Fourier Transform on incoming audio samples, and outputs the result via its UAnaBlob as both the complex spectrum and the magnitude spectrum. A buffering mechanism maintains the previous FFTsize # of samples, allowing FFT's to be taken at any point in time, on demand (via .upchuck() or by upchucking a downstream UAna. The window size (along with an arbitrary window shape) is controlled via the .window method. The hop size is complete dynamic, and is throttled by how time is advanced.", + "title": "**Fast Fourier Transform**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#FFT)" + }, + "FIR": { + "functions": [ + "**Methods:**", + "int **bpHetero**(float freq) Cosine modulate lowpass filter to freq.", + "float **coeff**(int idx, float coeff) Set filter idx's coefficient to coeff.", + "float **coeff**(int idx) Set filter idx's coefficient.", + "int **gaussian**(float cutoff_freq) Create a gaussian lowpass filter with cutoff cutoff_freq.", + "int **hpHetero**() Cosine modulate lowpass filter to 1/2 the sample rate.", + "int **order**(int arg) Set filter's order.", + "int **order**() Get filter's order.", + "int **sinc**(float cutoff_freq) Create a sinc lowpass filter with cutoff cutoff_freq." + ], + "examples": [ + "Examples: \t [FIR-convolve-homer.ck](https://chuck.stanford.edu/doc/examples/filter/FIR-convolve-homer.ck), [FIR-greyhole-down-up-decimate.ck](https://chuck.stanford.edu/doc/examples/filter/FIR-greyhole-down-up-decimate.ck), [FIR-sinc-explicit.ck](https://chuck.stanford.edu/doc/examples/filter/FIR-sinc-explicit.ck)" + ], + "description": "Yo! This here is a ChugIn for ChucK. It's a general-purpose FIR filter. You make a new one: FIR myFilter; Then specify order: N => myFilter.order;.", + "title": "**Finite Impulse Response Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#FIR)" + }, + "FM": { + "functions": [ + "**Methods:**", + "float **afterTouch**(float value) Set aftertouch, [0.0-1.0].", + "float **afterTouch**() Get aftertouch, [0.0-1.0].", + "float **controlOne**(float value) Set control one [instrument specific].", + "float **controlOne**() Get control one [instrument specific].", + "float **controlTwo**(float value) Set control two [instrument specific].", + "float **controlTwo**() Get control two [instrument specific].", + "float **getFMTableGain**(int index) Get table gain lookup.", + "float **getFMTableSusLevel**(int index) Get sustain level lookup.", + "float **getFMTableTime**(int index) Get table time lookup.", + "float **lfoDepth**(float value) Set modulation depth, [0.0-1.0].", + "float **lfoDepth**() Get modulation depth, [0.0-1.0].", + "float **lfoSpeed**(float value) Set modulation speed (Hz).", + "float **lfoSpeed**() Get modulation speed (Hz).", + "float **op4Feedback**(float value) Set operator 4 feedback.", + "float **op4Feedback**() Get operator 4 feedback.", + "float **opADSR**(int opNum, float attack, float decay, float sustain, float release) Set operator ADSR: attack (sec), decay (sec), sustain [0.0-1.0], release (sec).", + "float **opAM**(int opNum, float value) Set operator amplitude modulation.", + "float **opAM**(int opNum) Get operator amplitude modulation.", + "float **opGain**(int opNum, float value) Set operator gain.", + "float **opGain**(int opNum) Get gperator gain.", + "float **opRatio**(int opNum, float ratio) Set operator frequency ratio.", + "float **opRatio**(int opNum) Get operator frequency ratio.", + "float **opWave**(int opNum, int wave) Set operator waveform [1-8]." + ], + "examples": [], + "description": "STK FM synthesis super class. You should NOT need to use this UGen directly. Please refer to the documentation on FM subclasses instead. This class controls an arbitrary number of waves and envelopes, determined via a constructor argument. Control Change Numbers: - Control One = 2 - Control Two = 4 - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK FM Synthesis**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#FM)" + }, + "FMVoices": { + "functions": [ + "**Methods:**", + "float **adsrTarget**(float value) Set ADSR targets, [0.0-1.0].", + "float **adsrTarget**() Get ADSR targets, [0.0-1.0].", + "float **spectralTilt**(float value) Set spectral tilt, [0.0-1.0].", + "float **spectralTilt**() Get spectral tilt, [0.0-1.0].", + "float **vowel**(float value) Set vowel, [0.0-1.0].", + "float **vowel**() Get vowel, [0.0-1.0]." + ], + "examples": [], + "description": "STK singing FM synthesis instrument. This class implements 3 carriers and a common modulator, also referred to as algorithm 6 of the TX81Z. Algorithm 6 is : ___//->1 -\\ 4-||-->2 - +-> Out ___\\->3 -// Control Change Numbers: - Vowel = 2 (.controlOne) - Spectral Tilt = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**FM Voices**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#FMVoices)" + }, + "FeatureCollector": { + "functions": [], + "examples": [ + "Examples: \t [feature-extract.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/feature-extract.ck), [genre-classify.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/genre-classify.ck), [concat.ck](https://chuck.stanford.edu/doc/examples/analysis/concat.ck)" + ], + "description": "Turns UAna input into a single feature vector, upon .upchuck()", + "title": "**UAna Feature Collector**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#FeatureCollector)" + }, + "FileIO": { + "description": "File input and output utilities for reading, writing, seeking, etc. See examples for usage.", + "examples": [ + "Examples: \t [chout.ck](https://chuck.stanford.edu/doc/examples/io/chout.ck), [read-float.ck](https://chuck.stanford.edu/doc/examples/io/read-float.ck), [read-int.ck](https://chuck.stanford.edu/doc/examples/io/read-int.ck), [read-line.ck](https://chuck.stanford.edu/doc/examples/io/read-line.ck), [read-str.ck](https://chuck.stanford.edu/doc/examples/io/read-str.ck), [read-tokens.ck](https://chuck.stanford.edu/doc/examples/io/read-tokens.ck), [seek.ck](https://chuck.stanford.edu/doc/examples/io/seek.ck), [write.ck](https://chuck.stanford.edu/doc/examples/io/write.ck), [write2.ck](https://chuck.stanford.edu/doc/examples/io/write2.ck), [write-auto.ck](https://chuck.stanford.edu/doc/examples/io/write-auto.ck), [read-byte.ck](https://chuck.stanford.edu/doc/examples/io/read-byte.ck), [write-byte.ck](https://chuck.stanford.edu/doc/examples/io/write-byte.ck)" + ], + "functions": [ + "**Methods:**", + "string **autoExtension**() Get auto extension for \"special:auto\" filename generation (applicable to file writing only).", + "string **autoPrefix**() Get auto prefix for \"special:auto\" filename generation (applicable to file writing only).", + "void **autoPrefixExtension**(string prefix, string extension) Set auto prefix and extension for \"special:auto\" filename generation (applicable to file writing only).", + "void **close**() Close (and flush) the currently open file.", + "string[] **dirList**() Get an array of file names in an open directory.", + "int **eof**() Return whether end-of-file has been reached; the opposite of .more().", + "string **filename**() Get current filename.", + "void **flush**() Write any buffered output to file.", + "int **good**() Returns whether the file is ready for reading.", + "int **isDir**() Return if the open file is a directory.", + "int **mode**(int flag) Set file IO mode (IO.MODE_SYNC or IO.MODE_ASYNC).", + "int **mode**() Get file IO mode (IO.MODE_SYNC or IO.MODE_ASYNC).", + "int **more**() Return whether there is more to read; the opposite of .eof().", + "int **open**(string path) Open a file by name (and by default in ASCII mode).", + "int **open**(string path, int flags) Open a file by name with flags (bitwise combinations of IO.READ, IO.WRITE, IO.READ_WRITE, IO_APPEND, IO.ASCII, IO.BINARY).", + "float **readFloat**() Read and return the next floating point value.", + "float **readFloat**(int flags) Read and return the next floating point value; if binary mode: 'flags' denotes the size of float to read (IO.FLOAT32 or IO.FLOAT64).", + "int **readInt**(int flags) Read and return an integer; binary mode: 'flags' specifies int size to read (IO.INT8, IO.INT16, IO.INT32 default to unsigned values; for signed integers use IO.SINT8, IO.SINT16, IO.SINT32).", + "string **readLine**() Read and return the next line from file.", + "void **seek**(int pos) Seek to a specified byte offset in file.", + "int **size**() Return the size of the file in bytes, or -1 if no file is opened or if a directory is opened.", + "int **tell**() Return the byte read offset of the file, or -1 if no file is opened.", + "void **write**(string val) Write a string to file.", + "void **write**(int val) Write an integer to file.", + "void **write**(int val, int flags) Write integer value to file; binary mode: int size specified by 'flags' (IO.INT8, IO.INT16, IO.INT32).", + "void **write**(float val) Write floating point value to file.", + "void **write**(float val, int flags) Write floating point value to file; binary mode: flags indicate float size (IO.FLOAT32 or IO.FLOAT64).", + "string **expandPath**(string path) Expand platform-specific filepath to an absolute path, which is returned. On macOS and Linux expandPath() will attempt to resolve `~` or `~[username]`; on Windows expandPath() will attempt to resolve %USERNAME%. (Known issue: (macOS) expandPath currently introduced an audio click; it recommended to call expandPath() at the beginning; e.g., expanding path ahead of time could avoid a click instead of calling Machine.add() on a filepath with `~`.)" + ], + "title": "**File Input and Output**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#FileIO)" + }, + "FilterBasic": { + "functions": [ + "**Methods:**", + "float **Q**(float val) Set filter resonance.", + "float **Q**() Get filter resonance.", + "float **freq**(float val) Set filter cutoff/center frequency.", + "float **freq**() Get filter cutoff/center frequency.", + "void **set**(float freq, float Q) Set filter frequency and resonance at the same time." + ], + "examples": [], + "description": "Base class for basic filters with a notion of center/cutoff frequency and Q.", + "title": "**Basic Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#FilterBasic)" + }, + "FilterStk": { + "functions": [ + "**Methods:**", + "string **coefs**(string value) No description available" + ], + "examples": [], + "description": "FilterStk is an STK Filter base class inherited by all Stk Filter UGens such as BiQuad, TwoZero, PoleZero, etc. You should NOT need to use this UGen directly. Please refer to the documentation on other filter types instead.", + "title": "**FilterStk Base Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#FilterStk)" + }, + "Flip": { + "functions": [ + "**Methods:**", + "void **output**(float[] buffer) Manually take Flip (as opposed to using .upchuck() / upchuck operator)", + "int **size**(int size) Set the Flip size.", + "int **size**() Get the Flip size.", + "void **transform**(float[] from) Manually take Flip (as opposed to using .upchuck() / upchuck operator).", + "float[] **window**(float[] win) Set/get the transform window/size.", + "int **windowSize**() Get the current window size." + ], + "examples": [ + "Examples: \t [flip.ck](https://chuck.stanford.edu/doc/examples/analysis/flip.ck), [autocorr.ck](https://chuck.stanford.edu/doc/examples/analysis/autocorr.ck), [zerox.ck](https://chuck.stanford.edu/doc/examples/ai/features/zerox.ck)" + ], + "description": "Turn N (size) audio samples into a Unit Analyzer audio analysis frame.", + "title": "**Signal Flip**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#Flip)" + }, + "Flute": { + "functions": [ + "**Methods:**", + "float **clear**(float value) Clear instrument.", + "float **endReflection**(float value) Set end reflection.", + "float **endReflection**() Get end reflection.", + "float **jetDelay**(float value) Set jet delay.", + "float **jetDelay**() Get jet delay.", + "float **jetReflection**(float value) Set jet reflection.", + "float **jetReflection**() Get jet reflection.", + "float **noiseGain**(float value) Set noise component gain, [0.0-1.0].", + "float **noiseGain**() Get noise component gain, [0.0-1.0].", + "float **pressure**(float value) Set pressure, [0.0-1.0].", + "float **pressure**() Get pressure, [0.0-1.0].", + "float **rate**(float value) Set rate of attack (seconds).", + "float **rate**() Get rate of attack (seconds).", + "float **startBlowing**(float value) Start blowing, [0.0-1.0].", + "float **stopBlowing**(float value) Stop blowing, [0.0-1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [flute.ck](https://chuck.stanford.edu/doc/examples/stk/flute.ck)" + ], + "description": "This class implements a simple flute physical model, as discussed by Karjalainen, Smith, Waryznyk, etc. The jet model uses a polynomial, a la Cook. This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Control Change Numbers: - Jet Delay = 2 - Noise Gain = 4 - Vibrato Frequency = 11 - Vibrato Gain = 1 - Breath Pressure = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Flute**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Flute)" + }, + "Flux": { + "functions": [ + "**Methods:**", + "void **reset**() Reset the extractor.", + "float **compute**(float[] lhs, float[] rhs) Manually computes the flux between two frames.", + "float **compute**(float[] lhs, float[] rhs, float[] diff) Manually computes the flux between two frames, and stores the difference in a third array." + ], + "examples": [ + "Examples: \t [flux.ck](https://chuck.stanford.edu/doc/examples/ai/features/flux.ck), [flux0.ck](https://chuck.stanford.edu/doc/examples/ai/features/flux0.ck)" + ], + "description": "A unit analyzer that computes the spectral flux between successive magnitude spectra (via incoming UAna, or given manually), and outputs a single number.", + "title": "**Spectral Flux Analyzer**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#Flux)" + }, + "FoldbackSaturator": { + "functions": [ + "**Methods:**", + "float **index**(float arg) The index that the signal is multiplied by after it is inverted against the threshold. Defaults to 2.0.", + "float **index**() The index that the signal is multiplied by after it is inverted against the threshold. Defaults to 2.0.", + "float **makeupGain**(float arg) The amount of makeup gain applied to the signal after processing, multiplied against the reciprocal of the threshold. Defaults to 1.0.", + "float **makeupGain**() The amount of makeup gain applied to the signal after processing, multiplied against the reciprocal of the threshold. Defaults to 1.0.", + "float **threshold**(float arg) The threshold (positive and negative) that the signal is inverted against as it is passed. Defaults to 0.6.", + "float **threshold**() The threshold (positive and negative) that the signal is inverted against as it is passed. Defaults to 0.6." + ], + "examples": [ + "Examples: \t [FoldbackSaturator-index.ck](https://chuck.stanford.edu/doc/examples/effects/FoldbackSaturator-index.ck), [FoldbackSaturator-threshold.ck](https://chuck.stanford.edu/doc/examples/effects/FoldbackSaturator-threshold.ck)" + ], + "description": "Foldback saturator that inverts a signal and multiplies it by an index as it passes a threshold.", + "title": "**Foldback Saturator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#FoldbackSaturator)" + }, + "FrencHrn": { + "functions": [], + "examples": [ + "Examples: \t [frenchrn-algo2.ck](https://chuck.stanford.edu/doc/examples/stk/frenchrn-algo2.ck)" + ], + "description": "STK-style French Horn FM synthesis instrument. This class implements 3 cascade operators and a 4th modulator with feedback modulation, also referred to as algorithm 2 of the TX81Z. Algorithm 2 is : ____4--\\ 3--+-->>2-->1-->Out Control Change Numbers: - Total Modulator Index = 2 (.controlOne) - Modulator Crossfade = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**French Horn**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#FrencHrn)" + }, + "FullRect": { + "functions": [], + "examples": [], + "description": "A full wave rectifier.", + "title": "**Full Wave Rectifier**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#FullRect)" + }, + "GVerb": { + "functions": [ + "**Methods:**", + "float **bandwidth**() Get the input bandwidth [0 - 1]. Same as damping control, but on the input signal. Default 0.5.", + "float **bandwidth**(float arg) Set the input bandwidth [0 - 1]. Same as damping control, but on the input signal. Default 0.5.", + "float **damping**() Get high frequency rolloff [0 - 1]. 0 damps the reverb signal completely, 1 not at all. Default 0.", + "float **damping**(float arg) Set high frequency rolloff [0 - 1]. 0 damps the reverb signal completely, 1 not at all. Default 0.", + "float **dry**() Get the amount of dry signal [0 - 1]. Default 0.5.", + "float **dry**(float arg) Set the amount of dry signal [0 - 1]. Default 0.5.", + "float **early**() Get the early reflection level [0 - 1]. Default 0.4.", + "float **early**(float arg) Set the early reflection level [0 - 1]. Default 0.4.", + "dur **revtime**(dur arg) Set reverberation time. Default 5::second.", + "dur **revtime**() Get reverberation time.", + "float **roomsize**(float arg) Set room size [1.0 - 300.0]. Default 30.0.", + "float **roomsize**() Get room size [1.0 - 300.0].", + "float **tail**() Get the tail level [0 - 1]. Default 0.5.", + "float **tail**(float arg) Set the tail level [0 - 1]. Default 0.5." + ], + "examples": [ + "Examples: \t [GVerb.ck](https://chuck.stanford.edu/doc/examples/effects/GVerb.ck)" + ], + "description": "GVerb is a very smooth reverberator with the ability to produce very long reverb times. GVERB is based on the original \"gverb/gigaverb\" by Juhana Sadeharju (kouhia at nic.funet.fi). The code for this version was adapted from RTcmix (http:rtcmix.org), which in turn adapted it from the Max/MSP version by Olaf Mtthes (olaf.matthes at gmx.de).", + "title": "**GVerb Reverb**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#GVerb)" + }, + "Gain": { + "functions": [ + "**Methods:**", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode." + ], + "examples": [ + "Examples: \t [i-robot.ck](https://chuck.stanford.edu/doc/examples/basic/i-robot.ck)" + ], + "description": "A gain control unit generator. (All unit generators can already change their own gain; this is an explicit way to add multiple outputs together and scale them.)", + "title": "**Gain Control UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Gain)" + }, + "Gen10": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients." + ], + "examples": [ + "Examples: \t [Gen10-test.ck](https://chuck.stanford.edu/doc/examples/special/Gen10-test.ck)" + ], + "description": "Constructs a lookup table of harmonic partials with specified amplitudes. The amplitude of partial n is specified by the nth element of the coefficients. For example, setting coefs to [ 1 ] will produce a sine wave.", + "title": "**Generalized UGen 10-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#Gen10)" + }, + "Gen17": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients." + ], + "examples": [ + "Examples: \t [Gen17-test.ck](https://chuck.stanford.edu/doc/examples/special/Gen17-test.ck)" + ], + "description": "Constructs a Chebyshev polynomial wavetable with harmonic partials of specified weights. The weight of partial n is specified by the nth element of the coefficients. Primarily used for waveshaping, driven by a SinOsc instead of a Phasor. See http://crca.ucsd.edu/~msp/techniques/v0.08/book-html/node74.html and http://en.wikipedia.org/wiki/Distortion_synthesis for more information.", + "title": "**Generalized UGen 17-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#Gen17)" + }, + "Gen5": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients." + ], + "examples": [ + "Examples: \t [Gen5-test.ck](https://chuck.stanford.edu/doc/examples/special/Gen5-test.ck)" + ], + "description": "Constructs a lookup table composed of sequential exponential curves. For a table with N curves, starting value of y', and value yn for lookup index xn, set the coefficients to [ y', y0, x0, ..., yN-1, xN-1 ]. Note that there must be an odd number of coefficients. If an even number of coefficients is specified, behavior is undefined. The sum of xn for 0 ≤ n < N must be 1. yn = 0 is approximated as 0.000001 to avoid strange results arising from the nature of exponential curves.", + "title": "**Generalized UGen 5-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#Gen5)" + }, + "Gen7": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients." + ], + "examples": [ + "Examples: \t [Gen7-test.ck](https://chuck.stanford.edu/doc/examples/special/Gen7-test.ck)" + ], + "description": "Constructs a lookup table composed of sequential line segments. For a table with N lines, starting value of y', and value yn for lookupindex xn, set the coefficients to [ y', y0, x0, ..., yN-1, xN-1 ]. Note that there must be an odd number of coefficients. If an even number of coefficients is specified, behavior is undefined. The sum of xn for 0 ≤ n < N must be 1.", + "title": "**Generalized UGen 7-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#Gen7)" + }, + "Gen9": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients." + ], + "examples": [ + "Examples: \t [Gen9-test.ck](https://chuck.stanford.edu/doc/examples/special/Gen9-test.ck)" + ], + "description": "Constructs a lookup table of partials with specified amplitudes, phases, and harmonic ratios to the fundamental. Coefficients are specified in triplets of [ ratio, amplitude, phase ] arranged in a single linear array.", + "title": "**Generalized UGen 9-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#Gen9)" + }, + "GenX": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients; meaning is dependent on subclass.", + "float **lookup**(float which) Get lookup table value at index i [ -1, 1 ]; absolute value is used in the range [ -1, 0 )" + ], + "examples": [ + "Examples: \t [readme-GenX.ck](https://chuck.stanford.edu/doc/examples/special/readme-GenX.ck)" + ], + "description": "Ported from rtcmix. See http://www.music.columbia.edu/cmix/makegens.html for more information on the GenX family of UGens. Currently coefficients past the 100th are ignored. Lookup can either be done using the lookup() function, or by driving the table with an input UGen, typically a Phasor. For an input signal between [ -1, 1 ], using the absolute value for [ -1, 0 ), GenX will output the table value indexed by the current input.", + "title": "**Generalized UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#GenX)" + }, + "HMM": { + "functions": [ + "**Methods:**", + "int **generate**(int length, int[] output) Generate a sequence of observations of the given length.", + "int **load**(float[] initiailDistribution, float[][] transitionMatrix, float[][] emissionMatrix) Initialize the HMM model with the given initial state distribution, transition matrix, and emission matrix.", + "int **train**(int numStates, int numEmissions, int[] observations) Train the HMM model with the given observations." + ], + "examples": [ + "Examples: \t [hmm-load.ck](https://chuck.stanford.edu/doc/examples/ai/hmm/hmm-load.ck), [hmm-train.ck](https://chuck.stanford.edu/doc/examples/ai/hmm/hmm-train.ck)" + ], + "description": "A hidden markov model (HMM) utility that generates a sequence of observations based on the training data.", + "title": "**Hidden Markov Model**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#HMM)" + }, + "HPF": { + "functions": [ + "**Methods:**", + "float **Q**(float val) Set filter resonance.", + "float **Q**() Get filter resonance.", + "float **freq**(float val) Set filter cutoff frequency.", + "float **freq**() Get filter cutoff frequency.", + "void **set**(float freq, float Q) Set filter frequency and resonance at the same time." + ], + "examples": [ + "Examples: \t [hpf.ck](https://chuck.stanford.edu/doc/examples/filter/hpf.ck), [rhpf.ck](https://chuck.stanford.edu/doc/examples/filter/rhpf.ck)" + ], + "description": "A resonant high-pass filter (2nd order Butterworth).", + "title": "**High-Pass Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#HPF)" + }, + "HalfRect": { + "functions": [], + "examples": [], + "description": "A half wave rectifier.", + "title": "**Half Wave Rectifier**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#HalfRect)" + }, + "HevyMetl": { + "functions": [], + "examples": [ + "Examples: \t [hevymetl-algo3.ck](https://chuck.stanford.edu/doc/examples/stk/hevymetl-algo3.ck), [hevymetl-dance-now.ck](https://chuck.stanford.edu/doc/examples/stk/hevymetl-dance-now.ck), [hevymetl-trumpet-algo3.ck](https://chuck.stanford.edu/doc/examples/stk/hevymetl-trumpet-algo3.ck)" + ], + "description": "A STK heavy metal FM synthesis instrument. This class implements 3 cascade operators with feedback modulation, also referred to as algorithm 3 of the TX81Z. Algorithm 3 is : ____4--\\ 3-->2-- + -->1-->Out Control Change Numbers: - Total Modulator Index = 2 (.controlOne) - Modulator Crossfade = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Heavy Metal**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#HevyMetl)" + }, + "Hid": { + "description": "Class for interacting with human-interface devices (HIDs) such as keyboards, mice, gamepads, joysticks, etc.", + "examples": [ + "Examples: \t [kb.ck](https://chuck.stanford.edu/doc/examples/hid/kb.ck), [keyboard-organ.ck](https://chuck.stanford.edu/doc/examples/hid/keyboard-organ.ck), [mouse.ck](https://chuck.stanford.edu/doc/examples/hid/mouse.ck), [mouse-abs.ck](https://chuck.stanford.edu/doc/examples/hid/mouse-abs.ck), [mouse-fm.ck](https://chuck.stanford.edu/doc/examples/hid/mouse-fm.ck), [joy.ck](https://chuck.stanford.edu/doc/examples/hid/joy.ck), [joy-fm.ck](https://chuck.stanford.edu/doc/examples/hid/joy-fm.ck), [joy-noise.ck](https://chuck.stanford.edu/doc/examples/hid/joy-noise.ck), [joy-shake.ck](https://chuck.stanford.edu/doc/examples/hid/joy-shake.ck)" + ], + "functions": [ + "**Methods:**", + "int **can_wait**() (internal) used by virtual machine for synthronization.", + "int **good**() Get whether a device has been successfully opened on this HID instance.", + "string **name**() Get the name of the currently open device; return empty string (\"\") if no device is open on this HID instance.", + "int **num**() Get the number of the currently open device; returns -1 if no device is open on this HID instance.", + "int **open**(int type, int num) Open a HID device by device number ('num') and type ('type'). See static member variables for possible types.", + "int **open**(string name) Open a HID device by name.", + "int **openJoystick**(int num) Open a joystick/gamepad by device number.", + "int **openJoystick**(int num, int suppressErrMsg) Open a joystick/gamepad by device number, with option (true/false) to suppress error messages.", + "int **openKeyboard**(int num) Open a keyboard by device number.", + "int **openKeyboard**(int num, int suppressErrMsg) Open a keyboard by device number, with option (true/false) to suppress error messages.", + "int **openMouse**(int num) Open a mouse/trackpad by device number.", + "int **openMouse**(int num, int suppressErrMsg) Open a mouse/trackpad by device number, with option (true/false) to suppress error messages.", + "int **openTiltSensor**() Open a tilt-sensor by device number.", + "void **printerr**(int toPrintOrNot) Set whether to print errors (default is YES).", + "int **read**(int type, int which, HidMsg msg) Read the next HidMsg from device of type 'type' with device id 'which'.", + "int **recv**(HidMsg msg) Receive the next available HidMsg.", + "int **send**(HidMsg msg) Send a HidMsg to device; return whether the operation was successful.", + "dur **globalTiltPollRate**(dur d) Set tilt-sensor poll rate.", + "dur **globalTiltPollRate**() Get tilt-sensor poll rate.", + "int[] **readTiltSensor**() Read tilt-sensor and return as an int array.", + "int **startCursorTrack**() Start cursor tracking; return whether the request was successful.", + "int **stopCursorTrack**() Stop cursor tracking; return whether the request was successful." + ], + "title": "**Human-Interface Device (HID)**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#Hid)" + }, + "HidMsg": { + "description": "Helper class for receiving HID information; e.g., which key was pressed, joystick position, etc.", + "examples": [ + "Examples: \t [kb.ck](https://chuck.stanford.edu/doc/examples/hid/kb.ck), [keyboard-organ.ck](https://chuck.stanford.edu/doc/examples/hid/keyboard-organ.ck), [mouse.ck](https://chuck.stanford.edu/doc/examples/hid/mouse.ck), [mouse-abs.ck](https://chuck.stanford.edu/doc/examples/hid/mouse-abs.ck), [mouse-fm.ck](https://chuck.stanford.edu/doc/examples/hid/mouse-fm.ck), [joy.ck](https://chuck.stanford.edu/doc/examples/hid/joy.ck), [joy-fm.ck](https://chuck.stanford.edu/doc/examples/hid/joy-fm.ck), [joy-noise.ck](https://chuck.stanford.edu/doc/examples/hid/joy-noise.ck), [joy-shake.ck](https://chuck.stanford.edu/doc/examples/hid/joy-shake.ck)" + ], + "functions": [ + "**Methods:**", + "int **isAxisMotion**() Return whether this message is an axis-motion event.", + "int **isButtonDown**() Return whether this message is a button-down event.", + "int **isButtonUp**() Return whether this message is a button-up event.", + "int **isHatMotion**() Return whether this message is a hat-motion event.", + "int **isMouseMotion**() Return whether this message is a mouse-motion event.", + "int **isWheelMotion**() Return whether this message is a wheel-motion event.", + "int **is_axis_motion**() (Deprecated; use .isAxisMotion() instead).", + "int **is_button_down**() (Deprecated; use .isButtonDown() instead).", + "int **is_button_up**() (Deprecated; use .isButtonUp() instead).", + "int **is_hat_motion**() (Deprecated; use .isHatMotion() instead).", + "int **is_mouse_motion**() (Deprecated; use .isMouseMotion() instead)." + ], + "title": "**Human-Interface Device (HID) Message**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#HidMsg)" + }, + "HnkyTonk": { + "functions": [], + "examples": [ + "Examples: \t [honkeytonk-algo1.ck](https://chuck.stanford.edu/doc/examples/stk/honkeytonk-algo1.ck), [honkeytonk-algo3.ck](https://chuck.stanford.edu/doc/examples/stk/honkeytonk-algo3.ck)" + ], + "description": "STK-style Honkey Tonk Piano FM synthesis instrument. This class implements 4 cascade operators with feedback modulation, also referred to as algorithm 1 of the TX81Z. Algorithm 1 is : ____4-->3-->2-->1-->Out Control Change Numbers: - Total Modulator Index = 2 (.controlOne) - Modulator Crossfade = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Honky Tonk Piano**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#HnkyTonk)" + }, + "IDCT": { + "functions": [ + "**Methods:**", + "void **samples**(float[] buffer) Manually get result of previous IDCT.", + "int **size**(int size) Set the IDCT size.", + "int **size**() Get the IDCT size.", + "void **transform**(complex[] from) Manually take IDCT (as opposed to using .upchuck() / upchuck operator).", + "float[] **window**(float[] win) Set/get the transform window/size.", + "int **windowSize**() Get the current window size." + ], + "examples": [], + "description": "Computes the inverse Discrete Cosine Transform on incoming spectral frames (on demand), and overlap-adds the results into its internal buffer, ready to be sent to other UGen's connected via =>. The window size (along with an arbitrary window shape) is controlled via the .window method.", + "title": "**Inverse Discrete Cosine Transform**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#IDCT)" + }, + "IFFT": { + "functions": [ + "**Methods:**", + "void **samples**(float[] buffer) Manually take IFFT (as opposed to using .upchuck() / upchuck operator)", + "int **size**(int size) Set the IFFT-size.", + "int **size**() Get the IFFT-size.", + "void **transform**(complex[] from) Manually take IFFT (as opposed to using .upchuck() / upchuck operator)", + "float[] **window**(float[] win) Set/get the transform window/size.", + "int **windowSize**() Get the current window size." + ], + "examples": [ + "Examples: \t [ifft.ck](https://chuck.stanford.edu/doc/examples/analysis/ifft.ck), [ifft2.ck](https://chuck.stanford.edu/doc/examples/analysis/ifft2.ck), [ifft3.ck](https://chuck.stanford.edu/doc/examples/analysis/ifft3.ck)" + ], + "description": "Computes the inverse Fast Fourier Transform on incoming spectral frames (on demand), and overlap-adds the results into its internal buffer, ready to be sent to other UGen's connected via =>. The window size (along with an arbitrary window shape) is controlled via the .window method.", + "title": "**Inverse Fast Fourier Transform**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#IFFT)" + }, + "IO": { + "functions": [ + "**Methods:**", + "void **close**() Close the currently open IO.", + "int **eof**() Return whether end-of-file has been reached; the opposite of .more().", + "void **flush**() Write any buffered output.", + "int **good**() Returns whether IO is ready for reading.", + "int **mode**(int flag) Set the current IO mode; either IO.MODE_ASYNC or IO.MODE_SYNC.", + "int **mode**() Get the current IO mode; either IO.MODE_ASYNC or IO.MODE_SYNC.", + "int **more**() Return whether there is more to read; the opposite of .eof().", + "float **readFloat**(int flags) Read and return the next floating point value; binary mode: 'flags' denotes the size of float to read (IO.FLOAT32 or IO.FLOAT64).", + "int **readInt**(int flags) Read and return the next integer; binary mode: 'flags' denotes the bit-size of int (IO.INT8, IO.INT16, or IO.INT32).", + "string **readLine**() Read until an end-of-line character.", + "void **write**(string val) Write string 'val'.", + "void **write**(int val) Write integer 'val'.", + "void **write**(float val) Write floating point number 'val'.", + "string **newline**() Newline character; same as IO.nl().", + "string **nl**() Newline character; same as IO.newline()." + ], + "examples": [], + "description": "Base class for other IO classes such as FileIO, StdOut and StdErr. Besides IO.newline(), it’s unlikely you need to use this class directly.", + "title": "**Input/Output Operations**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#IO)" + }, + "Impulse": { + "functions": [ + "**Methods:**", + "float **next**(float next) Set the value of next sample. (Note: if you are using the UGen.last() method to read the output of the impulse, the value set by Impulse.next() does not appear as the output until after the next sample boundary. In this case, there is a consistent 1::samp offset between setting .next(...) and reading that value using .last().)", + "float **next**() Get value of next sample to be generated." + ], + "examples": [ + "Examples: \t [imp.ck](https://chuck.stanford.edu/doc/examples/basic/imp.ck), [comb.ck](https://chuck.stanford.edu/doc/examples/basic/comb.ck), [chant.ck](https://chuck.stanford.edu/doc/examples/deep/chant.ck)" + ], + "description": "An impulse generator. Can be used to set the value of the next sample; default for each sample is 0 if not set. Additionally, this can be used to generate a digital signal, one sample at a time.", + "title": "**Impulse Generator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Impulse)" + }, + "JCRev": { + "functions": [ + "**Methods:**", + "float **mix**(float value) Set mix level.", + "float **mix**() Get mix level." + ], + "examples": [ + "Examples: \t [reverb.ck](https://chuck.stanford.edu/doc/examples/effects/reverb.ck), [otf_06.ck](https://chuck.stanford.edu/doc/examples/otf_06.ck), [otf_07.ck](https://chuck.stanford.edu/doc/examples/otf_07.ck)" + ], + "description": "John Chowning's reverberator class. This class is derived from the CLM NRev function, which is based on the use of networks of simple allpass and comb delay filters. This particular arrangement consists of 6 comb filters in parallel, followed by 3 allpass filters, a lowpass filter, and another allpass in series, followed by two allpass filters in parallel with corresponding right and left outputs. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**John Chowning's Reverberator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#JCRev)" + }, + "KBHit": { + "description": "KBHit (terminal only) is a simple mechanism for capturing keyboard input; for a more flexible mechanism, see HID. (On Linux, KBHit does not require granting device permissions; it works out of the box.)", + "examples": [ + "Examples: \t [kbhit.ck](https://chuck.stanford.edu/doc/examples/hid/kbhit/kbhit.ck), [kbhit2.ck](https://chuck.stanford.edu/doc/examples/hid/kbhit/kbhit2.ck), [clix.ck](https://chuck.stanford.edu/doc/examples/hid/kbhit/clix.ck), [clix2.ck](https://chuck.stanford.edu/doc/examples/hid/kbhit/clix2.ck), [clix3.ck](https://chuck.stanford.edu/doc/examples/hid/kbhit/clix3.ck)" + ], + "functions": [ + "**Methods:**", + "int **can_wait**() (internal) used by virtual machine for synthronization.", + "int **getchar**() Get the ASCII value of the last keyboard press.", + "Event **hit**() Return itself as an Event to wait on; this is largely unnecessary as the KBHit instance can be directly => to 'now'.", + "int **more**() Return whether there are unprocessed KBHit events (e.g., if a user presses multiple keys at once).", + "void **off**() Disable the KBHit.", + "void **on**() Enable the KBHit.", + "void **state**() Get whether the KBHit is currently enabled." + ], + "title": "**Keyboard Hit**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#KBHit)" + }, + "KNN": { + "functions": [ + "**Methods:**", + "void **search**(float[] query, int k, int[] indices) Search for the 'k' nearest neighbors of 'query' and return their corresponding indices.", + "void **search**(float[] query, int k, int[] indices, float[][] observations) Search for the 'k' nearest neighbors of 'query' and return their corresponding indices and observations.", + "int **train**(float[][] x) Train the KNN model with the given observations 'x'", + "void **weigh**(float[] weights) Set the weights for each dimension in the data." + ], + "examples": [ + "Examples: \t [knn-search.ck](https://chuck.stanford.edu/doc/examples/ai/knn/knn-search.ck)" + ], + "description": "A basic k-NN utility that searches for k nearest neighbors from a set of observations / feature vectors. (Also see KNN2. The differrence between KNN and KNN2 is that KNN does not deal with labels whereas KNN2 is designed to work with labels.)", + "title": "**K-Nearest Neighbors**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#KNN)" + }, + "KNN2": { + "functions": [ + "**Methods:**", + "int **predict**(float[] query, int k, float[] prob) Predict the output probabilities 'prob' given unlabeled test input 'query' based on distances to 'k' nearest neighbors.", + "void **search**(float[] query, int k, int[] labels) Search for the 'k' nearest neighbors of 'query' and return their labels.", + "void **search**(float[] query, int k, int[] labels, int[] indices) Search for the 'k' nearest neighbors of 'query' and return their labels and indices.", + "void **search**(float[] query, int k, int[] labels, int[] indices, float[][] observations) Search for the 'k' nearest neighbors of 'query' and return their labels, indices, and observations.", + "int **train**(float[][] x, int[] labels) Train the KNN model with the given observations 'x' and corresponding labels.", + "void **weigh**(float[] weights) Set the weights for each dimension in the data." + ], + "examples": [ + "Examples: \t [knn2-classify.ck](https://chuck.stanford.edu/doc/examples/ai/knn/knn2-classify.ck), [knn2-search.ck](https://chuck.stanford.edu/doc/examples/ai/knn/knn2-search.ck)" + ], + "description": "A k-NN utility that predicts probabilities of class membership based on distances from a test input to its k nearest neighbors. (Also see KNN. The differrence between KNN and KNN2 is that KNN does not deal with labels whereas KNN2 is designed to work with labels.)", + "title": "**K-Nearest Neighbors 2**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#KNN2)" + }, + "KasFilter": { + "functions": [ + "**Methods:**", + "float **accent**(float arg) Sets the amount of waveshaping on the crossfading sine [0 - 1]. 1 is close to regular under-sampling (if no resonance is used).", + "float **accent**() Gets the amount of waveshaping on the crossfading sine [0 - 1]. 1 is close to regular under-sampling (if no resonance is used).", + "float **freq**(float arg) Sets the cutoff frequency. This sets both the frequency at which the two sample & holds sample the input signal and the frequency of the sine that crossfades between them.", + "float **freq**() Gets the cutoff frequency. This sets both the frequency at which the two sample & holds sample the input signal and the frequency of the sine that crossfades between them.", + "float **resonance**(float arg) Sets the resonance, which is implemented as negative feedback [0 - 0.95].", + "float **resonance**() Gets the resonance, which is implemented as negative feedback [0 - 0.95]." + ], + "examples": [ + "Examples: \t [KasFilter.ck](https://chuck.stanford.edu/doc/examples/filter/KasFilter.ck)" + ], + "description": "Under-sampling-based resonant lowpass filter, based on two sample & holds with a cosine crossfading between them. Each S&H samples at the moment it's faded out. The frequency of the crossfading and sampling of the input sets the cutoff. This leads to a infinitely steep cutoff, at the price of aliasing. Negative feedback is used for resonance at the cutoff frequency, a technique that I believe is new here. In addition to the traditional modulation options waveshaping of the crossfading signal is provided. This leads to distortion at the cutoff frequency. At extreme values (and assuming no feedback is used) that makes the effect closer to traditional under-sampling. Linear interpolation is used on the input signal to avoid the S&Hs being quantised to ChucK's sample rate; This technique causes quite a few interesting artifacts that result from the ratio between the frequency of the input and the cutoff frequency. To emphasise those it makes sense to try to minimise artifacts induced by the digital environment itself. Thanks to Rob Hordijk for sharing his insights there.", + "title": "**Kassel Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#KasFilter)" + }, + "KrstlChr": { + "functions": [], + "examples": [ + "Examples: \t [krstlchr-algo7.ck](https://chuck.stanford.edu/doc/examples/stk/krstlchr-algo7.ck)" + ], + "description": "STK-style \"Crystal Choir\" FM synthesis instrument. This class implements 3 parallel operators with being modulated (feedback modulation), also referred to as algorithm 7 of the TX81Z. Algorithm 7 is : 1 -\\ 2 - +-> Out 4-->3 -/ Control Change Numbers: - Total Modulator Index = 2 (.controlOne) - Modulator Crossfade = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Crystal Choir**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#KrstlChr)" + }, + "Kurtosis": { + "functions": [ + "**Methods:**", + "float **compute**(float[] input) Manually computes the kurtosis of a given input array." + ], + "examples": [ + "Examples: \t [kurtosis.ck](https://chuck.stanford.edu/doc/examples/ai/features/kurtosis.ck)" + ], + "description": "A unit analyzer that computes the kurtosis of a given input array, and outputs a single number.", + "title": "**Kurtosis Analysis**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#Kurtosis)" + }, + "LPF": { + "functions": [ + "**Methods:**", + "float **Q**(float val) Set filter resonance.", + "float **Q**() Get filter resonance.", + "float **freq**(float val) Set filter cutoff frequency.", + "float **freq**() Get filter cutoff frequency.", + "void **set**(float freq, float Q) Set filter frequency and resonance at the same time." + ], + "examples": [ + "Examples: \t [lpf.ck](https://chuck.stanford.edu/doc/examples/filter/lpf.ck), [rlpf.ck](https://chuck.stanford.edu/doc/examples/filter/rlpf.ck)" + ], + "description": "A resonant low-pass filter (2nd order Butterworth).", + "title": "**Low-Pass Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#LPF)" + }, + "LiSa": { + "functions": [ + "**Methods:**", + "int **bi**(int voice, int val) For particular voice (arg 1), turn on/off bidirectional playback.", + "int **bi**(int val) For particular voice (arg 1), get bidirectional playback status.", + "int **bi**() Get birectional playback status.", + "void **clear**() Clear recording buffer.", + "dur **duration**(dur val) Set buffer size; required to allocate memory, also resets all parameter values to default.", + "dur **duration**() Get buffer size.", + "float **feedback**(float val) Set feedback amount when overdubbing (loop recording; how much to retain).", + "float **feedback**() Get feedback amount when overdubbing (loop recording; how much to retain).", + "int **getVoice**() Return an available voice (one that is not currently playing). Return -1 if no voice is available.", + "int **getbi**(int voice) Turn on/off bidirectional playback (voice 0).", + "int **loop0**(int val) Turn on/off looping (voice 0).", + "int **loop0**() Get looping status (voice 0).", + "int **loop**(int voice, int val) For particular voice (arg 1), turn on/off looping.", + "int **loop**(int voice) For particular voice (arg 1), get looping status.", + "dur **loopEnd**(int voice, dur val) For particular voice (arg 1), set loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(int voice) For particular voice (arg 1), get loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(dur val) Set loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEnd**() Get loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEndRec**(dur val) Set end point in buffer for loop recording.", + "dur **loopEndRec**() Get end point in buffer for loop recording.", + "int **loopRec**(int val) Turn on/off loop recording.", + "int **loopRec**() Get loop recording status.", + "dur **loopStart**(int voice, dur val) For particular voice (arg 1), set loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(int voice) For particular voice (arg 1), get loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(dur val) Set loop starting point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopStart**() Get loop starting point for playback (voice 0). only applicable when 1 => loop.", + "int **maxVoices**(int val) Set the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "int **maxVoices**() Get the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "float **pan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **pan**(int voice) For particular voice (arg 1), get panning value.", + "float **pan**(float val) For voice 0, set panning value [0.0, number of channels - 1.0].", + "float **pan**() For voice 0, get panning value.", + "int **play**(int voice, int toggle) For particular voice (arg 1), turn on/off sample playback.", + "int **play**(int toggle) Turn on/off sample playback (voice 0)", + "dur **playPos**(int voice, dur val) For particular voice (arg 1), set playback position.", + "dur **playPos**(int voice) For particular voice (arg 1), get playback position.", + "dur **playPos**(dur val) Set playback position (voice 0).", + "dur **playPos**() Get playback position (voice 0).", + "int **playing**(int val) Get playing status.", + "void **rampDown**(int voice, dur val) For particular voice (arg 1), turn off sample playback, with ramp.", + "void **rampDown**(dur val) Turn off sample playback, with ramp (voice 0).", + "void **rampUp**(int voice, dur val) For particular voice (arg 1), turn on sample playback, with ramp.", + "void **rampUp**(dur val) Turn on sample playback, with ramp (voice 0).", + "float **rate**(int voice, float val) For particular voice (arg 1), set playback rate.", + "float **rate**(int voice) For particular voice (arg 1), get playback rate.", + "float **rate**(float val) Set playback rate (voice 0). Note that the int/float type for this method will determine whether the rate is being set (float, for voice 0) or read (int, for voice number).", + "float **rate**() Get playback rate (voice 0).", + "dur **recPos**(dur val) Set record position.", + "dur **recPos**() Get record position.", + "dur **recRamp**(dur val) Set ramping when recording (from 0 to loopEndRec).", + "int **record**(int toggle) Turn recording on and off.", + "int **sync**(int val) Set input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **sync**() Get input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **track**(int val) Identical to sync.", + "int **track**() Identical to sync.", + "dur **value**(int voice, dur val) For particular voice (arg 1), get value from the voice.", + "dur **value**(dur val) Get value from voice 0.", + "float **valueAt**(float val, dur index) Set value directly in record buffer.", + "float **valueAt**(dur index) Get value directly from record buffer.", + "float **voiceGain**(int voice, float val) For particular voice (arg 1), set gain.", + "float **voiceGain**(int voice) Set playback gain (voice 0).", + "float **voicePan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **voicePan**(int voice) For particular voice (arg 1), get panning value." + ], + "examples": [ + "Examples: \t [LiSa-munger1.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-munger1.ck), [LiSa-munger2.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-munger2.ck), [LiSa-munger3.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-munger3.ck), [LiSa-load.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-load.ck), [LiSa-simplelooping.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-simplelooping.ck), [LiSa-trigger.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-trigger.ck), [LiSa-track1.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-track1.ck), [LiSa-track2.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-track2.ck), [LiSa-track3.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-track3.ck), [LiSa-track4.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-track4.ck), [LiSa-track5.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-track5.ck), [LiSa-stereo.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-stereo.ck), [twilight-granular-kb.ck](https://chuck.stanford.edu/doc/examples/special/twilight/twilight-granular-kb.ck), [twilight-granular-kb-interp.ck](https://chuck.stanford.edu/doc/examples/special/twilight/twilight-granular-kb-interp.ck)" + ], + "description": "LiSa provides basic live sampling functionality, and is also often used for granular synthesis. An internal buffer stores samples chucked to LiSa's input. Segments of this buffer can be played back, with ramping and speed/direction control. Multiple voice facility is built in, allowing for a single LiSa object to serve as a source for sample layering and granular textures. by Dan Trueman (2007) See also: a slowly growing tutorial | LiSa examples in the ChucK distribution | video tutorial by Clint Hoagland.", + "title": "**Live Sampling UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#LiSa)" + }, + "LiSa10": { + "functions": [ + "**Methods:**", + "int **bi**(int voice, int val) For particular voice (arg 1), turn on/off bidirectional playback.", + "int **bi**(int val) For particular voice (arg 1), get bidirectional playback status.", + "int **bi**() Get birectional playback status.", + "void **clear**() Clear recording buffer.", + "dur **duration**(dur val) Set buffer size; required to allocate memory, also resets all parameter values to default.", + "dur **duration**() Get buffer size.", + "float **feedback**(float val) Set feedback amount when overdubbing (loop recording; how much to retain).", + "float **feedback**() Get feedback amount when overdubbing (loop recording; how much to retain).", + "int **getVoice**() Return an available voice (one that is not currently playing). Return -1 if no voice is available.", + "int **getbi**(int voice) Turn on/off bidirectional playback (voice 0).", + "int **loop0**(int val) Turn on/off looping (voice 0).", + "int **loop0**() Get looping status (voice 0).", + "int **loop**(int voice, int val) For particular voice (arg 1), turn on/off looping.", + "int **loop**(int voice) For particular voice (arg 1), get looping status.", + "dur **loopEnd**(int voice, dur val) For particular voice (arg 1), set loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(int voice) For particular voice (arg 1), get loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(dur val) Set loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEnd**() Get loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEndRec**(dur val) Set end point in buffer for loop recording.", + "dur **loopEndRec**() Get end point in buffer for loop recording.", + "int **loopRec**(int val) Turn on/off loop recording.", + "int **loopRec**() Get loop recording status.", + "dur **loopStart**(int voice, dur val) For particular voice (arg 1), set loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(int voice) For particular voice (arg 1), get loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(dur val) Set loop starting point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopStart**() Get loop starting point for playback (voice 0). only applicable when 1 => loop.", + "int **maxVoices**(int val) Set the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "int **maxVoices**() Get the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "float **pan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **pan**(int voice) For particular voice (arg 1), get panning value.", + "float **pan**(float val) For voice 0, set panning value [0.0, number of channels - 1.0].", + "float **pan**() For voice 0, get panning value.", + "int **play**(int voice, int toggle) For particular voice (arg 1), turn on/off sample playback.", + "int **play**(int toggle) Turn on/off sample playback (voice 0)", + "dur **playPos**(int voice, dur val) For particular voice (arg 1), set playback position.", + "dur **playPos**(int voice) For particular voice (arg 1), get playback position.", + "dur **playPos**(dur val) Set playback position (voice 0).", + "dur **playPos**() Get playback position (voice 0).", + "int **playing**(int val) Get playing status.", + "void **rampDown**(int voice, dur val) For particular voice (arg 1), turn off sample playback, with ramp.", + "void **rampDown**(dur val) Turn off sample playback, with ramp (voice 0).", + "void **rampUp**(int voice, dur val) For particular voice (arg 1), turn on sample playback, with ramp.", + "void **rampUp**(dur val) Turn on sample playback, with ramp (voice 0).", + "float **rate**(int voice, float val) For particular voice (arg 1), set playback rate.", + "float **rate**(int voice) For particular voice (arg 1), get playback rate.", + "float **rate**(float val) Set playback rate (voice 0). Note that the int/float type for this method will determine whether the rate is being set (float, for voice 0) or read (int, for voice number).", + "float **rate**() Get playback rate (voice 0).", + "dur **recPos**(dur val) Set record position.", + "dur **recPos**() Get record position.", + "dur **recRamp**(dur val) Set ramping when recording (from 0 to loopEndRec).", + "int **record**(int toggle) Turn recording on and off.", + "int **sync**(int val) Set input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **sync**() Get input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **track**(int val) Identical to sync.", + "int **track**() Identical to sync.", + "dur **value**(int voice, dur val) For particular voice (arg 1), get value from the voice.", + "dur **value**(dur val) Get value from voice 0.", + "float **valueAt**(float val, dur index) Set value directly in record buffer.", + "float **valueAt**(dur index) Get value directly from record buffer.", + "float **voiceGain**(int voice, float val) For particular voice (arg 1), set gain.", + "float **voiceGain**(int voice) Set playback gain (voice 0).", + "float **voicePan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **voicePan**(int voice) For particular voice (arg 1), get panning value." + ], + "examples": [], + "description": "A (li)ve (sa)mpling unit generator (10-channel edition); also popularly used for granular synthesis.", + "title": "**Live Sampling UGen 10-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#LiSa10)" + }, + "LiSa16": { + "functions": [ + "**Methods:**", + "int **bi**(int voice, int val) For particular voice (arg 1), turn on/off bidirectional playback.", + "int **bi**(int val) For particular voice (arg 1), get bidirectional playback status.", + "int **bi**() Get birectional playback status.", + "void **clear**() Clear recording buffer.", + "dur **duration**(dur val) Set buffer size; required to allocate memory, also resets all parameter values to default.", + "dur **duration**() Get buffer size.", + "float **feedback**(float val) Set feedback amount when overdubbing (loop recording; how much to retain).", + "float **feedback**() Get feedback amount when overdubbing (loop recording; how much to retain).", + "int **getVoice**() Return an available voice (one that is not currently playing). Return -1 if no voice is available.", + "int **getbi**(int voice) Turn on/off bidirectional playback (voice 0).", + "int **loop0**(int val) Turn on/off looping (voice 0).", + "int **loop0**() Get looping status (voice 0).", + "int **loop**(int voice, int val) For particular voice (arg 1), turn on/off looping.", + "int **loop**(int voice) For particular voice (arg 1), get looping status.", + "dur **loopEnd**(int voice, dur val) For particular voice (arg 1), set loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(int voice) For particular voice (arg 1), get loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(dur val) Set loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEnd**() Get loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEndRec**(dur val) Set end point in buffer for loop recording.", + "dur **loopEndRec**() Get end point in buffer for loop recording.", + "int **loopRec**(int val) Turn on/off loop recording.", + "int **loopRec**() Get loop recording status.", + "dur **loopStart**(int voice, dur val) For particular voice (arg 1), set loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(int voice) For particular voice (arg 1), get loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(dur val) Set loop starting point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopStart**() Get loop starting point for playback (voice 0). only applicable when 1 => loop.", + "int **maxVoices**(int val) Set the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "int **maxVoices**() Get the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "float **pan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **pan**(int voice) For particular voice (arg 1), get panning value.", + "float **pan**(float val) For voice 0, set panning value [0.0, number of channels - 1.0].", + "float **pan**() For voice 0, get panning value.", + "int **play**(int voice, int toggle) For particular voice (arg 1), turn on/off sample playback.", + "int **play**(int toggle) Turn on/off sample playback (voice 0)", + "dur **playPos**(int voice, dur val) For particular voice (arg 1), set playback position.", + "dur **playPos**(int voice) For particular voice (arg 1), get playback position.", + "dur **playPos**(dur val) Set playback position (voice 0).", + "dur **playPos**() Get playback position (voice 0).", + "int **playing**(int val) Get playing status.", + "void **rampDown**(int voice, dur val) For particular voice (arg 1), turn off sample playback, with ramp.", + "void **rampDown**(dur val) Turn off sample playback, with ramp (voice 0).", + "void **rampUp**(int voice, dur val) For particular voice (arg 1), turn on sample playback, with ramp.", + "void **rampUp**(dur val) Turn on sample playback, with ramp (voice 0).", + "float **rate**(int voice, float val) For particular voice (arg 1), set playback rate.", + "float **rate**(int voice) For particular voice (arg 1), get playback rate.", + "float **rate**(float val) Set playback rate (voice 0). Note that the int/float type for this method will determine whether the rate is being set (float, for voice 0) or read (int, for voice number).", + "float **rate**() Get playback rate (voice 0).", + "dur **recPos**(dur val) Set record position.", + "dur **recPos**() Get record position.", + "dur **recRamp**(dur val) Set ramping when recording (from 0 to loopEndRec).", + "int **record**(int toggle) Turn recording on and off.", + "int **sync**(int val) Set input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **sync**() Get input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **track**(int val) Identical to sync.", + "int **track**() Identical to sync.", + "dur **value**(int voice, dur val) For particular voice (arg 1), get value from the voice.", + "dur **value**(dur val) Get value from voice 0.", + "float **valueAt**(float val, dur index) Set value directly in record buffer.", + "float **valueAt**(dur index) Get value directly from record buffer.", + "float **voiceGain**(int voice, float val) For particular voice (arg 1), set gain.", + "float **voiceGain**(int voice) Set playback gain (voice 0).", + "float **voicePan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **voicePan**(int voice) For particular voice (arg 1), get panning value." + ], + "examples": [], + "description": "A (li)ve (sa)mpling unit generator (16-channel edition); also popularly used for granular synthesis.", + "title": "**Live Sampling UGen 16-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#LiSa16)" + }, + "LiSa2": { + "functions": [ + "**Methods:**", + "int **bi**(int voice, int val) For particular voice (arg 1), turn on/off bidirectional playback.", + "int **bi**(int val) For particular voice (arg 1), get bidirectional playback status.", + "int **bi**() Get birectional playback status.", + "void **clear**() Clear recording buffer.", + "dur **duration**(dur val) Set buffer size; required to allocate memory, also resets all parameter values to default.", + "dur **duration**() Get buffer size.", + "float **feedback**(float val) Set feedback amount when overdubbing (loop recording; how much to retain).", + "float **feedback**() Get feedback amount when overdubbing (loop recording; how much to retain).", + "int **getVoice**() Return an available voice (one that is not currently playing). Return -1 if no voice is available.", + "int **getbi**(int voice) Turn on/off bidirectional playback (voice 0).", + "int **loop0**(int val) Turn on/off looping (voice 0).", + "int **loop0**() Get looping status (voice 0).", + "int **loop**(int voice, int val) For particular voice (arg 1), turn on/off looping.", + "int **loop**(int voice) For particular voice (arg 1), get looping status.", + "dur **loopEnd**(int voice, dur val) For particular voice (arg 1), set loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(int voice) For particular voice (arg 1), get loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(dur val) Set loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEnd**() Get loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEndRec**(dur val) Set end point in buffer for loop recording.", + "dur **loopEndRec**() Get end point in buffer for loop recording.", + "int **loopRec**(int val) Turn on/off loop recording.", + "int **loopRec**() Get loop recording status.", + "dur **loopStart**(int voice, dur val) For particular voice (arg 1), set loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(int voice) For particular voice (arg 1), get loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(dur val) Set loop starting point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopStart**() Get loop starting point for playback (voice 0). only applicable when 1 => loop.", + "int **maxVoices**(int val) Set the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "int **maxVoices**() Get the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "float **pan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **pan**(int voice) For particular voice (arg 1), get panning value.", + "float **pan**(float val) For voice 0, set panning value [0.0, number of channels - 1.0].", + "float **pan**() For voice 0, get panning value.", + "int **play**(int voice, int toggle) For particular voice (arg 1), turn on/off sample playback.", + "int **play**(int toggle) Turn on/off sample playback (voice 0)", + "dur **playPos**(int voice, dur val) For particular voice (arg 1), set playback position.", + "dur **playPos**(int voice) For particular voice (arg 1), get playback position.", + "dur **playPos**(dur val) Set playback position (voice 0).", + "dur **playPos**() Get playback position (voice 0).", + "int **playing**(int val) Get playing status.", + "void **rampDown**(int voice, dur val) For particular voice (arg 1), turn off sample playback, with ramp.", + "void **rampDown**(dur val) Turn off sample playback, with ramp (voice 0).", + "void **rampUp**(int voice, dur val) For particular voice (arg 1), turn on sample playback, with ramp.", + "void **rampUp**(dur val) Turn on sample playback, with ramp (voice 0).", + "float **rate**(int voice, float val) For particular voice (arg 1), set playback rate.", + "float **rate**(int voice) For particular voice (arg 1), get playback rate.", + "float **rate**(float val) Set playback rate (voice 0). Note that the int/float type for this method will determine whether the rate is being set (float, for voice 0) or read (int, for voice number).", + "float **rate**() Get playback rate (voice 0).", + "dur **recPos**(dur val) Set record position.", + "dur **recPos**() Get record position.", + "dur **recRamp**(dur val) Set ramping when recording (from 0 to loopEndRec).", + "int **record**(int toggle) Turn recording on and off.", + "int **sync**(int val) Set input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **sync**() Get input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **track**(int val) Identical to sync.", + "int **track**() Identical to sync.", + "dur **value**(int voice, dur val) For particular voice (arg 1), get value from the voice.", + "dur **value**(dur val) Get value from voice 0.", + "float **valueAt**(float val, dur index) Set value directly in record buffer.", + "float **valueAt**(dur index) Get value directly from record buffer.", + "float **voiceGain**(int voice, float val) For particular voice (arg 1), set gain.", + "float **voiceGain**(int voice) Set playback gain (voice 0).", + "float **voicePan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **voicePan**(int voice) For particular voice (arg 1), get panning value." + ], + "examples": [ + "Examples: \t [LiSa-stereo.ck](https://chuck.stanford.edu/doc/examples/special/LiSa-stereo.ck)" + ], + "description": "A (li)ve (sa)mpling unit generator (stereo edition); also popularly used for granular synthesis.", + "title": "**Live Sampling UGen 2-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#LiSa2)" + }, + "LiSa6": { + "functions": [ + "**Methods:**", + "int **bi**(int voice, int val) For particular voice (arg 1), turn on/off bidirectional playback.", + "int **bi**(int val) For particular voice (arg 1), get bidirectional playback status.", + "int **bi**() Get birectional playback status.", + "void **clear**() Clear recording buffer.", + "dur **duration**(dur val) Set buffer size; required to allocate memory, also resets all parameter values to default.", + "dur **duration**() Get buffer size.", + "float **feedback**(float val) Set feedback amount when overdubbing (loop recording; how much to retain).", + "float **feedback**() Get feedback amount when overdubbing (loop recording; how much to retain).", + "int **getVoice**() Return an available voice (one that is not currently playing). Return -1 if no voice is available.", + "int **getbi**(int voice) Turn on/off bidirectional playback (voice 0).", + "int **loop0**(int val) Turn on/off looping (voice 0).", + "int **loop0**() Get looping status (voice 0).", + "int **loop**(int voice, int val) For particular voice (arg 1), turn on/off looping.", + "int **loop**(int voice) For particular voice (arg 1), get looping status.", + "dur **loopEnd**(int voice, dur val) For particular voice (arg 1), set loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(int voice) For particular voice (arg 1), get loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(dur val) Set loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEnd**() Get loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEndRec**(dur val) Set end point in buffer for loop recording.", + "dur **loopEndRec**() Get end point in buffer for loop recording.", + "int **loopRec**(int val) Turn on/off loop recording.", + "int **loopRec**() Get loop recording status.", + "dur **loopStart**(int voice, dur val) For particular voice (arg 1), set loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(int voice) For particular voice (arg 1), get loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(dur val) Set loop starting point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopStart**() Get loop starting point for playback (voice 0). only applicable when 1 => loop.", + "int **maxVoices**(int val) Set the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "int **maxVoices**() Get the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "float **pan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **pan**(int voice) For particular voice (arg 1), get panning value.", + "float **pan**(float val) For voice 0, set panning value [0.0, number of channels - 1.0].", + "float **pan**() For voice 0, get panning value.", + "int **play**(int voice, int toggle) For particular voice (arg 1), turn on/off sample playback.", + "int **play**(int toggle) Turn on/off sample playback (voice 0)", + "dur **playPos**(int voice, dur val) For particular voice (arg 1), set playback position.", + "dur **playPos**(int voice) For particular voice (arg 1), get playback position.", + "dur **playPos**(dur val) Set playback position (voice 0).", + "dur **playPos**() Get playback position (voice 0).", + "int **playing**(int val) Get playing status.", + "void **rampDown**(int voice, dur val) For particular voice (arg 1), turn off sample playback, with ramp.", + "void **rampDown**(dur val) Turn off sample playback, with ramp (voice 0).", + "void **rampUp**(int voice, dur val) For particular voice (arg 1), turn on sample playback, with ramp.", + "void **rampUp**(dur val) Turn on sample playback, with ramp (voice 0).", + "float **rate**(int voice, float val) For particular voice (arg 1), set playback rate.", + "float **rate**(int voice) For particular voice (arg 1), get playback rate.", + "float **rate**(float val) Set playback rate (voice 0). Note that the int/float type for this method will determine whether the rate is being set (float, for voice 0) or read (int, for voice number).", + "float **rate**() Get playback rate (voice 0).", + "dur **recPos**(dur val) Set record position.", + "dur **recPos**() Get record position.", + "dur **recRamp**(dur val) Set ramping when recording (from 0 to loopEndRec).", + "int **record**(int toggle) Turn recording on and off.", + "int **sync**(int val) Set input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **sync**() Get input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **track**(int val) Identical to sync.", + "int **track**() Identical to sync.", + "dur **value**(int voice, dur val) For particular voice (arg 1), get value from the voice.", + "dur **value**(dur val) Get value from voice 0.", + "float **valueAt**(float val, dur index) Set value directly in record buffer.", + "float **valueAt**(dur index) Get value directly from record buffer.", + "float **voiceGain**(int voice, float val) For particular voice (arg 1), set gain.", + "float **voiceGain**(int voice) Set playback gain (voice 0).", + "float **voicePan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **voicePan**(int voice) For particular voice (arg 1), get panning value." + ], + "examples": [], + "description": "A (li)ve (sa)mpling unit generator (6-channel edition); also popularly used for granular synthesis.", + "title": "**Live Sampling UGen 6-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#LiSa6)" + }, + "LiSa8": { + "functions": [ + "**Methods:**", + "int **bi**(int voice, int val) For particular voice (arg 1), turn on/off bidirectional playback.", + "int **bi**(int val) For particular voice (arg 1), get bidirectional playback status.", + "int **bi**() Get birectional playback status.", + "void **clear**() Clear recording buffer.", + "dur **duration**(dur val) Set buffer size; required to allocate memory, also resets all parameter values to default.", + "dur **duration**() Get buffer size.", + "float **feedback**(float val) Set feedback amount when overdubbing (loop recording; how much to retain).", + "float **feedback**() Get feedback amount when overdubbing (loop recording; how much to retain).", + "int **getVoice**() Return an available voice (one that is not currently playing). Return -1 if no voice is available.", + "int **getbi**(int voice) Turn on/off bidirectional playback (voice 0).", + "int **loop0**(int val) Turn on/off looping (voice 0).", + "int **loop0**() Get looping status (voice 0).", + "int **loop**(int voice, int val) For particular voice (arg 1), turn on/off looping.", + "int **loop**(int voice) For particular voice (arg 1), get looping status.", + "dur **loopEnd**(int voice, dur val) For particular voice (arg 1), set loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(int voice) For particular voice (arg 1), get loop ending point for playback. only applicable when .loop(voice, 1).", + "dur **loopEnd**(dur val) Set loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEnd**() Get loop ending point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopEndRec**(dur val) Set end point in buffer for loop recording.", + "dur **loopEndRec**() Get end point in buffer for loop recording.", + "int **loopRec**(int val) Turn on/off loop recording.", + "int **loopRec**() Get loop recording status.", + "dur **loopStart**(int voice, dur val) For particular voice (arg 1), set loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(int voice) For particular voice (arg 1), get loop starting point for playback. only applicable when .loop(voice, 1).", + "dur **loopStart**(dur val) Set loop starting point for playback (voice 0). only applicable when 1 => loop.", + "dur **loopStart**() Get loop starting point for playback (voice 0). only applicable when 1 => loop.", + "int **maxVoices**(int val) Set the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "int **maxVoices**() Get the maximum number of voices allowable; 10 by default (256 is the current hardwired internal limit).", + "float **pan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **pan**(int voice) For particular voice (arg 1), get panning value.", + "float **pan**(float val) For voice 0, set panning value [0.0, number of channels - 1.0].", + "float **pan**() For voice 0, get panning value.", + "int **play**(int voice, int toggle) For particular voice (arg 1), turn on/off sample playback.", + "int **play**(int toggle) Turn on/off sample playback (voice 0)", + "dur **playPos**(int voice, dur val) For particular voice (arg 1), set playback position.", + "dur **playPos**(int voice) For particular voice (arg 1), get playback position.", + "dur **playPos**(dur val) Set playback position (voice 0).", + "dur **playPos**() Get playback position (voice 0).", + "int **playing**(int val) Get playing status.", + "void **rampDown**(int voice, dur val) For particular voice (arg 1), turn off sample playback, with ramp.", + "void **rampDown**(dur val) Turn off sample playback, with ramp (voice 0).", + "void **rampUp**(int voice, dur val) For particular voice (arg 1), turn on sample playback, with ramp.", + "void **rampUp**(dur val) Turn on sample playback, with ramp (voice 0).", + "float **rate**(int voice, float val) For particular voice (arg 1), set playback rate.", + "float **rate**(int voice) For particular voice (arg 1), get playback rate.", + "float **rate**(float val) Set playback rate (voice 0). Note that the int/float type for this method will determine whether the rate is being set (float, for voice 0) or read (int, for voice number).", + "float **rate**() Get playback rate (voice 0).", + "dur **recPos**(dur val) Set record position.", + "dur **recPos**() Get record position.", + "dur **recRamp**(dur val) Set ramping when recording (from 0 to loopEndRec).", + "int **record**(int toggle) Turn recording on and off.", + "int **sync**(int val) Set input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **sync**() Get input mode; (0) input is recorded to internal buffer, (1) input sets playback position [0,1] (phase value between loopStart and loopEnd for all active voices), (2) input sets playback position, interpreted as a time value in samples (only works with voice 0)", + "int **track**(int val) Identical to sync.", + "int **track**() Identical to sync.", + "dur **value**(int voice, dur val) For particular voice (arg 1), get value from the voice.", + "dur **value**(dur val) Get value from voice 0.", + "float **valueAt**(float val, dur index) Set value directly in record buffer.", + "float **valueAt**(dur index) Get value directly from record buffer.", + "float **voiceGain**(int voice, float val) For particular voice (arg 1), set gain.", + "float **voiceGain**(int voice) Set playback gain (voice 0).", + "float **voicePan**(int voice, float val) For particular voice (arg 1), set panning value [0.0, number of channels - 1.0].", + "float **voicePan**(int voice) For particular voice (arg 1), get panning value." + ], + "examples": [], + "description": "A (li)ve (sa)mpling unit generator (8-channel edition); also popularly used for granular synthesis.", + "title": "**Live Sampling UGen 8-channel**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#LiSa8)" + }, + "MFCC": { + "functions": [ + "**Methods:**", + "float **compute**(float[] input, float[] output) Manually computes the MFCC of the input (an FFT spectrum), and stores the results in the output array (MFCC coefficients).", + "int **numCoeffs**(int n) Set the number of MFCC coefficients to compute.", + "int **numCoeffs**() Get the number of MFCC coefficients to compute.", + "int **numFilters**(int n) Set the number of linearly spaced filters in MEL space.", + "int **numFilters**() Get the number of linearly spaced filters in MEL space.", + "int **sampleRate**(int sr) Set the sample rate for MFCC analysis; NOTE: by default this is set to current ChucK sample rate.", + "int **sampleRate**() Get the sample rate for MFCC analysis." + ], + "examples": [ + "Examples: \t [mfcc-basic.ck](https://chuck.stanford.edu/doc/examples/ai/features/mfcc-basic.ck), [mfcc-mean.ck](https://chuck.stanford.edu/doc/examples/ai/features/mfcc-mean.ck), [feature-extract.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/feature-extract.ck), [genre-classify.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/genre-classify.ck)" + ], + "description": "A unit analyzer that computes Mel-frequency Cepstral Coefficients (MFCCs), and outputs a vector of coefficients.", + "title": "**Mel-Frequency Cepstral Coefficients**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#MFCC)" + }, + "MLP": { + "functions": [ + "**Methods:**", + "void **backprop**(float[] output, float learningRate) (Manually) backpropagate from the output layer, for a single input-output observation; compute the gradient of the loss function with respect to the weights in the network, one layer at a time.", + "void **forward**(float[] input) (Manually) forward-propagate the input vector through the network.", + "void **getActivations**(int layer, float[] activations) Get the activations of the given layer, after a manual .forward().", + "void **getBiases**(int layer, float[] biases) Get the biases of the given layer.", + "void **getGradients**(int layer, float[] gradients) Get the gradients of the given layer, after a manual .backprop().", + "void **getWeights**(int layer, float[][] weights) Get the weights of the given layer.", + "void **init**(int[] nodesPerLayer) Initialize the MLP with the given number of nodes per layer.", + "void **init**(int[] nodesPerLayer, int[] activationPerLayer) Initialize the MLP with the given number of nodes per layer and the given activation function per layer, as specified in 'activationPerLayer' (options: AI.Linear, AI.Sigmoid, AI.ReLU, AI.Tanh, or AI.Softmax).", + "void **init**(int[] nodesPerLayer, int activationFunction) Initialize the MLP with the given number of nodes per layer and the given activation function for all layers (options: AI.Linear, AI.Sigmoid, AI.ReLU, AI.Tanh, or AI.Softmax).", + "int **load**(string filename) Load a MLP model from file.", + "int **predict**(float[] input, float[] output) Predict the output layer from an input layer.", + "int **save**(string filename) Save the MLP model to file.", + "void **train**(float[][] inputs, float[][] outputs) Train the MLP with the given input and output observations with default learning rate=.01 and epochs=100. (Also see MLP.train(inputs,outputs,learningRate,epochs).)", + "void **train**(float[][] inputs, float[][] outputs, float learningRate, int epochs) Train the MLP with the given input and output observations, the learning rate, and number of epochs.", + "void **shuffle**(float[][] X, float[][] Y) (Manually) shuffle the given input and output vectors." + ], + "examples": [ + "Examples: \t [mlp.ck](https://chuck.stanford.edu/doc/examples/ai/mlp/mlp.ck), [mlp-manual.ck](https://chuck.stanford.edu/doc/examples/ai/mlp/mlp-manual.ck), [model-load.ck](https://chuck.stanford.edu/doc/examples/ai/mlp/model-load.ck), [model-save.ck](https://chuck.stanford.edu/doc/examples/ai/mlp/model-save.ck)" + ], + "description": "A multilayer perceptron (MLP)--a basic artificial neural network--that maps an input layer to an output layer across a number of fully-connected hidden layers. This implementation can be trained either 1) by using one of the comprehensive .train() functions OR 2) by iteratively calling .forward() and .backprop() for each input-output observation, and using .shuffle() for each epoch. Commonly used for regression or classification.", + "title": "**Multi-Layer Perceptron**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#MLP)" + }, + "Machine": { + "description": "Machine is the runtime interface to the ChucK Virtual Machine (Ck.VM or simply VM). This interface can be used to manage shreds, evaluate code, set log levels, etc. Machine's shred commands (add, replace, remove, etc.) are similar to the on-the-fly programming commands, except these are invoked from within a ChucK program, and benefit from ChucK's strongly-timed mechanics.", + "examples": [ + "Examples: \t [eval.ck](https://chuck.stanford.edu/doc/examples/machine/eval.ck), [eval-global.ck](https://chuck.stanford.edu/doc/examples/machine/eval-global.ck), [intsize.ck](https://chuck.stanford.edu/doc/examples/machine/intsize.ck), [is-realtime.ck](https://chuck.stanford.edu/doc/examples/machine/is-realtime.ck), [machine-help.ck](https://chuck.stanford.edu/doc/examples/machine/machine-help.ck), [machine-shred.ck](https://chuck.stanford.edu/doc/examples/machine/machine-shred.ck), [version.ck](https://chuck.stanford.edu/doc/examples/machine/version.ck), [DrumMachine](https://chuck.stanford.edu/doc/examples/book/digital-artists/chapter9/DrumMachine), [initialize.ck](https://chuck.stanford.edu/doc/examples/book/digital-artists/chapter9/SmartMandolin/initialize.ck)" + ], + "functions": [ + "**Methods:**", + "int **add**(string path) Compile and spork a new shred from file at 'path' into the VM; returns the new shred ID. It is possible to include arguments with the file being added, e.g., `Machine.add( \"foo.ck:bar:3:5.0\" )`.", + "void **clearVM**() Reset the type system, removing all user-defined types and all global variables; removes all shreds in the VM (including the shred calling this function); use with care.", + "void **crash**() Explicitly crash the virtual machine. The very last resort; or an emphatic gesture. Use with care.", + "int **eval**(string code) Evaluate a string as ChucK code, compile it and immediately spork it as a new independent shred, and automatically yield the current shred to give the new shred a chance to run, without advancing time.", + "int **eval**(string code, string args) Evaluate a string as ChucK code, with arguments (bundled in 'args' as \"ARG1:ARG2:...\", compile it and immediately spork it as a new independent shred, and automatically yield the current shred to give the new shred a chance to run, without advancing time.", + "int **eval**(string code, string args, int count) Evaluate a string as ChucK code, with optional arguments (bundled in 'args' as \"ARG1:ARG2:...\", compile it and immediately spork 'count' independent shreds; and automatically yield the current shred to give all new shreds a chance to run, without advancing time.", + "int **intsize**() Return the bit size of an integer.", + "int **loglevel**(int level) Set log level |- 0: NONE |- 1: CORE |- 2: SYSTEM |- 3: HERALD |- 4: WARNING |- 5: INFO |- 6: DEBUG |- 7: FINE |- 8: FINER |- 9: FINEST |- 10: ALL.", + "int **loglevel**() Get log level.", + "int **numShreds**() Get the number of shreds currently in the VM.", + "void **printStatus**() Print (to terminal or console) the current status of the VM.", + "void **printTimeCheck**() Print (to terminal or console) the current time information in the VM.", + "int **realtime**() Return true if the shred is in realtime mode, false if it's in silent mode (i.e. --silent is enabled)", + "int **refcount**(Object obj) Get an object's current internal reference count; this is intended for testing or curiosity; NOTE: this function intentionally does not take into account any reference counting related to the calling of this function (normally all functions increments the reference count for objects passed as arguments and decrements upon returning)", + "int **remove**(int id) Remove shred from VM by shred ID (returned by Machine.add).", + "void **removeAllShreds**() Remove all shreds in the VM (including the shred calling this function).", + "int **removeLastShred**() Remove the most recently added shred in the VM (could be the shred calling this function); returns the ID of the removed shred.", + "int **replace**(int id, string path) Replace shred with new shred from file. Returns new shred ID, or 0 on error. It is possible to include arguments, e.g., `Machine.replace( outID, \"foo.ck:bar:3:5.0\" )`.", + "void **resetOperators**() Reset operator overloading state to default startup state; removes all public @operator overloads; use with care.", + "int **resetShredID**() Reset shred IDs to 1 + the highest current shred ID in the VM; can be used as shred management to keep shred IDs low, after a lot of sporks; returns what the next shred ID would be.", + "int[] **shreds**() Retrieve an array of active shred ids.", + "int **silent**() Return false if the shred is in realtime mode, true if it's in silent mode (i.e. --silent is enabled)", + "int **sp_mem**() Get the calling shred's memory (aka \"mem\") stack pointer; intended for either debugging or curiosity.", + "int **sp_reg**() Get the calling shred's operand (aka \"reg\"/register) stack pointer; intended for either debugging or curiosity.", + "int **status**() Print the current status of the VM; legacy version of printStatus().", + "string **version**() Return language and VM version string." + ], + "title": "**ChucK Virtual Machine**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#Machine)" + }, + "MagicSine": { + "functions": [ + "**Methods:**", + "float **freq**(float arg) Oscillator frequency [Hz].", + "float **freq**() Oscillator frequency [Hz]." + ], + "examples": [], + "description": "Fast, recursive sine wave generator using the so-called \"magic circle\" algorithm (see https://ccrma.stanford.edu/~jos/pasp/Digital_Sinusoid_Generators.html). Can be 30-40% faster than regular SinOsc. Frequency modulation will negate this performance benefit; most useful when pure sine tones are desired or for additive synthesis.", + "title": "**Magic Sine Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#MagicSine)" + }, + "Mandolin": { + "functions": [ + "**Methods:**", + "float **afterTouch**(float value) Set aftertouch (currently unsupported).", + "string **bodyIR**(string path) Set body impulse response.", + "string **bodyIR**() Get body impulse response.", + "float **bodySize**(float value) Set body size (percentage).", + "float **bodySize**() Get body size (percentage).", + "float **pluck**(float value) Pluck instrument, [0.0-1.0].", + "float **pluckPos**(float value) Set pluck position, [0.0-1.0].", + "float **pluckPos**() Get pluck position, [0.0-1.0].", + "float **stringDamping**(float value) Set string damping, [0.0-1.0].", + "float **stringDamping**() Get string damping, [0.0-1.0].", + "float **stringDetune**(float value) Set detuning of string pair, [0.0-1.0].", + "float **stringDetune**() Get detuning of string pair, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [mandolin.ck](https://chuck.stanford.edu/doc/examples/stk/mandolin.ck), [mand-o-matic.ck](https://chuck.stanford.edu/doc/examples/stk/mand-o-matic.ck), [mand-o-matic-simple.ck](https://chuck.stanford.edu/doc/examples/stk/mand-o-matic-simple.ck)" + ], + "description": "This class inherits from PluckTwo and uses 'commuted synthesis' techniques to model a mandolin instrument. This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Commuted Synthesis, in particular, is covered by patents, granted, pending, and/or applied-for. All are assigned to the Board of Trustees, Stanford University. For information, contact the Office of Technology Licensing, Stanford University. Control Change Numbers: - Body Size = 2 - Pluck Position = 4 - String Sustain = 11 - String Detuning = 1 - Microphone Position = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Mandolin**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Mandolin)" + }, + "Math": { + "functions": [ + "**Methods:**", + "int **abs**(int value) Return absolute value of an integer value.", + "float **acos**(float x) Compute arccosine of x; result in [0, pi].", + "float **asin**(float x) Compute arcsine of x; result in [-pi/2, +pi/2].", + "float **atan2**(float y, float x) Compute arc tangent of two variables (y/x).", + "float **atan**(float x) Compute arctangent of x; result in [-pi/2, +pi/2].", + "float **ceil**(float x) Return the smallest integer value (returned as float) not less than x.", + "float **clampf**(float value, float min, float max) Clamp a float to range [min,max].", + "int **clampi**(int value, int min, int max) Clamp an integer to range [min,max].", + "float **cos**(float x) Compute cosine of x (measured in radians).", + "float **cosh**(float x) Compute the hyperbolic cosine of x.", + "float **cossim**(float[] a, float[] b) Compute the cosine similarity between arrays a and b.", + "float **cossim**(vec3 a, vec3 b) Compute the cosine similarity between 3D vectors a and b.", + "float **cossim**(vec4 a, vec4 b) Compute the cosine similarity between 4D vectors a and b.", + "float **dbtopow**(float value) Convert decibels (dB) to signal power ratio.", + "float **dbtorms**(float value) Convert decibles (dB) to linear amplitude.", + "int **ensurePow2**(int x) Return the smallest power-of-2 greater than or equal to the value of x.", + "int **equal**(float x, float y) Return whether two floats are considered equal.", + "float **euclidean**(float[] a, float[] b) Compute the euclidean distance between arrays a and b.", + "float **euclidean**(vec2 a, vec2 b) Compute the euclidean distance between 2D vectors a and b.", + "float **euclidean**(vec3 a, vec3 b) Compute the euclidean distance between 3D vectors a and b.", + "float **euclidean**(vec4 a, vec4 b) Compute the euclidean distance between 4D vectors a and b.", + "float **exp2**(float x) Compute 2^x, the base-2 exponential of x.", + "float **exp**(float x) Compute e^x, the base-e exponential of x.", + "float **fabs**(float value) Return absolute value of a floating point value.", + "float **floor**(float x) Return the largest integer value (returned as float) not greater than x.", + "float **fmod**(float x, float y) Compute the floating-point remainder of x / y.", + "float **ftom**(float value) Convert frequency (Hz) to MIDI note number space.", + "float **gauss**(float x, float mean, float sd) Compute gaussian function at x, given mean and SD.", + "float **hypot**(float x, float y) Compute the euclidean distance sqrt(x*x+y*y).", + "float **im**(complex v) Return the imaginary component of complex value v.", + "int **isinf**(float x) Return true if x is infinity, else return false.", + "int **isnan**(float x) Return true if x is not a number, else return false.", + "float **log10**(float x) Compute the logarithm of x to base 10.", + "float **log2**(float x) Compute the logarithm of x to base 2.", + "float **log**(float x) Compute the natural logarithm of x.", + "float **mag**(polar v) Return the magnitude component of polar value v.", + "float **map2**(float value, float x1, float y1, float x2, float y2) Map 'value' from range [x1,y1] into range [x2,y2]; 'value' will be clamped to [x1,y1] if outside range. (see also: Math.map())", + "float **map**(float value, float x1, float y1, float x2, float y2) Map 'value' from range [x1,y1] into range [x2,y2]; 'value' can be outside range[x1,y1]. (see also: Math.map2())", + "int **max**(int x, int y) Return the greater of x and y (integer).", + "float **max**(float x, float y) Return the greater of x and y (float).", + "int **min**(int x, int y) Return the lesser of x and y (int).", + "float **min**(float x, float y) Return the lesser of x and y (float).", + "float **mtof**(float value) Convert a MIDI note number to frequency (Hz). Note that the input value is of type float and supports fractional note numbers.", + "int **nextpow2**(int x) Compute the smallest power-of-2 greater than x.", + "float **phase**(polar v) Return the phase component of polar value v.", + "float **pow**(float x, float y) Compute x raised to the y-th power.", + "float **powtodb**(float value) Convert signal power ratio to decibels (dB).", + "int **ptor**(polar[] from, complex[] to) Convert polar values to complex values; returns number of values converted.", + "int **random2**(int min, int max) Return successive pseudo-random numbers in the range [min, max].", + "float **random2f**(float min, float max) Return successive pseudo-random floating-point numbers in the range [min, max].", + "int **random**() Return successive pseudo-random integer numbers in the range [0, Math.RANDOM_MAX]].", + "float **randomf**() Return successive pseudo-random floating-point numbers in the range [0,1].", + "void **randomize**() Randomize the seed of the random number generator (RNG), using an non-deterministic mechanism. Whereas srandom() explicitly seeds the RNG and will produce a deterministic sequence of pseudo-random numbers, randomize() \"shakes things up\" and causes RNG to start generating from a practically unpredicable seed. The quality of randomize() depends on the underlying implementation.", + "float **re**(complex v) Return the real component of complex value v.", + "float **remainder**(float x, float y) Compute the value r such that r=x-n*y, where n is the integer nearest the exact value of x / y. If there are two integers closest to x / y, n shall be the even one. If r is zero, it is given the same sign as x.", + "float **remap**(float value, float x1, float y1, float x2, float y2) Same as Math.map2().", + "float **rmstodb**(float value) Convert linear amplitude to decibels (dB).", + "float **round**(float x) Return the integer value (returned as float) nearest to x (rounding halfway cases away from zero).", + "int **rtop**(complex[] from, polar[] to) Convert complex values to polar values; returns number of values converted.", + "float **sgn**(float value) Return sign of 'value' as -1.0 (negative), 0.0, or 1.0 (positive).", + "float **sin**(float x) Compute sine of x (measured in radians).", + "float **sinh**(float x) Compute the hyperbolic sine of x.", + "float **sqrt**(float x) Compute the non-negative square root of x.", + "void **srandom**(int seed) Seed the random number generator (RNG). Different seeds will generate very different sequences of random numbers even if the seeds are close together. Alternatively, a deterministic sequence of pseudo-random numbers can repeatably generated by setting the same seed.", + "float **tan**(float x) Compute tangent of x (measured in radians).", + "float **tanh**(float x) Compute the hyperbolic tangent of x.", + "float **trunc**(float x) Return the integer value nearest to but no greater in magnitude than x.", + "static member variables float e", + "Euler's number; base of the natural logarithm. float E", + "Euler's number; base of the natural logarithm. float FLOAT_MAX", + "Largest representable floating-point value. float FLOAT_MIN_MAG", + "Smallest representable non-negative floating-point value. complex i", + "The complex number **sqrt**(-1). complex I", + "The complex number **sqrt**(-1). float INFINITY", + "Like, infinity. int INT_MAX", + "Largest representable integer value. complex j", + "The complex number **sqrt**(-1). complex J", + "The complex number **sqrt**(-1). float pi", + "An approximation of pi. (Same as global keyword 'pi'.) float PI", + "An approximation of pi. (Same as global keyword 'pi'.) int RANDOM_MAX", + "The largest possible value returned by **random**(). float two_pi", + "An approximation of 2*pi. float TWO_PI", + "An approximation of 2*pi. [ top ]", + "Machine inherits : Object" + ], + "examples": [ + "Examples: \t [blit2.ck](https://chuck.stanford.edu/doc/examples/basic/blit2.ck), [mand-o-matic.ck](https://chuck.stanford.edu/doc/examples/stk/mand-o-matic.ck), [randomize.ck](https://chuck.stanford.edu/doc/examples/math/randomize.ck), [maybe.ck](https://chuck.stanford.edu/doc/examples/math/maybe.ck), [int-dist.ck](https://chuck.stanford.edu/doc/examples/math/int-dist.ck), [map.ck](https://chuck.stanford.edu/doc/examples/math/map.ck)" + ], + "description": "Math class library.", + "title": "**Math Class Library**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#Math)" + }, + "Mesh2D": { + "functions": [ + "**Methods:**", + "float **decay**() Decay constant (0 = instant decay, 1.0 = long decay time).", + "float **decay**(float arg) Decay constant (0 = instant decay, 1.0 = long decay time).", + "float **noteOff**(float arg) Release the model.", + "float **noteOn**(float arg) Trigger the mesh with given amplitude.", + "int **x**() X dimension of \"plate\" (max 12).", + "int **x**(int arg) X dimension of \"plate\" (max 12).", + "float **xpos**() Strike x position (appears to be on range (0.0, 2.0)).", + "float **xpos**(float arg) Strike x position (appears to be on range (0.0, 2.0)).", + "int **y**() Y dimension of \"plate\" (max 12).", + "int **y**(int arg) Y dimension of \"plate\" (max 12).", + "float **ypos**() Strike y position (appears to be on range (0.0, 2.0)).", + "float **ypos**(float arg) Strike y position (appears to be on range (0.0, 2.0))." + ], + "examples": [ + "Examples: \t [Mesh2D.ck](https://chuck.stanford.edu/doc/examples/special/Mesh2D.ck)" + ], + "description": "This class implements a rectilinear, two-dimensional digital waveguide mesh structure. For details, see Van Duyne and Smith, \"Physical Modeling with the 2-D Digital Waveguide Mesh,\" Proceedings of the 1993 International Computer Music Conference.", + "title": "**2D Digital Waveguide Mesh**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Mesh2D)" + }, + "MidiFileIn": { + "functions": [ + "**Methods:**", + "void **close**() Close the MIDI file.", + "int **numTracks**() Get the number of tracks in the open MIDI file.", + "int **open**(string path) Open a MIDI file.", + "int **read**(MidiMsg msg) Read next MIDI Event (on default track 0); return contents in 'msg'.", + "int **read**(MidiMsg msg, int track) Read next MIDI Event on track 'track'; return contents in 'msg'.", + "void **rewind**() Rewind MIDI reader to beginning of default track 0.", + "void **rewind**(int track) Rewind MIDI reader to beginning of track 'track'." + ], + "examples": [ + "Examples: \t [midiplay-play.ck](https://chuck.stanford.edu/doc/examples/midi/midiplay-play.ck)" + ], + "description": "Class for reading data from a MIDI file.", + "title": "**MIDI File Input**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#MidiFileIn)" + }, + "MidiIn": { + "description": "Class that can be ChucKed to now as an event. When receiving a message, an event is signaled and Midi information can be read.", + "examples": [ + "Examples: \t [gomidi.ck](https://chuck.stanford.edu/doc/examples/midi/gomidi.ck), [gomidi2.ck](https://chuck.stanford.edu/doc/examples/midi/gomidi2.ck), [polyfony.ck](https://chuck.stanford.edu/doc/examples/midi/polyfony.ck), [polyfony2.ck](https://chuck.stanford.edu/doc/examples/midi/polyfony2.ck)" + ], + "functions": [ + "**Methods:**", + "int **can_wait**() (internal) used by virtual machine for synthronization.", + "int **good**() Return true (1) if a device has been opened for this instance and there was no error connecting to it. Return false (0) if a device has not been opened or there was an error opening a device.", + "string **name**() Return the Midi device's name as string.", + "int **num**() Return the device number of the device (i.e. the number passed to MidiIn/MidiOut.open).", + "int **open**(int port) Open Midi device using a port number.", + "int **open**(string name) Open Midi device using the device's name.", + "void **printerr**(int print_or_not) Set error printing (1 for on, 0 for off). On by default.", + "int **recv**(MidiMsg msg) Return into the MidiMsg argument the next message in the queue from the device. Return 0 if the queue is empty or 1 if a message was in the queue and returned in the argument." + ], + "title": "**MIDI Input**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#MidiIn)" + }, + "MidiMsg": { + "functions": [], + "examples": [ + "Examples: \t [gomidi.ck](https://chuck.stanford.edu/doc/examples/midi/gomidi.ck), [gomidi2.ck](https://chuck.stanford.edu/doc/examples/midi/gomidi2.ck), [polyfony.ck](https://chuck.stanford.edu/doc/examples/midi/polyfony.ck), [polyfony2.ck](https://chuck.stanford.edu/doc/examples/midi/polyfony2.ck)" + ], + "description": "Creates a message for sending and receiving Midi information.", + "title": "**MIDI Message**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#MidiMsg)" + }, + "MidiOut": { + "functions": [ + "**Methods:**", + "int **good**() Return true (1) if a device has been opened for this instance and there was no error connecting to it. Return false (0) if a device has not been opened or there was an error opening a device.", + "string **name**() Return the Midi device's name as string.", + "int **num**() Return the device number of the device (i.e. the number passed to MidiIn/MidiOut.open).", + "int **open**(int port) Open Midi device using a port number.", + "int **open**(string name) Open Midi device using the device's name.", + "void **printerr**(int print_or_not) Set error printing (1 for on, 0 for off). On by default.", + "int **send**(MidiMsg msg) Send out a MidiMsg message." + ], + "examples": [ + "Examples: \t [midiout.ck](https://chuck.stanford.edu/doc/examples/midi/midiout.ck)" + ], + "description": "Class for sending out Midi messages.", + "title": "**MIDI Output**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#MidiOut)" + }, + "Mix2": { + "description": "A stereo-to-mono unit generator for mixing stereo signal to mono.\nconstructors", + "examples": [], + "functions": [], + "title": "**Stereo to Mono UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Mix2)" + }, + "ModalBar": { + "functions": [ + "**Methods:**", + "float **clear**(float value) Clear instrument.", + "float **damp**(float value) Damp bar, [0.0-1.0].", + "float **directGain**(float value) Set direct gain, [0.0-1.0].", + "float **directGain**() Get direct gain, [0.0-1.0].", + "float **masterGain**(float value) Set master gain, [0.0-1.0].", + "float **masterGain**() Get master gain, [0.0-1.0].", + "int **mode**(int value) Set mode.", + "int **mode**() Get mode.", + "float **modeGain**(float value) Set gain for selected mode, [0.0-1.0].", + "float **modeGain**() Get gain for selected mode, [0.0-1.0].", + "float **modeRadius**(float value) Set radius for selected mode, [0.0-1.0].", + "float **modeRadius**() Get radius for selected mode, [0.0-1.0].", + "float **modeRatio**(float value) Set ratio for selected mode.", + "float **modeRatio**() Get ratio for selected mode.", + "int **preset**(int value) Set preset (see above).", + "int **preset**() Get preset.", + "float **stickHardness**(float value) Set stick hardness, [0.0-1.0].", + "float **stickHardness**() Get stick hardness, [0.0-1.0].", + "float **strike**(float value) Strike bar, [0.0-1.0].", + "float **strikePosition**(float value) Set strike position, [0.0-1.0].", + "float **strikePosition**() Get strike position, [0.0-1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0].", + "float **volume**(float value) Set volume, [0.0-1.0].", + "float **volume**() Get volume, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [modalbar.ck](https://chuck.stanford.edu/doc/examples/stk/modalbar.ck), [modalbar2.ck](https://chuck.stanford.edu/doc/examples/stk/modalbar2.ck), [mode-o-matic.ck](https://chuck.stanford.edu/doc/examples/stk/mode-o-matic.ck), [mode-o-test.ck](https://chuck.stanford.edu/doc/examples/stk/mode-o-test.ck)" + ], + "description": "This class implements a number of different struck bar instruments. It inherits from the Modal class. Control Change Numbers: - Stick Hardness = 2 - Stick Position = 4 - Vibrato Gain = 11 - Vibrato Frequency = 7 - Direct Stick Mix = 1 - Volume = 128 - Modal Presets = 16 - Marimba = 0 - Vibraphone = 1 - Agogo = 2 - Wood1 = 3 - Reso = 4 - Wood2 = 5 - Beats = 6 - Two Fixed = 7 - Clump = 8 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Modal Bar**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#ModalBar)" + }, + "Modulate": { + "functions": [ + "**Methods:**", + "float **randomGain**(float value) Set gain for random contribution.", + "float **randomGain**() Get gain for random contribution.", + "float **vibratoGain**(float value) Set gain for vibrato.", + "float **vibratoGain**() Get gain for vibrato.", + "float **vibratoRate**(float value) Set rate for vibrato.", + "float **vibratoRate**() Get rate for vibrato." + ], + "examples": [ + "Examples: \t [modulate.ck](https://chuck.stanford.edu/doc/examples/stk/modulate.ck)" + ], + "description": "This class combines random and periodic modulations to give a nice, natural human modulation function. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Modulation Effect**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Modulate)" + }, + "Moog": { + "functions": [ + "**Methods:**", + "float **afterTouch**(float value) Set aftertouch, [0.0-1.0].", + "float **filterQ**(float value) Set filter Q value, [0.0-1.0].", + "float **filterQ**() Get filter Q value, [0.0-1.0].", + "float **filterStartFreq**(float freq) Set filter starting frequency.", + "float **filterStartFreq**() Get filter starting frequency.", + "float **filterSweepRate**(float value) Set filter sweep rate, [0.0-1.0].", + "float **filterSweepRate**() Get filter sweep rate, [0.0-1.0].", + "float **lfoDepth**(float value) Set LFO modulation depth.", + "float **lfoDepth**() Get LFO modulation depth.", + "float **lfoSpeed**(float value) Set LFO modulation speed.", + "float **lfoSpeed**() Get LFO modulation speed.", + "float **modDepth**(float value) Set modulation depth.", + "float **modDepth**() Get modulation depth.", + "float **modSpeed**(float value) Set modulation speed.", + "float **modSpeed**() Get modulation speed.", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0].", + "float **volume**(float value) Set volume.", + "float **volume**() Get volume." + ], + "examples": [ + "Examples: \t [moog.ck](https://chuck.stanford.edu/doc/examples/stk/moog.ck), [moog2.ck](https://chuck.stanford.edu/doc/examples/stk/moog2.ck), [moogie.ck](https://chuck.stanford.edu/doc/examples/stk/moogie.ck)" + ], + "description": "This instrument uses one attack wave, one looped wave, and an ADSR envelope (inherited from the Sampler class) and adds two sweepable formant (FormSwep) filters. Control Change Numbers: - Filter Q = 2 - Filter Sweep Rate = 4 - Vibrato Frequency = 11 - Vibrato Gain = 1 - Gain = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Moog**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Moog)" + }, + "Multicomb": { + "functions": [ + "**Methods:**", + "float **maxfreq**(float maxfreq) Set max frequency. Default 880.", + "float **maxfreq**() Get max frequency. Default 880.", + "float **minfreq**(float minfreq) Set low frequency. Default 220.", + "float **minfreq**() Get low frequency. Default 220.", + "int **num**(int num) Set number of comb filters. Default 5.", + "int **num**() Get number of comb filters. Default 5.", + "dur **revtime**(dur revtime) Set total ring time. Default 1::second.", + "dur **revtime**() Get total ring time. Default 1::second.", + "void **set**(float minfreq, float maxfreq) Set both low and high frequencies." + ], + "examples": [ + "Examples: \t [Multicomb.ck](https://chuck.stanford.edu/doc/examples/filter/Multicomb.ck)" + ], + "description": "Multiple simultaneous comb filters randomly chosen within a specified frequency range and spread across the stereo field.", + "title": "**Multi-Comb Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Multicomb)" + }, + "NRev": { + "functions": [ + "**Methods:**", + "float **mix**(float value) Set mix level.", + "float **mix**() Get mix level." + ], + "examples": [ + "Examples: \t [reverb.ck](https://chuck.stanford.edu/doc/examples/effects/reverb.ck), [krstlchr-algo7.ck](https://chuck.stanford.edu/doc/examples/stk/krstlchr-algo7.ck), [thx.ck](https://chuck.stanford.edu/doc/examples/deep/thx.ck)" + ], + "description": "CCRMA's NRev reverberator class. This class is derived from the CLM NRev function, which is based on the use of networks of simple allpass and comb delay filters. This particular arrangement consists of 6 comb filters in parallel, followed by 3 allpass filters, a lowpass filter, and another allpass in series, followed by two allpass filters in parallel with corresponding rightand left outputs. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**CCRMA's NRev Reverberator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#NRev)" + }, + "Noise": { + "functions": [], + "examples": [ + "Examples: \t [wind.ck](https://chuck.stanford.edu/doc/examples/basic/wind.ck), [powerup.ck](https://chuck.stanford.edu/doc/examples/shred/powerup.ck)" + ], + "description": "A white noise generator.", + "title": "**Noise Generator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Noise)" + }, + "Object": { + "functions": [ + "**Methods:**", + "string **toString**() Get a textual description of this object.", + "void **help**() Output helpful information about a class or an instance thereof.", + "Type **typeOf**() Get the type of this object (or class)." + ], + "examples": [], + "description": "constructors", + "title": "**ChucK Base Object Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#Object)" + }, + "OnePole": { + "functions": [ + "**Methods:**", + "float **a1**(float value) Set filter coefficient.", + "float **a1**() Get filter coefficient.", + "float **b0**(float value) Set filter coefficient.", + "float **b0**() Get filter coefficient.", + "float **pole**(float value) Set pole position along real axis of z-plane.", + "float **pole**() Get pole position along real axis of z-plane." + ], + "examples": [ + "Examples: \t [follower.ck](https://chuck.stanford.edu/doc/examples/deep/follower.ck)" + ], + "description": "This Filter subclass implements a one-pole digital filter. A method is provided for setting the pole position along the real axis of the z-plane while maintaining a constant peak filter gain. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**One-Pole Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#OnePole)" + }, + "OneZero": { + "functions": [ + "**Methods:**", + "float **b0**(float value) Set filter coefficient.", + "float **b0**() Get filter coefficient.", + "float **b1**(float value) Set filter coefficient.", + "float **b1**() Get filter coefficient.", + "float **zero**(float value) Set zero position.", + "float **zero**() Get zero position." + ], + "examples": [ + "Examples: \t [plu.ck](https://chuck.stanford.edu/doc/examples/deep/plu.ck), [plu2.ck](https://chuck.stanford.edu/doc/examples/deep/plu2.ck), [plu3.ck](https://chuck.stanford.edu/doc/examples/deep/plu3.ck)" + ], + "description": "This Filter subclass implements a one-zero digital filter. A method is provided for setting the zero position along the real axis of the z-plane while maintaining a constant filter gain. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**One-Zero Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#OneZero)" + }, + "Osc": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency)." + ], + "examples": [], + "description": "Base class for simple oscillator unit generators.", + "title": "**Oscillator Base Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Osc)" + }, + "OscIn": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode.", + "void **addAddress**(string address) Add an OSC address to receive messages from.", + "void **listenAll**() Set OscIn to receive messages of any OSC address.", + "int **port**() Get which port to listen on.", + "int **port**(int p) Set which port to listen on; this will begin priming the background OSC listener on the named port. If port is set to 0, a usable port would be automatically assigned; the auto-assigned port number can be retrieved by calling .port() but may initially take some time to acquire (e.g., hundreds of milliseconds); if there is more than one OscIn client on port 0, they all will eventually share the same auto-assigned port.", + "int **recv**(OscMsg msg) Receive the next queued incoming OSC message, returning its contents in `msg`.", + "void **removeAddress**(string address) Stop listening on a particular OSC address.", + "void **removeAllAddresses**() Stop listening on all OSC addresses." + ], + "examples": [ + "Examples: \t [r.ck](https://chuck.stanford.edu/doc/examples/osc/r.ck), [s.ck](https://chuck.stanford.edu/doc/examples/osc/s.ck), [osc-dump.ck](https://chuck.stanford.edu/doc/examples/osc/osc-dump.ck), [r-multi-msg.ck](https://chuck.stanford.edu/doc/examples/osc/multi-msg/r-multi-msg.ck)" + ], + "description": "Class for receiving Open Sound Control (OSC) messages. See examples for usage.", + "title": "**OSC Input**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#OscIn)" + }, + "OscMsg": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode.", + "float **getFloat**(int i) Get argument (at index 'i') as a float.", + "int **getInt**(int i) Get argument (at index 'i') as an integer.", + "string **getString**(int i) Get argument (at index 'i') as a string.", + "int **numArgs**() Get the number of arguments contained in this OscMsg." + ], + "examples": [ + "Examples: \t [r.ck](https://chuck.stanford.edu/doc/examples/osc/r.ck), [s.ck](https://chuck.stanford.edu/doc/examples/osc/s.ck), [osc-dump.ck](https://chuck.stanford.edu/doc/examples/osc/osc-dump.ck), [r-multi-msg.ck](https://chuck.stanford.edu/doc/examples/osc/multi-msg/r-multi-msg.ck)" + ], + "description": "Helper class for receiving the contents of an OSC message.", + "title": "**OSC Message**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#OscMsg)" + }, + "OscOut": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode.", + "OscOut **add**(int i) Add an integer value to an OSC message.", + "OscOut **add**(float f) Add a floating-point value to an OSC message.", + "OscOut **add**(string s) Add an string value to an OSC message.", + "OscOut **dest**(string hostname, int port) Set the destination hostname and port for sending OSC message.", + "OscOut **send**() Send the current OSC message.", + "OscOut **start**(string address) Start an OSC message with a particular address.", + "OscOut **start**(string address, string host, int port) Start an OSC message with a particular address, aimed at a destination host and port." + ], + "examples": [ + "Examples: \t [s.ck](https://chuck.stanford.edu/doc/examples/osc/s.ck), [r.ck](https://chuck.stanford.edu/doc/examples/osc/r.ck), [osc-dump.ck](https://chuck.stanford.edu/doc/examples/osc/osc-dump.ck)" + ], + "description": "Class for sending Open Sound Control (OSC) messages. See examples for usage.", + "title": "**OSC Output**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#OscOut)" + }, + "PCA": { + "functions": [ + "**Methods:**", + "void **reduce**(float[][] input, int D, float[][] output) Dimension-reduce 'input' (NxM) to 'output' (NxD) as the projection of the input data onto its first 'D' principle components." + ], + "examples": [ + "Examples: \t [pca.ck](https://chuck.stanford.edu/doc/examples/ai/pca/pca.ck)" + ], + "description": "A principle component analysis (PCA) utility, commonly used for dimensionality reduction.", + "title": "**Principal Component Analyzer**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#PCA)" + }, + "PRCRev": { + "functions": [ + "**Methods:**", + "float **mix**(float value) Set mix level.", + "float **mix**() Get mix level." + ], + "examples": [ + "Examples: \t [reverb.ck](https://chuck.stanford.edu/doc/examples/effects/reverb.ck)" + ], + "description": "Perry's simple reverberator class. This class is based on some of the famous Stanford/CCRMA reverbs (NRev, KipRev), which were based on the Chowning/Moorer/Schroeder reverberators using networks of simple allpass and comb delay filters. This class implements two series allpass units and two parallel comb filters. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Perry Cook's Simple Reverberator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#PRCRev)" + }, + "Pan16": { + "functions": [ + "**Methods:**", + "float **pan**(float arg) Set pan position [0-16].", + "float **pan**() Get pan position [0-16]." + ], + "examples": [], + "description": "Sixteen-channel equal-power panner.", + "title": "**16-Channel Panner**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Pan16)" + }, + "Pan2": { + "functions": [], + "examples": [ + "Examples: \t [chirp2.ck](https://chuck.stanford.edu/doc/examples/basic/chirp2.ck), [array.ck](https://chuck.stanford.edu/doc/examples/stereo/array.ck), [powerup2.ck](https://chuck.stanford.edu/doc/examples/stereo/powerup2.ck), [moe2.ck](https://chuck.stanford.edu/doc/examples/stereo/moe2.ck), [larry2.ck](https://chuck.stanford.edu/doc/examples/stereo/larry2.ck), [curly2.ck](https://chuck.stanford.edu/doc/examples/stereo/curly2.ck), [ugen-array.ck](https://chuck.stanford.edu/doc/examples/stereo/ugen-array.ck), [stereo-noise.ck](https://chuck.stanford.edu/doc/examples/stereo/stereo-noise.ck), [honkeytonk-algo1.ck](https://chuck.stanford.edu/doc/examples/stk/honkeytonk-algo1.ck), [hanoi++.ck](https://chuck.stanford.edu/doc/examples/hanoi++.ck), [hanoi2.ck](https://chuck.stanford.edu/doc/examples/hanoi2.ck), [hanoi3.ck](https://chuck.stanford.edu/doc/examples/hanoi3.ck)" + ], + "description": "A mono-to-stereo unit generator for stereo panning.", + "title": "**Stereo Panner**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Pan2)" + }, + "Pan4": { + "functions": [ + "**Methods:**", + "float **pan**(float arg) Set pan position [0-4].", + "float **pan**() Get pan position [0-4]." + ], + "examples": [ + "Examples: \t [Pan4.ck](https://chuck.stanford.edu/doc/examples/spatial/Pan4.ck)" + ], + "description": "Four-channel equal-power panner.", + "title": "**4-Channel Panner**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Pan4)" + }, + "Pan8": { + "functions": [ + "**Methods:**", + "float **pan**(float arg) Set pan position [0-8].", + "float **pan**() Get pan position [0-8]." + ], + "examples": [ + "Examples: \t [Pan8.ck](https://chuck.stanford.edu/doc/examples/spatial/Pan8.ck)" + ], + "description": "Eight-channel equal-power panner.", + "title": "**8-Channel Panner**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Pan8)" + }, + "PercFlut": { + "functions": [], + "examples": [ + "Examples: \t [ctrl_sequencer.ck](https://chuck.stanford.edu/doc/examples/ctrl/ctrl_sequencer.ck)" + ], + "description": "STK percussive flute FM synthesis instrument. This class implements algorithm 4 of the TX81Z. Algorithm 4 is : 4->3--\\ ___2-- + -->1-->Out Control Change Numbers: - Total Modulator Index = 2 (.controlOne) - Modulator Crossfade = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Percussive Flute**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#PercFlut)" + }, + "Phasor": { + "functions": [], + "examples": [ + "Examples: \t [phasor.ck](https://chuck.stanford.edu/doc/examples/basic/phasor.ck)" + ], + "description": "A phasor oscillator; linearly rises from 0 to 1; can be used as a phase control.", + "title": "**Phasor Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Phasor)" + }, + "PitShift": { + "functions": [ + "**Methods:**", + "float **effectMix**(float value) Set effect mix level.", + "float **effectMix**() Get effect mix level.", + "float **mix**(float value) Set mix level.", + "float **mix**() Get mix level.", + "float **shift**(float value) Set degree of pitch shifting.", + "float **shift**() Get degree of pitch shifting." + ], + "examples": [ + "Examples: \t [pitch-shift.ck](https://chuck.stanford.edu/doc/examples/effects/pitch-shift.ck)" + ], + "description": "This class implements a simple pitch shifter using delay lines. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Pitch Shifter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#PitShift)" + }, + "PitchTrack": { + "functions": [ + "**Methods:**", + "float **bias**(float arg) Set the bias. Katja's pitch tracker introduces a small bias to help with the tracking. See the link above.", + "float **bias**() Get the bias. Katja's pitch tracker introduces a small bias to help with the tracking. See the link above.", + "float **fidelity**(float arg) Set the threshold for certainty about the result. A highly periodic signal (i.e. one that has a strong pitch center) should produce a result with a high fidelity, which a non-periodic signal (eg noise) will have a very low fidelity. Setting this parameter close to 1 should reduce the number of inaccurate reports. [0-1], default 0.95.", + "float **fidelity**() Get the threshold for certainty about the result. A highly periodic signal (i.e. one that has a strong pitch center) should produce a result with a high fidelity, which a non-periodic signal (eg noise) will have a very low fidelity. Setting this parameter close to 1 should reduce the number of inaccurate reports. [0-1], default 0.95.", + "int **frame**(int arg) Set size of FFT frame for analysis. Smaller values result in lower latency and high responsiveness but less accuracy. Higher values result in considerably greater CPU load. Values that aren't powers of 2 get rounded up to the next power of 2. Recommend 512, 1024, or 2048. [128-?], default 2048.", + "int **frame**() Get size of FFT frame for analysis. Smaller values result in lower latency and high responsiveness but less accuracy. Higher values result in considerably greater CPU load. Values that aren't powers of 2 get rounded up to the next power of 2. Recommend 512, 1024, or 2048. [128-?], default 2048.", + "float **get**() Get calculated frequency.", + "int **overlap**(int arg) Set how much to overlap successive analysis frames. Higher values should produce smoother values, at the cost of an increase of CPU load. [1-?], default 2.", + "int **overlap**() Get how much to overlap successive analysis frames. Higher values should produce smoother values, at the cost of an increase of CPU load. [1-?], default 2.", + "float **sensitivity**(float arg) Set the minimum RMS value to trigger a pitch calculation. Setting this parameter low forces PitchTrack to attempt to find the pitch of even very quiet sounds. Higher values will cause it to trigger only on louder notes. [0-1], default 0.003.", + "float **sensitivity**() Get the minimum RMS value to trigger a pitch calculation. Setting this parameter low forces PitchTrack to attempt to find the pitch of even very quiet sounds. Higher values will cause it to trigger only on louder notes. [0-1], default 0.003." + ], + "examples": [ + "Examples: \t [autotune.ck](https://chuck.stanford.edu/doc/examples/effects/autotune.ck), [PitchTrack.ck](https://chuck.stanford.edu/doc/examples/analysis/PitchTrack.ck)" + ], + "description": "PitchTrack is a monophonic autocorrelation pitch tracker with a fast response and extremely high accuracy, even at low frequencies. It is adapted from [helmholtz~] for Pd by Katja, documented at http://www.katjaas.nl/helmholtz/helmholtz.html.", + "title": "**Pitch Tracker**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#PitchTrack)" + }, + "PoleZero": { + "functions": [ + "**Methods:**", + "float **a1**(float value) Set filter coefficient.", + "float **a1**() Get filter coefficient.", + "float **allpass**(float value) Set allpass filter with given coefficient.", + "float **allpass**() Get allpass filter with given coefficient.", + "float **b0**(float value) Set filter coefficient.", + "float **b0**() Get filter coefficient.", + "float **b1**(float value) Set filter coefficient.", + "float **b1**() Get filter coefficient.", + "float **blockZero**(float value) Set DC blocking filter with given pole position.", + "float **blockZero**() Get DC blocking filter with given pole position." + ], + "examples": [ + "Examples: \t [dcblocker.ck](https://chuck.stanford.edu/doc/examples/filter/dcblocker.ck), [plu2.ck](https://chuck.stanford.edu/doc/examples/deep/plu2.ck), [plu3.ck](https://chuck.stanford.edu/doc/examples/deep/plu3.ck), [flute.ck](https://chuck.stanford.edu/doc/examples/stk/flute.ck), [pitch-track.ck](https://chuck.stanford.edu/doc/examples/analysis/tracking/pitch-track.ck), [pitch-third.ck](https://chuck.stanford.edu/doc/examples/analysis/tracking/pitch-third.ck), [pitch-fifth.ck](https://chuck.stanford.edu/doc/examples/analysis/tracking/pitch-fifth.ck), [pitch-seventh.ck](https://chuck.stanford.edu/doc/examples/analysis/tracking/pitch-seventh.ck), [Tracking.ck](https://chuck.stanford.edu/doc/examples/analysis/tracking/Tracking.ck)" + ], + "description": "A one-pole, one-zero digital filter. A method is provided for creating an allpass filter with a given coefficient. Another method is provided to create a DC blocking filter. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Pole-Zero Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#PoleZero)" + }, + "PowerADSR": { + "functions": [ + "**Methods:**", + "dur **attack**(dur attackDuration) Sets duration of the attack phase.", + "float **attackCurve**(float attackCurve) Sets envelope curve of the attack phase.", + "float **attackCurve**() Gets the attack curve.", + "dur **attackTime**(dur attackDuration) Sets duration of the attack phase.", + "dur **attackTime**() Gets the attack duration.", + "dur **decay**(dur decayDuration) Sets duration of the decay phase.", + "float **decayCurve**(float decayCurve) Sets envelope curve of the decay phase.", + "float **decayCurve**() Gets the decay curve.", + "dur **decayTime**(dur decayDuration) Sets duration of the decay phase.", + "dur **decayTime**() Gets the decay duration.", + "int **keyOff**() Begins the release phase of the envelope.", + "int **keyOff**(int keyOff) Begins the release phase of the envelope.", + "int **keyOn**() Begins the attack phase of the envelope.", + "int **keyOn**(int keyOn) Begins the attack phase of the envelope.", + "dur **release**(dur releaseDuration) Sets duration of the release phase.", + "float **releaseCurve**(float releaseCurve) Sets envelope curve of the release phase.", + "float **releaseCurve**() Gets the release curve.", + "dur **releaseTime**(dur releaseDuration) Sets duration of the release phase.", + "dur **releaseTime**() Gets the release duration.", + "void **set**(dur attackDuration, dur decayDuration, float sustainLevel, dur releaseDuration) Sets duration of the attack, decay, and release phases; as well as the sustain level (ADSR order).", + "void **setCurves**(float attackCurve, float decayCurve, float releaseCurve) Sets envelope curves of the attack, decay, and release phases.", + "int **state**() Gets current state.", + "float **sustainLevel**(float sustainLevel) Sets sustain level.", + "float **sustainLevel**() Gets sustain level.", + "float **value**() Gets current envelope value." + ], + "examples": [ + "Examples: \t [PowerADSR-feedback-beatings.ck](https://chuck.stanford.edu/doc/examples/effects/PowerADSR-feedback-beatings.ck), [PowerADSR.ck](https://chuck.stanford.edu/doc/examples/effects/PowerADSR.ck)" + ], + "description": "ADSR envelope that uses a power function to create curved envelope phases. In general, curves under 1.0 are sharp, while curves over 1.0 are soft.", + "title": "**Power ADSR Envelope**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#PowerADSR)" + }, + "PulseOsc": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode.", + "float **width**(float width) Set width of duty cycle [0,1).", + "float **width**() Get width of duty cycle [0,1)/." + ], + "examples": [ + "Examples: \t [pulse.ck](https://chuck.stanford.edu/doc/examples/basic/pulse.ck)" + ], + "description": "A pulse width oscillator.", + "title": "**Pulse Wave Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#PulseOsc)" + }, + "RMS": { + "functions": [ + "**Methods:**", + "float **compute**(float[] input) Manually computes the RMS from a float array." + ], + "examples": [ + "Examples: \t [rms.ck](https://chuck.stanford.edu/doc/examples/ai/features/rms.ck)" + ], + "description": "A unit analyzer that computes the root-mean-square (RMS) power mean from a magnitude spectrum (either from an incoming UAna, or given manually), and outputs a single number.", + "title": "**Root Mean Square**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#RMS)" + }, + "RegEx": { + "functions": [ + "**Methods:**", + "int **match**(string pattern, string str) Return true if match for pattern is found in str, false otherwise.", + "int **match**(string pattern, string str, string[] matches) Return the match and sub-patterns in matches. matches[0] in the entire matched pattern, matches[1] is the first sub-pattern (if any), and so on.", + "string **replace**(string pattern, string replacement, string str) Replace the first instance of pattern in str with replacement, returning the result.", + "string **replaceAll**(string pattern, string replacement, string str) Replace all instances of pattern in str with replacement, returning the result." + ], + "examples": [], + "description": "Class for regular expression matching and replacing in strings. Regex style is POSIX-extended.", + "title": "**Regular Expression**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#RegEx)" + }, + "ResonZ": { + "functions": [ + "**Methods:**", + "float **Q**(float val) Set filter resonance.", + "float **Q**() Get filter resonance.", + "float **freq**(float val) Set filter center frequency.", + "float **freq**() Get filter center frequency.", + "void **set**(float freq, float Q) Set filter frequency and resonance at the same time." + ], + "examples": [ + "Examples: \t [resonz.ck](https://chuck.stanford.edu/doc/examples/filter/resonz.ck)" + ], + "description": "A resonance filter with equal-gain zeros; keeps gain under control independent of frequency.", + "title": "**Resonant Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#ResonZ)" + }, + "Rhodey": { + "functions": [], + "examples": [ + "Examples: \t [rhodey.ck](https://chuck.stanford.edu/doc/examples/stk/rhodey.ck)" + ], + "description": "STK Fender Rhodes-like electric piano FM synthesis instrument. This class implements two simple FM Pairs summed together, also referred to as algorithm 5 of the TX81Z. Algorithm 5 is : 4->3-- + --> Out 2->1-- Control Change Numbers: - Modulator Index One = 2 (.controlOne) - Crossfade of Outputs = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Rhodes Piano**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Rhodey)" + }, + "RollOff": { + "functions": [ + "**Methods:**", + "float **percent**(float percent) Set the percentage for computing rolloff.", + "float **percent**() Get the percentage specified for the rolloff.", + "float **compute**(float[] input, float percent) Manually computes the rolloff from a float array." + ], + "examples": [ + "Examples: \t [rolloff.ck](https://chuck.stanford.edu/doc/examples/ai/features/rolloff.ck), [rolloff2.ck](https://chuck.stanford.edu/doc/examples/ai/features/rolloff2.ck)" + ], + "description": "A unit analyzer that computes the spectral rolloff from a magnitude spectrum (either from incoming UAna, or given manually), and outputs a single number.", + "title": "**Spectral Rolloff**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#RollOff)" + }, + "SFM": { + "functions": [ + "**Methods:**", + "float **compute**(float[] input, float[] output) Manually computes the SFM of the input (an FFT spectrum), and stores the results in the output array (SFM coefficients).", + "int **nrBands**(int nr_bands) Set the number of frequency bands to use for SFM analysis.", + "int **nrBands**() Get the number of frequency bands to use for SFM analysis." + ], + "examples": [ + "Examples: \t [sfm.ck](https://chuck.stanford.edu/doc/examples/ai/features/sfm.ck)" + ], + "description": "A unit analyzer that computes the Spectral Flatness Measure (SFM) from a magnitude spectrum (either from an incoming UAna, or given manually), and outputs a single number.", + "title": "**Spectral Flatness Measure**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#SFM)" + }, + "SVM": { + "functions": [ + "**Methods:**", + "int **predict**(float[] x, float[] y) Predict the output 'y' given the input 'x'.", + "int **train**(float[][] x, float[][] y) Train the SVM model with the given samples 'x' and 'y'." + ], + "examples": [ + "Examples: \t [svm-basic.ck](https://chuck.stanford.edu/doc/examples/ai/svm/svm-basic.ck)" + ], + "description": "A support vector machine (SVM) utility trains a model and predicts output based on new input.", + "title": "**Support Vector Machine**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#SVM)" + }, + "SawOsc": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode.", + "float **width**(float width) Whether sawtooth wave is to fall (0) or rise (1).", + "float **width**() Whether sawtooth wave is to fall (0) or rise (1)." + ], + "examples": [ + "Examples: \t [thx.ck](https://chuck.stanford.edu/doc/examples/deep/thx.ck), [oscillatronx.ck](https://chuck.stanford.edu/doc/examples/basic/oscillatronx.ck)" + ], + "description": "Sawtooth wave oscillator.", + "title": "**Sawtooth Wave Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#SawOsc)" + }, + "Saxofony": { + "functions": [ + "**Methods:**", + "float **aperture**(float value) Set reed aperture, [0.0-1.0].", + "float **aperture**() Get reed aperture, [0.0-1.0].", + "float **blowPosition**(float value) Set lip stiffness, [0.0-1.0].", + "float **blowPosition**() Get lip stiffness, [0.0-1.0].", + "float **clear**(float value) Clear instrument.", + "float **noiseGain**(float value) Set noise component gain, [0.0-1.0].", + "float **noiseGain**() Get noise component gain, [0.0-1.0].", + "float **pressure**(float value) Set pressure, [0.0-1.0].", + "float **pressure**() Get pressure, [0.0-1.0].", + "float **rate**(float value) Set rate of attack (seconds).", + "float **rate**() Get rate of attack (seconds).", + "float **startBlowing**(float value) Start blowing, [0.0-1.0].", + "float **stiffness**(float value) Set reed stiffness, [0.0-1.0].", + "float **stiffness**() Get reed stiffness, [0.0-1.0].", + "float **stopBlowing**(float value) Stop blowing, [0.0-1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain, [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [saxofony.ck](https://chuck.stanford.edu/doc/examples/stk/saxofony.ck)" + ], + "description": "This class implements a 'hybrid' digital waveguide instrument that can generate a variety of wind-like sounds. It has also been referred to as the 'blowed string' model. The waveguide section is essentially that of a string, with one rigid and one lossy termination. The non-linear function is a reed table. The string can be 'blown' at any point between the terminations, though just as with strings, it is impossible to excite the system at either end. If the excitation is placed at the string mid-point, the sound is that of a clarinet. At points closer to the 'bridge', the sound is closer to that of a saxophone. See Scavone (2002) for more details. This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Control Change Numbers: - Reed Stiffness = 2 - Reed Aperture = 26 - Noise Gain = 4 - Blow Position = 11 - Vibrato Frequency = 29 - Vibrato Gain = 1 - Breath Pressure = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Saxophone**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Saxofony)" + }, + "SerialIO": { + "functions": [ + "**Methods:**", + "int **baudRate**(int r) Set baud rate.", + "int **baudRate**() Get current baud rate.", + "void **close**() No description available", + "int **dataAvailable**() No description available", + "void **flush**() Flush the IO buffer.", + "int **getByte**() Get next requested byte.", + "int[] **getBytes**() Get next requested number of bytes.", + "int[] **getInts**() Get next requested number of integers.", + "string **getLine**() Get next requested line.", + "SerialIO **onByte**() Wait for one byte (binary mode only).", + "SerialIO **onBytes**(int num) Wait for requested number of bytes (binary mode only).", + "SerialIO **onFloats**(int num) Wait for requested number of floats (ASCII or binary mode).", + "SerialIO **onInts**(int num) Wait for requested number of ints (ASCII or binary mode).", + "SerialIO **onLine**() Wait for one line (ASCII mode only).", + "int **open**(int i, int baud, int mode) Open serial device i with specified baud rate and mode (binary or ASCII).", + "string **readLine**() No description available", + "void **writeByte**(int b) Write a single byte.", + "void **writeBytes**(int[] b) Write array of bytes.", + "string[] **list**() Get list of available serial devices." + ], + "examples": [ + "Examples: \t [byte.ck](https://chuck.stanford.edu/doc/examples/serial/byte.ck), [bytes.ck](https://chuck.stanford.edu/doc/examples/serial/bytes.ck), [ints-bin.ck](https://chuck.stanford.edu/doc/examples/serial/ints-bin.ck), [ints-ascii.ck](https://chuck.stanford.edu/doc/examples/serial/ints-ascii.ck), [lines.ck](https://chuck.stanford.edu/doc/examples/serial/lines.ck), [list.ck](https://chuck.stanford.edu/doc/examples/serial/list.ck), [write-bytes.ck](https://chuck.stanford.edu/doc/examples/serial/write-bytes.ck), [write.ck](https://chuck.stanford.edu/doc/examples/serial/write.ck)" + ], + "description": "Serial input/output. popularly used to communicate with systems like Arduino.", + "title": "**Serial Input/Output**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/io.html#SerialIO)" + }, + "Shakers": { + "functions": [ + "**Methods:**", + "float **decay**(float value) Set system decay, [0.0-1.0].", + "float **decay**() Get system decay, [0.0-1.0].", + "float **energy**(float value) Set shake energy, [0.0-1.0].", + "float **energy**() Get shake energy, [0.0-1.0].", + "float **freq**(float value) Set frequency (Hz).", + "float **freq**() Get frequency (Hz).", + "float **noteOff**(float value) Trigger note off.", + "float **noteOn**(float value) Trigger note on.", + "float **objects**(float value) Set number of objects, [0.0-128.0].", + "float **objects**() Get number of objects, [0.0-128.0].", + "int **preset**(int value) Set instrument, [0-22] (see above).", + "int **preset**() Get instrument, [0-22] (see above).", + "int **which**(int value) Set instrument, [0-22] (see above).", + "int **which**() Get instrument, [0-22] (see above)." + ], + "examples": [ + "Examples: \t [shake-cycle.ck](https://chuck.stanford.edu/doc/examples/stk/shake-cycle.ck), [shake-o-matic.ck](https://chuck.stanford.edu/doc/examples/stk/shake-o-matic.ck)" + ], + "description": "PhISEM (Physically Informed Stochastic Event Modeling) is an algorithmic approach for simulating collisions of multiple independent sound producing objects. This class is a meta-model that can simulate a Maraca, Sekere, Cabasa, Bamboo Wind Chimes, Water Drops, Tambourine, Sleighbells, and a Guiro. PhOLIES (Physically-Oriented Library of Imitated Environmental Sounds) is a similar approach for the synthesis of environmental sounds. This class implements simulations of breaking sticks, crunchy snow (or not), a wrench, sandpaper, and more. Control Change Numbers: - Shake Energy = 2 - System Decay = 4 - Number Of Objects = 11 - Resonance Frequency = 1 - Shake Energy = 128 - Instrument Selection = 1071 - Maraca = 0 - Cabasa = 1 - Sekere = 2 - Guiro = 3 - Water Drops = 4 - Bamboo Chimes = 5 - Tambourine = 6 - Sleigh Bells = 7 - Sticks = 8 - Crunch = 9 - Wrench = 10 - Sand Paper = 11 - Coke Can = 12 - Next Mug = 13 - Penny + Mug = 14 - Nickle + Mug = 15 - Dime + Mug = 16 - Quarter + Mug = 17 - Franc + Mug = 18 - Peso + Mug = 19 - Big Rocks = 20 - Little Rocks = 21 - Tuned Bamboo Chimes = 22 by Perry R. Cook, 1996 - 1999.", + "title": "**STK Shakers**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Shakers)" + }, + "Shred": { + "functions": [ + "**Methods:**", + "string **arg**(int index) Get the Shred argument at the specified index.", + "int **args**() Get the number of arguments provided to the Shred.", + "int **childMemSize**(int sizeInBytes) Set size hint of per-shred call stack (\"mem\") for children shreds subsequently sporked from the calling shred (NOTE this size hint does not affect the calling shred--only its descendants); if sizeInBytes <= 0, the size hint is set to the VM default. (FYI This is an arcane functionality that most programmers never need to worry about. Advanced usage: set size hint to small values (e.g., 1K) to support A LOT (e.g., >10000) of simultaneous shreds; set size hint to large values (e.g., >65K) to spork functions with extremely deep recursion, or to support A LOT (>10000) of declared local variables. Use with care.)", + "int **childMemSize**() Get the memory stack size hint (in bytes) for shreds sporked from this one.", + "int **childRegSize**(int sizeInBytes) Set size hint of per-shred operand stack (\"reg\") for children shreds subsequently sporked from the calling shred (NOTE this size hint does not affect the calling shred--only its descendants); if sizeInBytes <= 0, the size hint is set to the VM default. (FYI This is an arcane functionality that most programmers never need to worry about. Advanced usage: set size hint to small values (e.g., 256 bytes) to support A LOT (>10000) of simultaneous shreds; set size hint to large values (e.g., >20K) to spork functions with extremely lengthy (>10000) statements, including array initializer lists. Use with care.)", + "int **childRegSize**() Get the operand stack size hint (in bytes) for shreds sporked from this one.", + "string **dir**() Get the enclosing directory of the source file from which this Shred's code is derived (same as .sourceDir()).", + "string **dir**(int levelsUp) Get the enclosing directory, the specified number of parent directories up.", + "int **done**() Has the Shred reached the end of its execution?", + "void **exit**() Halt the shred's operation and remove it from the virtual machine.", + "int **id**() Get the unique numeric id of the Shred.", + "string **path**() Get the path of the source file from which this Shred's code is derived (same as .sourcePath()).", + "int **running**() Is the Shred currently actively running in the VM?", + "string **sourceDir**() Get the enclosing directory of the source file from which this Shred's code is derived (same as .dir()).", + "string **sourcePath**() Get the path of the source file from which this Shred's code is derived (same as .path()).", + "void **yield**() Cause the current Shred to temporarily suspend without advancing time, allowing other simultaneously schreduled shreds to run as needed. NOTE: yield() is equivalent to '0::second +=> now;'", + "Shred **ancestor**() Get the calling shred's \"ancestor\" shred (i.e., the top-level shred). Returns itself if the calling shred is the top-level shred. (Related: see Shred.parent())", + "Shred **fromId**(int id) Get Shred corresponding to a Shred ID.", + "Shred **parent**() Get the calling shred's parent shred (i.e., the shred that sporked the calling shred). Returns null if there is no parent Shred. (Related: see Shred.ancestor())" + ], + "examples": [ + "Examples: \t [spork.ck](https://chuck.stanford.edu/doc/examples/shred/spork.ck), [spork2.ck](https://chuck.stanford.edu/doc/examples/shred/spork2.ck), [spork2-exit.ck](https://chuck.stanford.edu/doc/examples/shred/spork2-exit.ck), [spork2-remove.ck](https://chuck.stanford.edu/doc/examples/shred/spork2-remove.ck), [powerup.ck](https://chuck.stanford.edu/doc/examples/shred/powerup.ck), [broadcast.ck](https://chuck.stanford.edu/doc/examples/event/broadcast.ck), [signal.ck](https://chuck.stanford.edu/doc/examples/event/signal.ck), [signal4.ck](https://chuck.stanford.edu/doc/examples/event/signal4.ck), [parent.ck](https://chuck.stanford.edu/doc/examples/shred/parent.ck), [ancestor.ck](https://chuck.stanford.edu/doc/examples/shred/ancestor.ck)" + ], + "description": "A strongly-timed ChucK thread of execution.", + "title": "**ChucK Shred Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#Shred)" + }, + "Sigmund": { + "functions": [ + "**Methods:**", + "float **amp**(int amp) Report amplitude of nth sinusoundal peak sorting depends on parameter \"tracks.\"", + "void **clear**() Clear buffers and reset.", + "float **env**() Get reported RMS value (in dB) of input signal.", + "float **freq**() Get reported frequency of input signal.", + "float **maxfreq**(float arg) Set maximum frequency of sinusoidal peaks to look for. This can be useful in situations where background noise creates high-frequency, spurious peaks...", + "float **minpower**(float arg) Set the minimum dB level to report a pitch. Signals quieter than this will be assumed to be crosstalk and ignored. default: 50.", + "int **npeak**(int npeak) Set the maximum number of sinusoidal peaks to look for. The computation time is quadratic in the number of peaks actually found (this number only sets an upper limit). Use it to balance CPU time with quality of results.", + "int **npts**(int npts) Set the number of points used in analysis. Must be a power of 2, at least 128. The minimum frequency that can be tracked is about 2 * samplerate / npts. Default: 1024.", + "float **param1**(float arg) Mysterious setting...", + "float **param2**(float arg) Mysterious setting...", + "float **param3**(float arg) Mysterious setting...", + "float **peak**(int peak) Report freq of nth sinusoundal peak sorting. Depends on parameter \"tracks.\"", + "dur **stabletime**(dur stabletime) Set period of stability needed for note. Not implemented.", + "int **tracks**(int tracks) Toggle whether peak and amp are sorted in order of amplitude or organized into tracks. Default false." + ], + "examples": [ + "Examples: \t [Sigmund.ck](https://chuck.stanford.edu/doc/examples/analysis/Sigmund.ck)" + ], + "description": "Sinusoidal analysis & pitch tracking. Adapted from Miller Puckette’s sigmund~ Max object.", + "title": "**Pitch Tracking UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Sigmund)" + }, + "SinOsc": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode." + ], + "examples": [ + "Examples: \t [otf_05.ck](https://chuck.stanford.edu/doc/examples/otf_05.ck), [otf_06.ck](https://chuck.stanford.edu/doc/examples/otf_06.ck), [foo.ck](https://chuck.stanford.edu/doc/examples/basic/foo.ck), [bar.ck](https://chuck.stanford.edu/doc/examples/basic/bar.ck), [chirp.ck](https://chuck.stanford.edu/doc/examples/basic/chirp.ck), [alarm.ck](https://chuck.stanford.edu/doc/examples/basic/alarm.ck), [whirl.ck](https://chuck.stanford.edu/doc/examples/basic/whirl.ck), [fft.ck](https://chuck.stanford.edu/doc/examples/analysis/fft.ck)" + ], + "description": "A sine wave oscillator.", + "title": "**Sine Wave Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#SinOsc)" + }, + "Sitar": { + "functions": [ + "**Methods:**", + "float **clear**(float value) Clear instrument.", + "float **pluck**(float value) Pluck string." + ], + "examples": [ + "Examples: \t [sitar.ck](https://chuck.stanford.edu/doc/examples/stk/sitar.ck)" + ], + "description": "This class implements a sitar plucked string physical model based on the Karplus-Strong algorithm. This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. There exist at least two patents, assigned to Stanford, bearing the names of Karplus and/or Strong. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Sitar**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Sitar)" + }, + "SndBuf": { + "functions": [ + "**Methods:**", + "int **channel**(int channel) For sound file containing more than one channel of audio, select the channel to play.", + "int **channel**() Get the selected chanel of audio this buffer is playing.", + "int **channels**() Get number of channels available in the sound file.", + "int **chunks**(int frames) Set chunk size, in frames, for loading the file from disk. Set to 0 to disable chunking.", + "int **chunks**() Get chunk size, in frames, for loading the file from disk. 0 indicates that chunking is disabled.", + "int **frames**() Get total number of sample frames in the file; same as .samples().", + "float **freq**(float freq) Set loop rate (in file loops per second).", + "float **freq**() Get loop rate (in file loops per second).", + "int **interp**(int interp) Set interpolation mode: (0) drop sample; (1) linear interpolation; (2) sinc interpolation.", + "int **interp**() Get interpolation mode: (0) drop sample; (1) linear interpolation; (2) sinc interpolation.", + "dur **length**() Get total length of the file as a duration.", + "int **loop**(int loop) Toggle looping file playback.", + "int **loop**() Get whether file playback is set to loop.", + "float **phase**(float phase) Set phase position, normalized to [0,1).", + "float **phase**() Get phase position, normalized to [0,1).", + "float **phaseOffset**(float value) Advance the playhead by the specified phase offset in [0,1), where 0 is no advance and 1 advance the entire length of the file.", + "float **play**(float play) (same as .rate)", + "float **play**() (same as .rate)", + "int **pos**(int pos) Set play position (between 0 and number of samples).", + "int **pos**() Get play position (between 0 and number of samples).", + "float **rate**(float rate) Set playback rate (relative to file's natural speed). For example, 1.0 is 'normal', 0.5 is half speed, and 2 is twice as fast.", + "float **rate**() Get playback rate (relative to file's natural speed). For example, 1.0 is 'normal', 0.5 is half speed, and 2 is twice as fast.", + "string **read**(string read) Read file for reading.", + "int **ready**() Query whether the SndBuf is ready for use (e.g., sound file successfully loaded).", + "int **samples**() Get total number of sample frames in the file; same as .frames().", + "float **valueAt**(int pos) Get sample value at given position (in samples).", + "string **write**(string read) Set file for writing (currently unsupported)." + ], + "examples": [ + "Examples: \t [sndbuf.ck](https://chuck.stanford.edu/doc/examples/basic/sndbuf.ck), [doh.ck](https://chuck.stanford.edu/doc/examples/basic/doh.ck), [valueat.ck](https://chuck.stanford.edu/doc/examples/basic/valueat.ck), [otf_01.ck](https://chuck.stanford.edu/doc/examples/otf_01.ck), [otf_02.ck](https://chuck.stanford.edu/doc/examples/otf_02.ck), [otf_03.ck](https://chuck.stanford.edu/doc/examples/otf_03.ck), [otf_04.ck](https://chuck.stanford.edu/doc/examples/otf_04.ck)" + ], + "description": "An interpolating sound buffer/player with single-channel output; can read audio data from a variety of uncompressed formats.", + "title": "**Sound Buffer Player**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#SndBuf)" + }, + "SndBuf2": { + "functions": [ + "**Methods:**", + "int **channel**(int channel) For sound file containing more than one channel of audio, select the channel to play.", + "int **channel**() Get the selected chanel of audio this buffer is playing.", + "int **channels**() Get number of channels available in the sound file.", + "int **chunks**(int frames) Set chunk size, in frames, for loading the file from disk. Set to 0 to disable chunking.", + "int **chunks**() Get chunk size, in frames, for loading the file from disk. 0 indicates that chunking is disabled.", + "int **frames**() Get total number of sample frames in the file; same as .samples().", + "float **freq**(float freq) Set loop rate (in file loops per second).", + "float **freq**() Get loop rate (in file loops per second).", + "int **interp**(int interp) Set interpolation mode: (0) drop sample; (1) linear interpolation; (2) sinc interpolation.", + "int **interp**() Get interpolation mode: (0) drop sample; (1) linear interpolation; (2) sinc interpolation.", + "dur **length**() Get total length of the file as a duration.", + "int **loop**(int loop) Toggle looping file playback.", + "int **loop**() Get whether file playback is set to loop.", + "float **phase**(float phase) Set phase position, normalized to [0,1).", + "float **phase**() Get phase position, normalized to [0,1).", + "float **phaseOffset**(float value) Advance the playhead by the specified phase offset in [0,1), where 0 is no advance and 1 advance the entire length of the file.", + "float **play**(float play) (same as .rate)", + "float **play**() (same as .rate)", + "int **pos**(int pos) Set play position (between 0 and number of samples).", + "int **pos**() Get play position (between 0 and number of samples).", + "float **rate**(float rate) Set playback rate (relative to file's natural speed). For example, 1.0 is 'normal', 0.5 is half speed, and 2 is twice as fast.", + "float **rate**() Get playback rate (relative to file's natural speed). For example, 1.0 is 'normal', 0.5 is half speed, and 2 is twice as fast.", + "string **read**(string read) Read file for reading.", + "int **ready**() Query whether the SndBuf is ready for use (e.g., sound file successfully loaded).", + "int **samples**() Get total number of sample frames in the file; same as .frames().", + "float **valueAt**(int pos) Get sample value at given position (in samples).", + "string **write**(string read) Set file for writing (currently unsupported)." + ], + "examples": [], + "description": "An interpolating sound buffer with two-channel output. Reads from a variety of uncompressed formats.", + "title": "**Sound Buffer Player (Stereo)**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#SndBuf2)" + }, + "Spectacle": { + "functions": [ + "**Methods:**", + "int **bands**(int arg) Set number of frequency bands, [1 - 512], default 64.", + "int **bands**() Get number of frequency bands, [1 - 512], default 64.", + "void **clear**() Reset Spectacle.", + "dur **delay**(dur delay) Set the same delay duration for all bands.", + "dur **delayMax**(dur delay) Set maximum delay time.", + "dur **delayMax**() Get maximum delay time.", + "dur **delayMin**(dur delay) Set minimum delay time.", + "dur **delayMin**() Get minimum delay time.", + "float **eq**(float eq) Set the same EQ value for all bands (value is +/- dB).", + "float **feedback**(float feedback) Set the same feedback value for all bands [-1.0 - 1.0].", + "int **fftlen**(int arg) Set FFT frame size (power of 2).", + "int **fftlen**() Get FFT frame size (power of 2).", + "float **freqMax**(float arg) Set maximum frequency processed by Spectacle.", + "float **freqMax**() Get maximum frequency processed by Spectacle.", + "float **freqMin**(float arg) Set minimum frequency processed by Spectacle.", + "float **freqMin**() Get minimum frequency processed by Spectacle.", + "int **hold**(int arg) Set hold. True to suppress input, false disables.", + "int **hold**() Get hold. True to suppress input, false disables.", + "float **mix**(float mix) Set mix of processed and unprocessed signal [0 - 1].", + "float **mix**() Get mix of processed and unprocessed signal [0 - 1].", + "int **overlap**(int arg) Set frame overlap; best between 2 and 6.", + "int **overlap**() Get frame overlap; best between 2 and 6.", + "int **posteq**(int arg) Set posteq to true to apply EQ after delay, rather than before.", + "int **posteq**() Get posteq. True applies EQ after delay, rather than before.", + "void **range**(float arg1, float arg2) Set both min and max freqs in one command.", + "int **table**(string table, string type) Set \"delay\", “eq”, or \"feedback\" tables to the types \"random\", \"ascending\", or \"descending.\" Example: table(\"delay\", \"random\");." + ], + "examples": [ + "Examples: \t [Spectacle.ck](https://chuck.stanford.edu/doc/examples/effects/Spectacle.ck)" + ], + "description": "FFT-based spectral delay and EQ by John Gibson. Inspired by the totally awesome Spektral Delay plug-in by Native Instruments.", + "title": "**Spectral Delay and EQ**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#Spectacle)" + }, + "SqrOsc": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode.", + "float **width**() Set width of duty cycle (always 0.5)." + ], + "examples": [ + "Examples: \t [oscillatronx.ck](https://chuck.stanford.edu/doc/examples/basic/oscillatronx.ck), [brf.ck](https://chuck.stanford.edu/doc/examples/filter/brf.ck), [rlpf.ck](https://chuck.stanford.edu/doc/examples/filter/rlpf.ck), [rhpf.ck](https://chuck.stanford.edu/doc/examples/filter/rhpf.ck)" + ], + "description": "A square wave oscillator (same as PulseOsc with 0.5 duty cycle).", + "title": "**Square Wave Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#SqrOsc)" + }, + "Std": { + "functions": [ + "**Methods:**", + "int **abs**(int value) Return absolute value of integer.", + "float **atof**(string value) Converts ascii (string) to floating point value (float).", + "int **atoi**(string value) Convert ascii (string) to integer (int).", + "int **clamp**(int value, int min, int max) Clamp integer to range [min, max].", + "float **clampf**(float value, float min, float max) Clamp float to range [min, max].", + "float **dbtolin**(float value) Convert decibels (dB) to linear amplitude.", + "float **dbtopow**(float value) Convert decibels (dB) to signal power ratio.", + "float **dbtorms**(float value) Convert decibels (dB) to rms.", + "float **fabs**(float value) Return absolute value of float.", + "string **ftoa**(float f, int precision) Converts floating point value (float) to ascii (string) with specified precision (number of decimal digits).", + "int **ftoi**(float f) Convert float to integer.", + "float **ftom**(float value) Convert frequency (Hz) to MIDI note number space.", + "string **getenv**(string key) Get the value of an environment variable (e.g., PATH).", + "string **getenv**(string key, string default) Get the value of an environment variable, returning the provided default if unset.", + "string **itoa**(int i) Converts integer (int) to ascii (string).", + "float **lintodb**(float value) Convert linear amplitude to decibels (dB).", + "float **mtof**(float value) Convert a MIDI note number to frequency (Hz). Note the input value is of type float (supports fractional note number). For reference, MIDI note number 60 is Middle C; each whole number is one semitone.", + "float **powtodb**(float value) Convert signal power ratio to decibels (dB).", + "int **rand2**(int min, int max) Generate a random integer in range [min, max]. (NOTE: this is deprecated; use Math.random2()).", + "float **rand2f**(float min, float max) Generate random floating point number in the range [min, max]. (NOTE: this is deprecated; use Math.random2f())", + "int **rand**() Generate a random integer between 0 and Std.RAND_MAX. (NOTE: this is deprecated; use Math.random()).", + "float **randf**() Generate random floating point number in the range [-1, 1]. (Note: this is deprecated; use Math.randomf())", + "int[] **range**(int stop) Return array containing the range [0,stop).", + "int[] **range**(int start, int stop) Return array containing the range [start,stop).", + "int[] **range**(int start, int stop, int step) Return array containing values from start up to (but not including) stop, hopping by step.", + "float **rmstodb**(float value) Convert rms to decibels (dB).", + "float **scalef**(float value, float srcmin, float srcmax, float dstmin, float dstmax) Scale a float from source range to destination range.", + "int **setenv**(string key, string value) Set the value of environment variable named 'key'", + "float **sgn**(float value) Get sign of value as -1 (negative), 0, or 1 (positive).", + "void **srand**(int seed) Seed the random number generator. Different seeds will likely generate different sequences of random numbers even if the seeds are close together; alternatively, a sequence of random numbers can be repeated by setting the same seed. (NOTE: this is deprecated; use Math.srandom())", + "int **system**(string cmd) Pass a command to be executed in the shell (requires --caution-to-the-wind flag to be set).", + "static member variables int RAND_MAX", + "The largest possible value returned by Std.**rand**(). [ top ]" + ], + "examples": [], + "description": "A standard library in ChucK, which includes utility functions for random number generation, unit conversions, and absolute value.", + "title": "**ChucK Standard Library**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#Std)" + }, + "Step": { + "functions": [ + "**Methods:**", + "float **next**(float next) Set the next step value.", + "float **next**() Get the next step value." + ], + "examples": [ + "Examples: \t [step.ck](https://chuck.stanford.edu/doc/examples/basic/step.ck), [fm3.ck](https://chuck.stanford.edu/doc/examples/basic/fm3.ck), [zerox.ck](https://chuck.stanford.edu/doc/examples/basic/zerox.ck)" + ], + "description": "A step generator. Step behaves like Impulse, except that once a next value is set, that value is held for all following samples, until a different value is set.", + "title": "**Step Function Generator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#Step)" + }, + "StifKarp": { + "functions": [ + "**Methods:**", + "float **baseLoopGain**(float value) Set base loop gain, [0.0-1.0].", + "float **baseLoopGain**() Get base loop gain, [0.0-1.0].", + "float **clear**(float value) Clear instrument.", + "float **pickupPosition**(float value) Set pickup position, [0.0-1.0].", + "float **pickupPosition**() Get pickup position, [0.0-1.0].", + "float **pluck**(float value) Pluck string.", + "float **stretch**(float value) Set string stretch, [0.0-1.0].", + "float **stretch**() Get string stretch, [0.0-1.0].", + "float **sustain**(float value) Set string sustain, [0.0-1.0].", + "float **sustain**() Get string sustain, [0.0-1.0]." + ], + "examples": [ + "Examples: \t [stifkarp.ck](https://chuck.stanford.edu/doc/examples/stk/stifkarp.ck), [stif-o-karp.ck](https://chuck.stanford.edu/doc/examples/stk/stif-o-karp.ck)" + ], + "description": "This class implements a simple plucked string algorithm (Karplus Strong) with enhancements (Jaffe-Smith, Smith, and others), including string stiffness and pluck position controls. The stiffness is modeled with allpass filters. This is a digital waveguide model, making its use possibly subject to patents held by Stanford University, Yamaha, and others. Control Change Numbers: - Pickup Position = 4 - String Sustain = 11 - String Stretch = 1 by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Stiff Karplus-Strong**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#StifKarp)" + }, + "StkInstrument": { + "functions": [ + "**Methods:**", + "void **controlChange**(int ctrl, float value) Assert control change; numbers are instrument specific; value range [0.0 - 127.0].", + "float **freq**(float value) Set frequency.", + "float **freq**() Get frequency.", + "float **noteOff**(float value) Trigger note off.", + "float **noteOn**(float value) Trigger note on." + ], + "examples": [], + "description": "Super-class for STK instruments.", + "title": "**STK Instrument**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#StkInstrument)" + }, + "StringTokenizer": { + "description": "Break a string into tokens. This uses whitespace as the delimiter.", + "examples": [ + "Examples: \t [token.ck](https://chuck.stanford.edu/doc/examples/string/token.ck), [readline.ck](https://chuck.stanford.edu/doc/examples/string/readline.ck), [read-tokens.ck](https://chuck.stanford.edu/doc/examples/io/read-tokens.ck), [jabberwocky.txt](https://chuck.stanford.edu/doc/examples/io/jabberwocky.txt), [word2vec-prompt.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/word2vec-prompt.ck)" + ], + "functions": [ + "**Methods:**", + "string **get**(int index) Return the i-th token in the set string.", + "string **get**(int index, string out) Return the i-th token in the set string. Additionally, write the token string to the `out` string variable.", + "int **more**() Return true (1) if there are still more tokens, false (0) if no more tokens.", + "string **next**() Return the next token string.", + "string **next**(string out) Return the next token string. Additionally, write the token string to the 'out' string variable.", + "void **reset**() Reset token iteration back to the beginning of the set string.", + "void **set**(string line) Set the string to be tokenized.", + "int **size**() Returns the number of token strings that the set string can be broken into." + ], + "title": "**String Tokenizer**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/utils.html#StringTokenizer)" + }, + "SubNoise": { + "functions": [ + "**Methods:**", + "int **rate**(int value) Set subsampling rate.", + "int **rate**() Get subsampling rate." + ], + "examples": [ + "Examples: \t [subnoise-control.ck](https://chuck.stanford.edu/doc/examples/stk/subnoise-control.ck), [subnoise-audio.ck](https://chuck.stanford.edu/doc/examples/stk/subnoise-audio.ck)" + ], + "description": "Generates a new random number every 'rate' ticks using the C `rand()` function. The quality of the r`and()` function varies from one OS to another. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Sub-Sampling Noise Generator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#SubNoise)" + }, + "TriOsc": { + "functions": [ + "**Methods:**", + "float **freq**(float hz) Set frequency of oscillator in Hertz; maintains phase.", + "float **freq**() Get frequency of oscillator in Hertz.", + "dur **period**(dur value) Set period of oscillator (inverse of frequency).", + "dur **period**() Get period of oscillator (inverse of frequency).", + "float **phase**(float phase) Set oscillator phase, in range [0,1).", + "float **phase**() Get oscillator phase, in range [0,1).", + "float **sfreq**(float hz) Set frequency of oscillator in Hertz; resets phase to 0.", + "int **sync**(int type) Choose how to interpret input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **sync**() Get current interpretation of input: (0) sync frequency to input; (1) sync phase to input; (2) frequency modulation (add input to internal frequency).", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode.", + "float **width**(float width) Set width of triangle wave (ratio of rise time to fall time).", + "float **width**() Get width of triangle wave (ratio of rise time to fall time)." + ], + "examples": [ + "Examples: \t [oscillatronx.ck](https://chuck.stanford.edu/doc/examples/basic/oscillatronx.ck), [shepard.ck](https://chuck.stanford.edu/doc/examples/deep/shepard.ck)" + ], + "description": "A triangle wave oscillator.", + "title": "**Triangle Wave Oscillator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#TriOsc)" + }, + "TubeBell": { + "functions": [], + "examples": [], + "description": "STK tubular bell (orchestral chime) FM synthesis instrument. This class implements two simple FM Pairs summed together, also referred to as algorithm 5 of the TX81Z. Algorithm 5 is : 4->3-- + --> Out 2->1-- Control Change Numbers: - Modulator Index One = 2 (.controlOne) - Crossfade of Outputs = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Tubular Bell**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#TubeBell)" + }, + "TwoPole": { + "functions": [ + "**Methods:**", + "float **a1**(float value) Set filter coefficient.", + "float **a1**() Get filter coefficient.", + "float **a2**(float value) Set filter coefficient.", + "float **a2**() Get filter coefficient.", + "float **b0**(float value) Set filter coefficient.", + "float **b0**() Get filter coefficient.", + "float **freq**(float value) Set filter resonance frequency.", + "float **freq**() Get filter resonance frequency.", + "int **norm**(int value) Set filter normalization.", + "int **norm**() Get filter normalization.", + "float **radius**(float value) Set filter radius resonance.", + "float **radius**() Get filter radius resonance." + ], + "examples": [ + "Examples: \t [powerup.ck](https://chuck.stanford.edu/doc/examples/shred/powerup.ck)" + ], + "description": "This Filter subclass implements a two-pole digital filter. A method is provided for creating a resonance in the frequency response while maintaining a nearly constant filter gain. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Two-Pole Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#TwoPole)" + }, + "TwoZero": { + "functions": [ + "**Methods:**", + "float **b0**(float value) Set filter coefficient.", + "float **b0**() Get filter coefficient.", + "float **b1**(float value) Set filter coefficient.", + "float **b1**() Get filter coefficient.", + "float **b2**(float value) Set filter coefficient.", + "float **b2**() Get filter coefficient.", + "float **freq**(float value) Set filter notch frequency.", + "float **freq**() Get filter notch frequency.", + "float **radius**(float value) Set filter notch radius.", + "float **radius**() Get filter notch radius." + ], + "examples": [ + "Examples: \t [chant.ck](https://chuck.stanford.edu/doc/examples/deep/chant.ck), [say-chu.ck](https://chuck.stanford.edu/doc/examples/deep/say-chu.ck)" + ], + "description": "This Filter subclass implements a two-zero digital filter. A method is provided for creating a 'notch' in the frequency response while maintaining a constant filter gain. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Two-Zero Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-filters.html#TwoZero)" + }, + "Type": { + "description": "A representation of a ChucK type.", + "examples": [ + "Examples: \t [type_type.ck](https://chuck.stanford.edu/doc/examples/type/type_type.ck), [type_query.ck](https://chuck.stanford.edu/doc/examples/type/type_query.ck)" + ], + "functions": [ + "**Methods:**", + "int **arrayDepth**() Return the number of array dimensions associated with this Type (e.g., 'int[][]' has 2; 'int' has 0).", + "string **baseName**() Return the base name of this Type. The base of name of an array Type is the type without the array dimensions (e.g., base name of 'int[][]' is 'int')", + "Type[] **children**() Retrieve this Type's children Types.", + "int **equals**(Type another) Return whether this Type is same as 'another'.", + "int **isArray**() Return whether this Type is some kind of an array.", + "int **isPrimitive**() Return whether this is a primitive Type (e.g., 'int' and 'dur' are primitives types; 'Object' and its children Types are not).", + "int **isa**(Type another) Return whether this Type is a kind of 'another'.", + "int **isa**(string another) Return whether this Type is a kind of 'another'.", + "string **name**() Return the name of this Type.", + "string **origin**() Return a string describing where this Type was defined (e.g., \"builtin\", \"chugin\", \"cklib\", \"user\").", + "Type **parent**() Return this Type's parent Type; returns null if this Type is 'Object'.", + "Type **find**(string typeName) Find and return the Type associated with 'typeName'; returns null if no Types currently in the VM with that name.", + "Type[] **getTypes**(int attributes, int origins) Retrieve all top-level Types in the ChucK runtime type system that fit the attributes and origins flags. Flags that can bitwise-OR'ed for attributes: Type.ATTRIB_OBJECT, Type.ATTRIB_PRIMITIVE, TYPE_SPECIAL -- and for origins: Type.ORIGIN_BUILTIN, Type.ORIGIN_CHUGIN, Type.ORIGIN_CKLIB, Type.ORIGIN_USER.", + "Type[] **getTypes**() Retrieves all top-level Types currently in the type system.", + "Type **of**(Object obj) Return the Type of 'obj'", + "Type **of**(int val) Return the Type associated with 'int'.", + "Type **of**(float val) Return the Type associated with 'float'.", + "Type **of**(time val) Return the Type associated with 'time'.", + "Type **of**(dur val) Return the Type associated with 'dur'.", + "Type **of**(complex val) Return the Type associated with 'complex'.", + "Type **of**(polar val) Return the Type associated with 'polar'.", + "Type **of**(vec3 val) Return the Type associated with 'vec3'.", + "Type **of**(vec4 val) Return the Type associated with 'vec4'." + ], + "title": "**ChucK Type Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/utils.html#Type)" + }, + "UAna": { + "functions": [ + "**Methods:**", + "complex **cval**(int index) Get blob's complex value at index.", + "complex[] **cvals**() Get blob's complex array.", + "float **fval**(int index) Get blob's float value at index.", + "float[] **fvals**() Get blob's float array.", + "int **isUpConnectedTo**(UAna right) Is connected to another uana via =^?", + "UAnaBlob **upchuck**() Initiate analysis at the UAna and return result." + ], + "examples": [], + "description": "Base class from which all unit analyzer (UAna) types inherit; UAnae (note plural form) can be interconnected using => (chuck operator for synthesis; all UAnae are also UGens) or using =^ (upchuck operator for analysis) -- the operator used will determine how data is passed. When .upchuck() is invoked on a given UAna, the UAna-chain (i.e., UAnae connected via =^) is traversed upstream from the upchucked UAna, and analysis is performed at each UAna along the chain; the analysis results are returned in UAnaBlobs.", + "title": "**Unit Analyzer Base Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#UAna)" + }, + "UAnaBlob": { + "functions": [ + "**Methods:**", + "complex **cval**(int index) Get blob's complex value at index.", + "complex[] **cvals**() Get blob's complex array.", + "float **fval**(int index) Get blob's float value at index.", + "float[] **fvals**() Get blob's float array.", + "time **when**() Get the time when blob was last upchucked." + ], + "examples": [], + "description": "A data structure that contains results associated with UAna analysis. There is a UAnaBlob associated with every UAna. As a UAna is upchucked (using .upchuck()), the result is stored in the UAnaBlob's floating point vector and/or complex vector. The interpretation of the results depends on the specific UAna.", + "title": "**Unit Analyzer Blob**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#UAnaBlob)" + }, + "UGen": { + "functions": [ + "**Methods:**", + "int **buffered**(int val) Set the unit generator's buffered operation mode, typically used externally from hosts that embed ChucK as a component. If true, the UGen stores a buffer of its most recent samples, which can be fetched using global variables in the host language.", + "int **buffered**() Get the ugen's buffered operation mode.", + "UGen **chan**(int num) Get channel (as a UGen) at specified index.", + "int **channels**(int num) Set number of channels. (currently NOT supported)", + "int **channels**() Get number of channels.", + "float **gain**(float val) Set the gain of the unit generator.", + "float **gain**() Get the gain of the unit generator.", + "int **isConnectedTo**(UGen rhs) Return true if this UGen's output is connected to the input of rhs; if either this UGen or rhs has more than one channel, this function returns true if any connections exist between the channels; return false if there are no connections.", + "float **last**() Get the last sample value of the unit generator.", + "int **op**(int val) Set the unit generator's operation mode. Accepted values are: 1 (sum inputs), 2 (take difference between first input and subsequent inputs), 3 (multiply inputs), 4 (divide first input by subsequent inputs), 0 (do not synthesize audio, output 0) or -1 (passthrough inputs to output).", + "int **op**() Get the unit generator's operation mode." + ], + "examples": [], + "description": "Base class for all unit generator (UGen) types.", + "title": "**Unit Generator Base Class**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#UGen)" + }, + "UGen_Multi": { + "functions": [ + "**Methods:**", + "UGen **chan**(int which) Get UGen representing a specific channel of this UGen, or null if no such channel is available." + ], + "examples": [], + "description": "Base class for multi-channel unit generators.", + "title": "**Multi-Channel UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#UGen_Multi)" + }, + "UGen_Stereo": { + "functions": [ + "**Methods:**", + "float **pan**(float val) Pan between left and right channels, in range [-1,1], with -1 being far-left, 1 far-right, and 0 centered.", + "float **pan**() Pan between left and right channels, in range [-1,1], with -1 being far-left, 1 far-right, and 0 centered.", + "int **panType**(int val) Set the panning type: (1) constant power panning, (0) unity gain anti-panning.", + "int **panType**() Get the panning type: (1) constant power panning, (0) unity gain anti-panning.", + "member variables UGen left", + "Left **channel**(same as .chan(0)). UGen right", + "Right **channel**(same as .chan(1)). [ top ]" + ], + "examples": [], + "description": "Base class for stereo unit generators.", + "title": "**Stereo UGen**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-basic.html#UGen_Stereo)" + }, + "UnFlip": { + "functions": [ + "**Methods:**", + "void **output**(float[] buffer) Manually take pilF (as opposed to using .upchuck() / upchuck operator)", + "int **size**(int size) Set the pilF size.", + "int **size**() Get the pilF size.", + "void **transform**() Manually take pilF (as opposed to using .upchuck() / upchuck operator).", + "float[] **window**(float[] win) Set/get the transform window/size.", + "int **windowSize**() Get the current window size." + ], + "examples": [ + "Examples: \t [flip.ck](https://chuck.stanford.edu/doc/examples/analysis/flip.ck)" + ], + "description": "Turns UAna frames into audio samples, via overlap add.", + "title": "**Signal Unflip**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#UnFlip)" + }, + "VoicForm": { + "functions": [ + "**Methods:**", + "float **loudness**(float value) Set 'loudness' of voice, [0.0-1.0].", + "float **loudness**() Get 'loudness' of voice, [0.0-1.0].", + "string **phoneme**(string value) Set phoneme (see above).", + "string **phoneme**() Get phoneme (see above).", + "int **phonemeNum**(int value) Set phoneme by number, [0.0-128.0].", + "int **phonemeNum**() Get phoneme by number, [0.0-128.0].", + "float **pitchSweepRate**(float value) Set rate of pitch sweep, [0.0-1.0].", + "float **pitchSweepRate**() Get rate of pitch sweep, [0.0-1.0].", + "float **quiet**(float value) Stop singing, [0.0-1.0].", + "float **speak**(float value) Start singing, [0.0-1.0].", + "float **unVoiced**(float value) Set mix for unvoiced component, [0.0 - 1.0].", + "float **unVoiced**() Get mix for unvoiced component, [0.0 - 1.0].", + "float **vibratoFreq**(float value) Set vibrato frequency (Hz).", + "float **vibratoFreq**() Get vibrato frequency (Hz).", + "float **vibratoGain**(float value) Set vibrato gain (Hz), [0.0-1.0].", + "float **vibratoGain**() Get vibrato gain (Hz), [0.0-1.0].", + "float **voiceMix**(float value) Set voiced/unvoiced mix, [0.0-1.0].", + "float **voiceMix**() Get voiced/unvoiced mix, [0.0-1.0].", + "float **voiced**(float value) Set mix for voiced component, [0.0 - 1.0].", + "float **voiced**() Get mix for voiced component, [0.0 - 1.0]." + ], + "examples": [ + "Examples: \t [voic-o-form.ck](https://chuck.stanford.edu/doc/examples/stk/voic-o-form.ck)" + ], + "description": "This instrument contains an excitation singing wavetable (looping wave with random and periodic vibrato, smoothing on frequency, etc.), excitation noise, and four sweepable complex resonances. Measured formant data is included, and enough data is there to support either parallel or cascade synthesis. In the floating point case cascade synthesis is the most natural so that's what you'll find here. Control Change Numbers: Voiced/Unvoiced Mix = 2 Vowel/Phoneme Selection = 4 Vibrato Frequency = 11 Vibrato Gain = 1 Loudness (Spectral Tilt) = 128 by Perry R. Cook and Gary P. Scavone, 1995 - 2002. Phoneme Names: 'eee' 'ihh' 'ehh' 'aaa' 'ahh' 'aww' 'ohh' 'uhh' 'uuu' 'ooo' 'rrr' 'lll' 'mmm' 'nnn' 'nng' 'ngg' 'fff' 'sss' 'thh' 'shh' 'xxx' 'hee' 'hoo' 'hah' 'bbb' 'ddd' 'jjj' 'ggg' 'vvv' 'zzz' 'thz' 'zhh'", + "title": "**STK Voice Formant**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#VoicForm)" + }, + "WPDiodeLadder": { + "functions": [ + "**Methods:**", + "float **cutoff**(float arg) Cuttoff is in Hz [0..Nyquist).", + "float **cutoff**() Get cuttoff frequency in Hz [0..Nyquist).", + "int **nlp_type**(int arg) Set to 1 to normalize non-linear output.", + "int **nlp_type**() Get non-linear output setting. 1 is normalized.", + "int **nonlinear**(int arg) Enable non linear saturator.", + "int **nonlinear**() Get non-linear saturator setting. 1 is enabled.", + "float **resonance**(float arg) Resonance goes between [0...17].", + "float **resonance**() Get resonance [0 - 17].", + "float **saturation**(float arg) Saturation is a scalar gain, and can be used to drive the non-linearity.", + "float **saturation**() Get saturation. Saturation is a scalar gain, and can be used to drive the non-linearity." + ], + "examples": [ + "Examples: \t [WPDiodeLadder.ck](https://chuck.stanford.edu/doc/examples/filter/WPDiodeLadder.ck)" + ], + "description": "Virtual analog low pass filter based on Will Pirkle's Diode Ladder application notes.", + "title": "**WPD Diode Ladder Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#WPDiodeLadder)" + }, + "WPKorg35": { + "functions": [ + "**Methods:**", + "float **cutoff**(float arg) Cuttoff is in Hz [0..Nyquist).", + "float **cutoff**() Get cutoff in Hz [0..Nyquist).", + "int **nonlinear**(int arg) Enable non linear saturator.", + "int **nonlinear**() Get non-linear saturator setting. 1 is enabled.", + "float **resonance**(float arg) Resonance goes between [0...2).", + "float **resonance**() Get resonance [0 - 2).", + "float **saturation**(float arg) Saturation is a scalar gain, and can be used to drive the non-linearity.", + "float **saturation**() Get saturation. Saturation is a scalar gain, and can be used to drive the non-linearity." + ], + "examples": [ + "Examples: \t [WPKorg35.ck](https://chuck.stanford.edu/doc/examples/filter/WPKorg35.ck)" + ], + "description": "Virtual analog low pass filter based on Will Pirkle's Korg35 application notes.", + "title": "**WPD Korg 35 Filter**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#WPKorg35)" + }, + "WarpTable": { + "functions": [ + "**Methods:**", + "float[] **coefs**(float[] v) Set lookup table coefficients." + ], + "examples": [ + "Examples: \t [GenX-WarpTable-test.ck](https://chuck.stanford.edu/doc/examples/special/GenX-WarpTable-test.ck)" + ], + "description": "An end-constrained mapping table, mostly useful for conditioning control signals.", + "title": "**Warp Table**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-advanced.html#WarpTable)" + }, + "WaveLoop": { + "functions": [ + "**Methods:**", + "float **addPhase**(float value) Set offset by phase.", + "float **addPhase**() Get offset by phase.", + "float **addPhaseOffset**(float value) Set phase offset.", + "float **addPhaseOffset**() Get phase offset.", + "float **freq**(float value) Set frequency of playback (loops/second).", + "float **freq**() Get frequency of playback (loops/second)." + ], + "examples": [], + "description": "This class inherits from WvIn and provides audio file looping functionality. WaveLoop supports multi-channel data in interleaved format. It is important to distinguish the `tick()` methods, which return samples produced by averaging across sample frames, from the `tickFrame()` methods, which return pointers to multi-channel sample frames. For single-channel data, these methods return equivalent values. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Audio File Looping**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#WaveLoop)" + }, + "Wekinator": { + "functions": [ + "**Methods:**", + "void **add**() Add current inputs and outputs to the observations.", + "void **add**(float[] inputs, float[] outputs) Add given inputs and outputs to the observations.", + "void **add**(int output_index, float[] inputs, float[] outputs) Add given inputs and outputs to the observations for the specified output.", + "void **clear**() Clear everything except the global properties.", + "void **clearAllObs**() Clear all observations.", + "void **clearAllObs**(int output_index) Clear all observations for the specified output.", + "void **clearObs**(int lo, int hi) Clear the observations by id range.", + "void **clearObs**(int output_index, int lo, int hi) Clear the observations by id range for the specified output.", + "void **deleteLastRound**() Delete the last round of observations.", + "void **exportObs**(string filename) Export the observations to a file.", + "void **exportObs**(int output_index, string filename) Export the observations for the specified output to a file.", + "int **getAllRecordStatus**() Get the record status for all outputs.", + "int **getAllRunStatus**() Get the run status for all outputs.", + "void **getObs**(float[][] obs) Get the observations in the Wekinator.", + "void **getObs**(int output_index, float[][] obs) Get the observations for the specified output in the Wekinator.", + "void **getOutputProperty**(int output_index, string property_name, int[] property_value) Get the output property of the Wekinator. See the Wekinator documentation for more information.", + "float **getOutputPropertyFloat**(int output_index, int property_type, string property_name) Get the output property of the Wekinator. See the Wekinator documentation for more information.", + "int **getOutputPropertyInt**(int output_index, string property_name) Get the output property of the Wekinator. See the Wekinator documentation for more information.", + "int **getOutputPropertyInt**(int output_index, int property_type, string property_name) Get the output property of the Wekinator. See the Wekinator documentation for more information.", + "int **getOutputRecordStatus**(int output_index) Get the record status for the specified output.", + "int **getOutputRunStatus**(int output_index) Get the run status for the specified output.", + "float **getPropertyFloat**(int property_type, string property_name) Get the property of the Wekinator. See the Wekinator documentation for more information.", + "int **getPropertyInt**(int property_type, string property_name) Get the property of the Wekinator. See the Wekinator documentation for more information.", + "int **getRound**() Get the current recording round.", + "void **importObs**(string filename) Import the observations from a file.", + "void **input**(float[] inputs) Set the inputs of the Wekinator.", + "int **inputDims**(int n) Set the number of input dimensions to Wekinator.", + "int **inputDims**() Get the number of input dimensions to Wekinator.", + "void **load**(string filename) Load the Wekinator from a file.", + "int **modelType**(int model_type) Set the model type of the Wekinator. Options: AI.Regression: AI.MLP, AI.LR, AI.Classification: AI.KNN, AI.SVM, AI.DT.", + "int **modelType**() Get the model type id of the Wekinator.", + "string **modelTypeName**() Get the model type name of the Wekinator.", + "void **nextRound**() Bump the recording round.", + "int **numObs**() Get the number of observations in the Wekinator.", + "int **numObs**(int output_index) Get the number of observations for the specified output in the Wekinator.", + "void **output**(float[] outputs) Set the outputs of the Wekinator.", + "int **outputDims**(int n) Set the number of output dimensions to Wekinator.", + "int **outputDims**() Get the number of output dimensions to Wekinator.", + "void **predict**(float[] inputs, float[] outputs) Predict outputs for the given inputs.", + "void **randomizeOutputs**() Randomize the outputs of the Wekinator.", + "void **save**(string filename) Save the Wekinator to a file.", + "void **setAllRecordStatus**(int status) Set the record status for all outputs.", + "void **setAllRunStatus**(int status) Set the run status for all outputs.", + "void **setOutputProperty**(int output_index, string property_name, int property_value) Set the output property of the Wekinator. See the Wekinator documentation for more information.", + "void **setOutputProperty**(int output_index, int property_type, string property_name, int property_value) Set the output property of the Wekinator. See the Wekinator documentation for more information.", + "void **setOutputProperty**(int output_index, int property_type, string property_name, float property_value) Set the output property of the Wekinator. See the Wekinator documentation for more information.", + "void **setOutputProperty**(int output_index, string property_name, int[] property_value) Set the output property of the Wekinator. See the Wekinator documentation for more information.", + "void **setOutputRecordStatus**(int output_index, int status) Set the record status for the specified output.", + "void **setOutputRunStatus**(int output_index, int status) Set the run status for the specified output.", + "void **setProperty**(int property_type, string property_name, int property_value) Set the property of the Wekinator. See the Wekinator documentation for more information.", + "void **setProperty**(int property_type, string property_name, float property_value) Set the property of the Wekinator. See the Wekinator documentation for more information.", + "int **taskType**(int task_type) Set the task type of the Wekinator. Options: AI.Regression, AI.Classification.", + "int **taskType**() Get the task type id of the Wekinator.", + "string **taskTypeName**() Get the task type name of the Wekinator.", + "void **train**() Train models for all outputs." + ], + "examples": [ + "Examples: \t [wekinator-basic.ck](https://chuck.stanford.edu/doc/examples/ai/wekinator/wekinator-basic.ck), [wekinator-customize.ck](https://chuck.stanford.edu/doc/examples/ai/wekinator/wekinator-customize.ck), [wekinator-import.ck](https://chuck.stanford.edu/doc/examples/ai/wekinator/wekinator-import.ck)" + ], + "description": "A Wekinator utility that maps input vectors to output vectors, commonly used for interactive machine learning combining human-computer interaction and ML. Based on Rebecca Fiebrink's Wekinator framework.", + "title": "**Wekinator**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#Wekinator)" + }, + "WinFuncEnv": { + "functions": [ + "**Methods:**", + "dur **attackTime**(dur attackDuration) Set duration of the attack phase.", + "int **keyOff**() Start release phase.", + "int **keyOff**(int keyOff) Start release phase.", + "int **keyOn**() Start attack phase.", + "int **keyOn**(int keyOn) Start attack phase.", + "dur **releaseTime**(dur releaseDuration) Set duration of the release phase.", + "void **setBlackman**() Set Blackman Window Envelope with default value (0.16).", + "void **setBlackman**(float a) Set Blackman Window Envelope with a custom value.", + "void **setBlackmanDerivative**(float a0, float a1, float a2, float a3) Set a custom Blackman Derivative Envelope with custom values.", + "void **setBlackmanHarris**() Set BlackmanHarris Window Envelope.", + "void **setBlackmanNutall**() Set BlackmanNutall Window Envelope.", + "void **setExponential**() Set Exponential Function Envelope with default value (8.69/60.0).", + "void **setExponential**(float a) Set Exponential Function Envleope with a custom value.", + "void **setHann**() Set Hann (Hanning) Window Envelope.", + "void **setHannPoisson**() Set Hann-Poisson Window Envelope with default value (0.5).", + "void **setHannPoisson**(float a) Set Hann-Poisson Window Envelope with a custom value.", + "void **setNutall**() Set Nutall Window Envelope.", + "void **setParzen**() Set Parzen Window Envelope.", + "void **setPoisson**() Set Poisson Window Envelope with default value (6.0).", + "void **setPoisson**(float a) Set Poisson Window Envelope with a custom value.", + "void **setSigmoid**() Set Sigmoid Window Envelope with default value (2.0).", + "void **setSigmoid**(float k) Set Sigmoid Window Envelope with a custom value.", + "void **setTukey**() Set Tukey Window Envelope with default value (0.5).", + "void **setTukey**(float a) Set Tukey Window Envelope with a custom value.", + "void **setWelch**() Set Welch Window Window.", + "float **windowValue**() Get current window value." + ], + "examples": [ + "Examples: \t [WinFuncEnv.ck](https://chuck.stanford.edu/doc/examples/effects/WinFuncEnv.ck)" + ], + "description": "WinFunEnv is an Attack/Release envelope built around window functions!", + "title": "**Window Function Envelope**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/chugins.html#WinFuncEnv)" + }, + "Windowing": { + "functions": [ + "**Methods:**", + "float[] **blackmanHarris**(int size) No description available", + "float[] **hamming**(int size) No description available", + "float[] **hann**(int size) No description available", + "float[] **rectangle**(int size) No description available", + "float[] **triangle**(int size) No description available" + ], + "examples": [ + "Examples: \t [win.ck](https://chuck.stanford.edu/doc/examples/analysis/win.ck), [xsynth.ck](https://chuck.stanford.edu/doc/examples/analysis/xsynth.ck), [pitch-track.ck](https://chuck.stanford.edu/doc/examples/analysis/tracking/pitch-track.ck), [rolloff2.ck](https://chuck.stanford.edu/doc/examples/ai/features/rolloff2.ck), [win.ck](https://chuck.stanford.edu/doc/examples/analysis/win.ck), [feature-extract.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/feature-extract.ck), [genre-classify.ck](https://chuck.stanford.edu/doc/examples/ai/genre-classify/genre-classify.ck)" + ], + "description": "No description available", + "title": "**Windowing Function**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#Windowing)" + }, + "Word2Vec": { + "functions": [ + "**Methods:**", + "int **contains**(string word) Query if 'word' is in the current model.", + "int **dim**() Get number of dimensions for word embedding.", + "int **getSimilar**(string word, int k, string[] output) Get the k most similar words to the given word; return false if 'word' is not in model.", + "int **getSimilar**(float[] vec, int k, string[] output) Get the k most similar words to the given vector.", + "int **getVector**(string word, float[] output) Get the vector of the given word; returns false if 'word' is not in model.", + "int **load**(string path) Load pre-trained word embedding model from the given path.", + "int **load**(string path, int useKDTreeDim) Load pre-trained word embedding model from the given path; will use KDTree for similarity searches if the data dimension is less than or equal to 'useKDTreeDim'. Set 'useKDTreeDim' to 0 to use linear (brute force) similarity search; set 'useKDTreeDim' to less than 0 to always use KDTree.", + "void **minMax**(float[] mins, float[] maxs) Retrieve the minimums and maximums for each dimension.", + "int **size**() Get number of words in dictionary.", + "int **useKDTree**() Get whether a KDTree is used for similarity search." + ], + "examples": [ + "Examples: \t [word2vec-basic.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/word2vec-basic.ck), [poem-i-feel.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/poem-i-feel.ck), [poem-randomwalk.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/poem-randomwalk.ck), [poem-spew.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/poem-spew.ck), [poem-ungenerate.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/poem-ungenerate.ck), [word2vec-prompt.ck](https://chuck.stanford.edu/doc/examples/ai/word2vec/word2vec-prompt.ck)" + ], + "description": "A word embeddings utility that maps words to vectors; can load a model and perform similarity retrieval.", + "title": "**Word2Vec**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ai.html#Word2Vec)" + }, + "Wurley": { + "functions": [], + "examples": [ + "Examples: \t [wurley.ck](https://chuck.stanford.edu/doc/examples/stk/wurley.ck), [wurley2.ck](https://chuck.stanford.edu/doc/examples/stk/wurley2.ck), [wurley3.ck](https://chuck.stanford.edu/doc/examples/stk/wurley3.ck)" + ], + "description": "STK Wurlitzer electric piano FM synthesis instrument. This class implements two simple FM Pairs summed together, also referred to as algorithm 5 of the TX81Z. Algorithm 5 is : 4->3-- + --> Out 2->1-- Control Change Numbers: - Modulator Index One = 2 (.controlOne) - Crossfade of Outputs = 4 (.controlTwo) - LFO Speed = 11 - LFO Depth = 1 - ADSR 2 & 4 Target = 128 The basic Chowning/Stanford FM patent expired in 1995, but there exist follow-on patents, mostly assigned to Yamaha. If you are of the type who should worry about this (making money) worry away. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**STK Wurlitzer**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#Wurley)" + }, + "WvIn": { + "functions": [ + "**Methods:**", + "string **path**(string value) Set file to be played.", + "string **path**() Get file to be played.", + "float **rate**(float value) Set playback rate.", + "float **rate**() Get playback rate." + ], + "examples": [], + "description": "This class provides input support for various audio file formats. It also serves as a base class for 'realtime' streaming subclasses. WvIn loads the contents of an audio file for subsequent output. Linear interpolation is used for fractional 'read rates'. WvIn supports multi-channel data in interleaved format. It is important to distinguish the `tick()` methods, which return samples produced by averaging across sample frames, from the `tickFrame()` methods, which return pointers to multi-channel sample frames. For single-channel data, these methods return equivalent values. Small files are completely read into local memory during instantiation. Large files are read incrementally from disk. The file size threshold and the increment size values are defined in WvIn.h. WvIn currently supports WAV, AIFF, SND (AU), MAT-file (Matlab), and STK RAW file formats. Signed integer (8-, 16-, and 32-bit) and floating-point (32- and 64-bit) data types are supported. Uncompressed data types are not supported. If using MAT-files, data should be saved in an array with each data channel filling a matrix row. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Audio File Input**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#WvIn)" + }, + "WvOut": { + "functions": [ + "**Methods:**", + "string **aifFilename**(string value) Open an AIFF file for writing (with default datatype IO.INT16).", + "string **aifFilename**(string value, int datatype) Open an AIFF file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).", + "string **autoPrefix**(string value) Set auto prefix string for \"special:auto\" filename generation.", + "string **autoPrefix**() Get auto prefix string for \"special:auto\" filename generation.", + "string **closeFile**(string value) Close the file properly.", + "string **closeFile**() Close the file properly.", + "float **fileGain**(float value) Set file gain.", + "float **fileGain**() Get file gain.", + "string **filename**() Get filename.", + "string **matFilename**(string value) Open MATLAB file for writing (with default datatype IO.FLOAT64).", + "string **matFilename**(string value, int datatype) Open MATLAB file for writing; datatype for MATLAB files can only be IO.FLOAT64.", + "string **rawFilename**(string value) Open a RAW file for writing (note: raw audio files are mono and 16-bit).", + "string **rawFilename**(string value, int datatype) Open a RAW file for writing; datatype for raw files can only be IO.INT16.", + "int **record**(int value) Start/stop output.", + "int **record**() Start/stop output.", + "string **sndFilename**(string value) Open SND file for writing (with default datatype IO.INT16).", + "string **sndFilename**(string value, int datatype) Open SND file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64).", + "string **wavFilename**(string value) Open WAVE file for writing (with default datatype IO.INT16).", + "string **wavFilename**(string value, int datatype) Open WAVE file for writing, with datatype (e.g., IO.INT16, IO.INT24, IO.INT32, IO.FLOAT32, IO.FLOAT64)." + ], + "examples": [ + "Examples: \t [rec.ck](https://chuck.stanford.edu/doc/examples/basic/rec.ck), [rec-auto.ck](https://chuck.stanford.edu/doc/examples/basic/rec-auto.ck), [rec-auto-stereo.ck](https://chuck.stanford.edu/doc/examples/basic/rec-auto-stereo.ck), [wvout-24bit.ck](https://chuck.stanford.edu/doc/examples/stk/wvout-24bit.ck)" + ], + "description": "This class provides output support for various audio file formats. It also serves as a base class for 'realtime' streaming subclasses. WvOut writes samples to an audio file. It supports multi-channel data in interleaved format. It is important to distinguish the `tick()` methods, which output single samples to all channels in a sample frame, from the `tickFrame()` method, which takes a pointer to multi-channel sample frame data. WvOut currently supports WAV, AIFF, AIFC, SND (AU), MAT-file (Matlab), and STK RAW file formats. Signed integer (8-, 16-, and 32-bit) and floating- point (32- and 64-bit) data types are supported. STK RAW files use 16-bit integers by definition. MAT-files will always be written as 64-bit floats. If a data type specification does not match the specified file type, the data type will automatically be modified. Uncompressed data types are not supported. Currently, WvOut is non-interpolating and the output rate is always `Stk::sampleRate()`. by Perry R. Cook and Gary P. Scavone, 1995 - 2002.", + "title": "**Audio File Output**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#WvOut)" + }, + "WvOut2": { + "functions": [], + "examples": [ + "Examples: \t [rec.ck](https://chuck.stanford.edu/doc/examples/basic/rec.ck), [rec-auto.ck](https://chuck.stanford.edu/doc/examples/basic/rec-auto.ck), [rec-auto-stereo.ck](https://chuck.stanford.edu/doc/examples/basic/rec-auto-stereo.ck), [wvout-24bit.ck](https://chuck.stanford.edu/doc/examples/stk/wvout-24bit.ck)" + ], + "description": "WvOut2 is the stereo version of WvOut; opens and writes a 2-channel audio file; see WvOut for usage.", + "title": "**Stereo Audio File Output**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/ugens-stk.html#WvOut2)" + }, + "XCorr": { + "functions": [ + "**Methods:**", + "int **normalize**(int flag) No description available", + "int **normalize**() No description available", + "float[] **compute**(float[] f, float[] g, int normalize, float[] y) No description available" + ], + "examples": [ + "Examples: \t [xcorr.ck](https://chuck.stanford.edu/doc/examples/analysis/xcorr.ck)" + ], + "description": "A unit analyzer that computes cross-correlation between two incoming analysis frames.", + "title": "**Cross Correlation**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#XCorr)" + }, + "ZeroX": { + "functions": [ + "**Methods:**", + "float **compute**(float[] input) Manually computes the zero crossing rate for an array." + ], + "examples": [ + "Examples: \t [zerox.ck](https://chuck.stanford.edu/doc/examples/ai/features/zerox.ck)" + ], + "description": "Zero crossing detector.", + "title": "**Zero Crossing Detector**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/uanae.html#ZeroX)" + }, + "string": { + "description": "Textual data as a sequence of characters, along with functions for manipulating text.", + "examples": [ + "Examples: \t [strops.ck](https://chuck.stanford.edu/doc/examples/string/strops.ck), [strops2.ck](https://chuck.stanford.edu/doc/examples/string/strops2.ck), [replace.ck](https://chuck.stanford.edu/doc/examples/string/replace.ck), [token.ck](https://chuck.stanford.edu/doc/examples/string/token.ck), [escape.ck](https://chuck.stanford.edu/doc/examples/string/escape.ck), [tostr.ck](https://chuck.stanford.edu/doc/examples/string/tostr.ck)" + ], + "functions": [ + "**Methods:**", + "int **charAt**(int index) Get a character at the specified index.", + "void **erase**(int start, int length) Erase length characters of the string from start position.", + "int **find**(int theChar) Get the index of the first occurrence of theChar, or -1 if theChar is not found.", + "int **find**(int theChar, int start) Get the index of the first occurrence of theChar at or after the start position, or -1 if theChar is not found.", + "int **find**(string str) Get the index of the first occurrence of str, or -1 if str is not found.", + "int **find**(string str, int start) Get the index of the first occurrence of str at or after the start position, or -1 if str is not found.", + "void **insert**(int position, string str) Insert a string at the specified position.", + "int **length**() Get the number of characters of the string.", + "string **lower**() Get a new string in which the uppercase characters of the original string have been converted to lowercase.", + "string **ltrim**() Get a new string in which leading whitespace has been removed.", + "void **replace**(int position, string str) Replace characters from 'position' with contents of 'str'.", + "void **replace**(int position, int length, string str) Replace 'length' characters from 'position' with contents of 'str'.", + "void **replace**(string from, string to) Replace all instances of 'from' in the string with 'to'.", + "int **rfind**(int theChar) Get the index of the last occurrence of theChar, or -1 if theChar is not found.", + "int **rfind**(int theChar, int start) Get the index of the last occurrence of theChar at or before the start position, or -1 if theChar is not found.", + "int **rfind**(string str) Get the index of the last occurrence of str, or -1 if str is not found.", + "int **rfind**(string str, int start) Get the index of the last occurrence of str at or before the start position, or -1 if str is not found.", + "string **rtrim**() Get a new string in which trailing whitespace has been removed.", + "int **setCharAt**(int index, int theChar) Set the character at the specified index.", + "string **substring**(int start) Get a new string containing the substring from the start index to the end of the string.", + "string **substring**(int start, int length) Get a new string containing the substring from the start index of the specified length.", + "float **toFloat**() Attempt to convert the contents of the string to an float and return the result, or 0 if conversion failed.", + "int **toInt**() Attempt to convert the contents of the string to an integer and return the result, or 0 if conversion failed.", + "string **toString**() Return the reference of calling string.", + "string **trim**() Get a new string in which leading and trailing whitespace has been removed.", + "string **upper**() Get a new string in which the lowercase characters of the original string have been converted to uppercase." + ], + "title": "**String Object**", + "link": "[More...](https://chuck.stanford.edu/doc/reference/base.html#string)" + } +} \ No newline at end of file